From 007b8eb7c46b2b72b9c82c5cfedad0bdedc60a6b Mon Sep 17 00:00:00 2001
From: Jack Jansen <jack.jansen@cwi.nl>
Date: Sat, 3 Jan 2004 17:23:27 +0000
Subject: Added interfaces for most of the stuff in QuickTimeComponents.h.

---
 Mac/Modules/qt/_Qtmodule.c  | 9828 ++++++++++++++++++++++++++++++++++++++++++-
 Mac/Modules/qt/qtscan.py    |   53 +-
 Mac/Modules/qt/qtsupport.py |   42 +-
 3 files changed, 9862 insertions(+), 61 deletions(-)

diff --git a/Mac/Modules/qt/_Qtmodule.c b/Mac/Modules/qt/_Qtmodule.c
index 7d0bd1e..ade8903 100644
--- a/Mac/Modules/qt/_Qtmodule.c
+++ b/Mac/Modules/qt/_Qtmodule.c
@@ -7293,6 +7293,124 @@ PyTypeObject Movie_Type = {
 /* --------------------- End object type Movie ---------------------- */
 
 
+/* ---------------------- Object type SGOutput ---------------------- */
+
+PyTypeObject SGOutput_Type;
+
+#define SGOutputObj_Check(x) ((x)->ob_type == &SGOutput_Type || PyObject_TypeCheck((x), &SGOutput_Type))
+
+typedef struct SGOutputObject {
+	PyObject_HEAD
+	SGOutput ob_itself;
+} SGOutputObject;
+
+PyObject *SGOutputObj_New(SGOutput itself)
+{
+	SGOutputObject *it;
+	if (itself == NULL) {
+						PyErr_SetString(Qt_Error,"Cannot create null SGOutput");
+						return NULL;
+					}
+	it = PyObject_NEW(SGOutputObject, &SGOutput_Type);
+	if (it == NULL) return NULL;
+	it->ob_itself = itself;
+	return (PyObject *)it;
+}
+int SGOutputObj_Convert(PyObject *v, SGOutput *p_itself)
+{
+	if (!SGOutputObj_Check(v))
+	{
+		PyErr_SetString(PyExc_TypeError, "SGOutput required");
+		return 0;
+	}
+	*p_itself = ((SGOutputObject *)v)->ob_itself;
+	return 1;
+}
+
+static void SGOutputObj_dealloc(SGOutputObject *self)
+{
+	/* Cleanup of self->ob_itself goes here */
+	self->ob_type->tp_free((PyObject *)self);
+}
+
+static PyMethodDef SGOutputObj_methods[] = {
+	{NULL, NULL, 0}
+};
+
+#define SGOutputObj_getsetlist NULL
+
+
+#define SGOutputObj_compare NULL
+
+#define SGOutputObj_repr NULL
+
+#define SGOutputObj_hash NULL
+#define SGOutputObj_tp_init 0
+
+#define SGOutputObj_tp_alloc PyType_GenericAlloc
+
+static PyObject *SGOutputObj_tp_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
+{
+	PyObject *self;
+	SGOutput itself;
+	char *kw[] = {"itself", 0};
+
+	if (!PyArg_ParseTupleAndKeywords(args, kwds, "O&", kw, SGOutputObj_Convert, &itself)) return NULL;
+	if ((self = type->tp_alloc(type, 0)) == NULL) return NULL;
+	((SGOutputObject *)self)->ob_itself = itself;
+	return self;
+}
+
+#define SGOutputObj_tp_free PyObject_Del
+
+
+PyTypeObject SGOutput_Type = {
+	PyObject_HEAD_INIT(NULL)
+	0, /*ob_size*/
+	"_Qt.SGOutput", /*tp_name*/
+	sizeof(SGOutputObject), /*tp_basicsize*/
+	0, /*tp_itemsize*/
+	/* methods */
+	(destructor) SGOutputObj_dealloc, /*tp_dealloc*/
+	0, /*tp_print*/
+	(getattrfunc)0, /*tp_getattr*/
+	(setattrfunc)0, /*tp_setattr*/
+	(cmpfunc) SGOutputObj_compare, /*tp_compare*/
+	(reprfunc) SGOutputObj_repr, /*tp_repr*/
+	(PyNumberMethods *)0, /* tp_as_number */
+	(PySequenceMethods *)0, /* tp_as_sequence */
+	(PyMappingMethods *)0, /* tp_as_mapping */
+	(hashfunc) SGOutputObj_hash, /*tp_hash*/
+	0, /*tp_call*/
+	0, /*tp_str*/
+	PyObject_GenericGetAttr, /*tp_getattro*/
+	PyObject_GenericSetAttr, /*tp_setattro */
+	0, /*tp_as_buffer*/
+	Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
+	0, /*tp_doc*/
+	0, /*tp_traverse*/
+	0, /*tp_clear*/
+	0, /*tp_richcompare*/
+	0, /*tp_weaklistoffset*/
+	0, /*tp_iter*/
+	0, /*tp_iternext*/
+	SGOutputObj_methods, /* tp_methods */
+	0, /*tp_members*/
+	SGOutputObj_getsetlist, /*tp_getset*/
+	0, /*tp_base*/
+	0, /*tp_dict*/
+	0, /*tp_descr_get*/
+	0, /*tp_descr_set*/
+	0, /*tp_dictoffset*/
+	SGOutputObj_tp_init, /* tp_init */
+	SGOutputObj_tp_alloc, /* tp_alloc */
+	SGOutputObj_tp_new, /* tp_new */
+	SGOutputObj_tp_free, /* tp_free */
+};
+
+/* -------------------- End object type SGOutput -------------------- */
+
+
 static PyObject *Qt_EnterMovies(PyObject *_self, PyObject *_args)
 {
 	PyObject *_res = NULL;
@@ -14088,86 +14206,8877 @@ static PyObject *Qt_ImageTranscoderEndSequence(PyObject *_self, PyObject *_args)
 	return _res;
 }
 
-static PyObject *Qt_AlignWindow(PyObject *_self, PyObject *_args)
+static PyObject *Qt_ClockGetTime(PyObject *_self, PyObject *_args)
 {
 	PyObject *_res = NULL;
-	WindowPtr wp;
-	Boolean front;
-#ifndef AlignWindow
-	PyMac_PRECHECK(AlignWindow);
+	ComponentResult _rv;
+	ComponentInstance aClock;
+	TimeRecord out;
+#ifndef ClockGetTime
+	PyMac_PRECHECK(ClockGetTime);
 #endif
-	if (!PyArg_ParseTuple(_args, "O&b",
-	                      WinObj_Convert, &wp,
-	                      &front))
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpInstObj_Convert, &aClock))
 		return NULL;
-	AlignWindow(wp,
-	            front,
-	            (Rect *)0,
-	            (ICMAlignmentProcRecordPtr)0);
-	Py_INCREF(Py_None);
-	_res = Py_None;
+	_rv = ClockGetTime(aClock,
+	                   &out);
+	_res = Py_BuildValue("lO&",
+	                     _rv,
+	                     QtTimeRecord_New, &out);
 	return _res;
 }
 
-static PyObject *Qt_DragAlignedWindow(PyObject *_self, PyObject *_args)
+static PyObject *Qt_ClockSetTimeBase(PyObject *_self, PyObject *_args)
 {
 	PyObject *_res = NULL;
-	WindowPtr wp;
-	Point startPt;
-	Rect boundsRect;
-#ifndef DragAlignedWindow
-	PyMac_PRECHECK(DragAlignedWindow);
+	ComponentResult _rv;
+	ComponentInstance aClock;
+	TimeBase tb;
+#ifndef ClockSetTimeBase
+	PyMac_PRECHECK(ClockSetTimeBase);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&O&",
+	                      CmpInstObj_Convert, &aClock,
+	                      TimeBaseObj_Convert, &tb))
+		return NULL;
+	_rv = ClockSetTimeBase(aClock,
+	                       tb);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_ClockGetRate(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	ComponentInstance aClock;
+	Fixed rate;
+#ifndef ClockGetRate
+	PyMac_PRECHECK(ClockGetRate);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpInstObj_Convert, &aClock))
+		return NULL;
+	_rv = ClockGetRate(aClock,
+	                   &rate);
+	_res = Py_BuildValue("lO&",
+	                     _rv,
+	                     PyMac_BuildFixed, rate);
+	return _res;
+}
+
+static PyObject *Qt_SCPositionRect(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	ComponentInstance ci;
+	Rect rp;
+	Point where;
+#ifndef SCPositionRect
+	PyMac_PRECHECK(SCPositionRect);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpInstObj_Convert, &ci))
+		return NULL;
+	_rv = SCPositionRect(ci,
+	                     &rp,
+	                     &where);
+	_res = Py_BuildValue("lO&O&",
+	                     _rv,
+	                     PyMac_BuildRect, &rp,
+	                     PyMac_BuildPoint, where);
+	return _res;
+}
+
+static PyObject *Qt_SCPositionDialog(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	ComponentInstance ci;
+	short id;
+	Point where;
+#ifndef SCPositionDialog
+	PyMac_PRECHECK(SCPositionDialog);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&h",
+	                      CmpInstObj_Convert, &ci,
+	                      &id))
+		return NULL;
+	_rv = SCPositionDialog(ci,
+	                       id,
+	                       &where);
+	_res = Py_BuildValue("lO&",
+	                     _rv,
+	                     PyMac_BuildPoint, where);
+	return _res;
+}
+
+static PyObject *Qt_SCSetTestImagePictHandle(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	ComponentInstance ci;
+	PicHandle testPict;
+	Rect testRect;
+	short testFlags;
+#ifndef SCSetTestImagePictHandle
+	PyMac_PRECHECK(SCSetTestImagePictHandle);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&O&h",
+	                      CmpInstObj_Convert, &ci,
+	                      ResObj_Convert, &testPict,
+	                      &testFlags))
+		return NULL;
+	_rv = SCSetTestImagePictHandle(ci,
+	                               testPict,
+	                               &testRect,
+	                               testFlags);
+	_res = Py_BuildValue("lO&",
+	                     _rv,
+	                     PyMac_BuildRect, &testRect);
+	return _res;
+}
+
+static PyObject *Qt_SCSetTestImagePictFile(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	ComponentInstance ci;
+	short testFileRef;
+	Rect testRect;
+	short testFlags;
+#ifndef SCSetTestImagePictFile
+	PyMac_PRECHECK(SCSetTestImagePictFile);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&hh",
+	                      CmpInstObj_Convert, &ci,
+	                      &testFileRef,
+	                      &testFlags))
+		return NULL;
+	_rv = SCSetTestImagePictFile(ci,
+	                             testFileRef,
+	                             &testRect,
+	                             testFlags);
+	_res = Py_BuildValue("lO&",
+	                     _rv,
+	                     PyMac_BuildRect, &testRect);
+	return _res;
+}
+
+static PyObject *Qt_SCSetTestImagePixMap(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	ComponentInstance ci;
+	PixMapHandle testPixMap;
+	Rect testRect;
+	short testFlags;
+#ifndef SCSetTestImagePixMap
+	PyMac_PRECHECK(SCSetTestImagePixMap);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&O&h",
+	                      CmpInstObj_Convert, &ci,
+	                      ResObj_Convert, &testPixMap,
+	                      &testFlags))
+		return NULL;
+	_rv = SCSetTestImagePixMap(ci,
+	                           testPixMap,
+	                           &testRect,
+	                           testFlags);
+	_res = Py_BuildValue("lO&",
+	                     _rv,
+	                     PyMac_BuildRect, &testRect);
+	return _res;
+}
+
+static PyObject *Qt_SCGetBestDeviceRect(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	ComponentInstance ci;
+	Rect r;
+#ifndef SCGetBestDeviceRect
+	PyMac_PRECHECK(SCGetBestDeviceRect);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpInstObj_Convert, &ci))
+		return NULL;
+	_rv = SCGetBestDeviceRect(ci,
+	                          &r);
+	_res = Py_BuildValue("lO&",
+	                     _rv,
+	                     PyMac_BuildRect, &r);
+	return _res;
+}
+
+static PyObject *Qt_SCRequestImageSettings(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	ComponentInstance ci;
+#ifndef SCRequestImageSettings
+	PyMac_PRECHECK(SCRequestImageSettings);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpInstObj_Convert, &ci))
+		return NULL;
+	_rv = SCRequestImageSettings(ci);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_SCCompressImage(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	ComponentInstance ci;
+	PixMapHandle src;
+	Rect srcRect;
+	ImageDescriptionHandle desc;
+	Handle data;
+#ifndef SCCompressImage
+	PyMac_PRECHECK(SCCompressImage);
 #endif
 	if (!PyArg_ParseTuple(_args, "O&O&O&",
-	                      WinObj_Convert, &wp,
-	                      PyMac_GetPoint, &startPt,
-	                      PyMac_GetRect, &boundsRect))
+	                      CmpInstObj_Convert, &ci,
+	                      ResObj_Convert, &src,
+	                      PyMac_GetRect, &srcRect))
 		return NULL;
-	DragAlignedWindow(wp,
-	                  startPt,
-	                  &boundsRect,
-	                  (Rect *)0,
-	                  (ICMAlignmentProcRecordPtr)0);
-	Py_INCREF(Py_None);
-	_res = Py_None;
+	_rv = SCCompressImage(ci,
+	                      src,
+	                      &srcRect,
+	                      &desc,
+	                      &data);
+	_res = Py_BuildValue("lO&O&",
+	                     _rv,
+	                     ResObj_New, desc,
+	                     ResObj_New, data);
 	return _res;
 }
 
-static PyObject *Qt_MoviesTask(PyObject *_self, PyObject *_args)
+static PyObject *Qt_SCCompressPicture(PyObject *_self, PyObject *_args)
 {
 	PyObject *_res = NULL;
-	long maxMilliSecToUse;
-#ifndef MoviesTask
-	PyMac_PRECHECK(MoviesTask);
+	ComponentResult _rv;
+	ComponentInstance ci;
+	PicHandle srcPicture;
+	PicHandle dstPicture;
+#ifndef SCCompressPicture
+	PyMac_PRECHECK(SCCompressPicture);
 #endif
-	if (!PyArg_ParseTuple(_args, "l",
-	                      &maxMilliSecToUse))
+	if (!PyArg_ParseTuple(_args, "O&O&O&",
+	                      CmpInstObj_Convert, &ci,
+	                      ResObj_Convert, &srcPicture,
+	                      ResObj_Convert, &dstPicture))
 		return NULL;
-	MoviesTask((Movie)0,
-	           maxMilliSecToUse);
-	Py_INCREF(Py_None);
-	_res = Py_None;
+	_rv = SCCompressPicture(ci,
+	                        srcPicture,
+	                        dstPicture);
+	_res = Py_BuildValue("l",
+	                     _rv);
 	return _res;
 }
 
-static PyMethodDef Qt_methods[] = {
-	{"EnterMovies", (PyCFunction)Qt_EnterMovies, 1,
-	 PyDoc_STR("() -> None")},
-	{"ExitMovies", (PyCFunction)Qt_ExitMovies, 1,
-	 PyDoc_STR("() -> None")},
-	{"GetMoviesError", (PyCFunction)Qt_GetMoviesError, 1,
-	 PyDoc_STR("() -> None")},
-	{"ClearMoviesStickyError", (PyCFunction)Qt_ClearMoviesStickyError, 1,
-	 PyDoc_STR("() -> None")},
-	{"GetMoviesStickyError", (PyCFunction)Qt_GetMoviesStickyError, 1,
-	 PyDoc_STR("() -> None")},
-	{"QTGetWallClockTimeBase", (PyCFunction)Qt_QTGetWallClockTimeBase, 1,
-	 PyDoc_STR("() -> (TimeBase wallClockTimeBase)")},
-	{"QTIdleManagerOpen", (PyCFunction)Qt_QTIdleManagerOpen, 1,
-	 PyDoc_STR("() -> (IdleManager _rv)")},
-	{"CreateMovieControl", (PyCFunction)Qt_CreateMovieControl, 1,
-	 PyDoc_STR("(WindowPtr theWindow, Movie theMovie, UInt32 options) -> (Rect localRect, ControlHandle returnedControl)")},
-	{"DisposeMatte", (PyCFunction)Qt_DisposeMatte, 1,
+static PyObject *Qt_SCCompressPictureFile(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	ComponentInstance ci;
+	short srcRefNum;
+	short dstRefNum;
+#ifndef SCCompressPictureFile
+	PyMac_PRECHECK(SCCompressPictureFile);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&hh",
+	                      CmpInstObj_Convert, &ci,
+	                      &srcRefNum,
+	                      &dstRefNum))
+		return NULL;
+	_rv = SCCompressPictureFile(ci,
+	                            srcRefNum,
+	                            dstRefNum);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_SCRequestSequenceSettings(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	ComponentInstance ci;
+#ifndef SCRequestSequenceSettings
+	PyMac_PRECHECK(SCRequestSequenceSettings);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpInstObj_Convert, &ci))
+		return NULL;
+	_rv = SCRequestSequenceSettings(ci);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_SCCompressSequenceBegin(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	ComponentInstance ci;
+	PixMapHandle src;
+	Rect srcRect;
+	ImageDescriptionHandle desc;
+#ifndef SCCompressSequenceBegin
+	PyMac_PRECHECK(SCCompressSequenceBegin);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&O&O&",
+	                      CmpInstObj_Convert, &ci,
+	                      ResObj_Convert, &src,
+	                      PyMac_GetRect, &srcRect))
+		return NULL;
+	_rv = SCCompressSequenceBegin(ci,
+	                              src,
+	                              &srcRect,
+	                              &desc);
+	_res = Py_BuildValue("lO&",
+	                     _rv,
+	                     ResObj_New, desc);
+	return _res;
+}
+
+static PyObject *Qt_SCCompressSequenceFrame(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	ComponentInstance ci;
+	PixMapHandle src;
+	Rect srcRect;
+	Handle data;
+	long dataSize;
+	short notSyncFlag;
+#ifndef SCCompressSequenceFrame
+	PyMac_PRECHECK(SCCompressSequenceFrame);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&O&O&",
+	                      CmpInstObj_Convert, &ci,
+	                      ResObj_Convert, &src,
+	                      PyMac_GetRect, &srcRect))
+		return NULL;
+	_rv = SCCompressSequenceFrame(ci,
+	                              src,
+	                              &srcRect,
+	                              &data,
+	                              &dataSize,
+	                              &notSyncFlag);
+	_res = Py_BuildValue("lO&lh",
+	                     _rv,
+	                     ResObj_New, data,
+	                     dataSize,
+	                     notSyncFlag);
+	return _res;
+}
+
+static PyObject *Qt_SCCompressSequenceEnd(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	ComponentInstance ci;
+#ifndef SCCompressSequenceEnd
+	PyMac_PRECHECK(SCCompressSequenceEnd);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpInstObj_Convert, &ci))
+		return NULL;
+	_rv = SCCompressSequenceEnd(ci);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_SCDefaultPictHandleSettings(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	ComponentInstance ci;
+	PicHandle srcPicture;
+	short motion;
+#ifndef SCDefaultPictHandleSettings
+	PyMac_PRECHECK(SCDefaultPictHandleSettings);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&O&h",
+	                      CmpInstObj_Convert, &ci,
+	                      ResObj_Convert, &srcPicture,
+	                      &motion))
+		return NULL;
+	_rv = SCDefaultPictHandleSettings(ci,
+	                                  srcPicture,
+	                                  motion);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_SCDefaultPictFileSettings(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	ComponentInstance ci;
+	short srcRef;
+	short motion;
+#ifndef SCDefaultPictFileSettings
+	PyMac_PRECHECK(SCDefaultPictFileSettings);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&hh",
+	                      CmpInstObj_Convert, &ci,
+	                      &srcRef,
+	                      &motion))
+		return NULL;
+	_rv = SCDefaultPictFileSettings(ci,
+	                                srcRef,
+	                                motion);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_SCDefaultPixMapSettings(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	ComponentInstance ci;
+	PixMapHandle src;
+	short motion;
+#ifndef SCDefaultPixMapSettings
+	PyMac_PRECHECK(SCDefaultPixMapSettings);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&O&h",
+	                      CmpInstObj_Convert, &ci,
+	                      ResObj_Convert, &src,
+	                      &motion))
+		return NULL;
+	_rv = SCDefaultPixMapSettings(ci,
+	                              src,
+	                              motion);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_SCGetInfo(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	ComponentInstance ci;
+	OSType infoType;
+	void * info;
+#ifndef SCGetInfo
+	PyMac_PRECHECK(SCGetInfo);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&O&s",
+	                      CmpInstObj_Convert, &ci,
+	                      PyMac_GetOSType, &infoType,
+	                      &info))
+		return NULL;
+	_rv = SCGetInfo(ci,
+	                infoType,
+	                info);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_SCSetInfo(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	ComponentInstance ci;
+	OSType infoType;
+	void * info;
+#ifndef SCSetInfo
+	PyMac_PRECHECK(SCSetInfo);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&O&s",
+	                      CmpInstObj_Convert, &ci,
+	                      PyMac_GetOSType, &infoType,
+	                      &info))
+		return NULL;
+	_rv = SCSetInfo(ci,
+	                infoType,
+	                info);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_SCSetCompressFlags(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	ComponentInstance ci;
+	long flags;
+#ifndef SCSetCompressFlags
+	PyMac_PRECHECK(SCSetCompressFlags);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&l",
+	                      CmpInstObj_Convert, &ci,
+	                      &flags))
+		return NULL;
+	_rv = SCSetCompressFlags(ci,
+	                         flags);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_SCGetCompressFlags(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	ComponentInstance ci;
+	long flags;
+#ifndef SCGetCompressFlags
+	PyMac_PRECHECK(SCGetCompressFlags);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpInstObj_Convert, &ci))
+		return NULL;
+	_rv = SCGetCompressFlags(ci,
+	                         &flags);
+	_res = Py_BuildValue("ll",
+	                     _rv,
+	                     flags);
+	return _res;
+}
+
+static PyObject *Qt_SCGetSettingsAsText(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	ComponentInstance ci;
+	Handle text;
+#ifndef SCGetSettingsAsText
+	PyMac_PRECHECK(SCGetSettingsAsText);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpInstObj_Convert, &ci))
+		return NULL;
+	_rv = SCGetSettingsAsText(ci,
+	                          &text);
+	_res = Py_BuildValue("lO&",
+	                     _rv,
+	                     ResObj_New, text);
+	return _res;
+}
+
+static PyObject *Qt_SCAsyncIdle(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	ComponentInstance ci;
+#ifndef SCAsyncIdle
+	PyMac_PRECHECK(SCAsyncIdle);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpInstObj_Convert, &ci))
+		return NULL;
+	_rv = SCAsyncIdle(ci);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_TweenerReset(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	TweenerComponent tc;
+#ifndef TweenerReset
+	PyMac_PRECHECK(TweenerReset);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpObj_Convert, &tc))
+		return NULL;
+	_rv = TweenerReset(tc);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_TCGetSourceRef(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	HandlerError _rv;
+	MediaHandler mh;
+	TimeCodeDescriptionHandle tcdH;
+	UserData srefH;
+#ifndef TCGetSourceRef
+	PyMac_PRECHECK(TCGetSourceRef);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&O&",
+	                      CmpInstObj_Convert, &mh,
+	                      ResObj_Convert, &tcdH))
+		return NULL;
+	_rv = TCGetSourceRef(mh,
+	                     tcdH,
+	                     &srefH);
+	_res = Py_BuildValue("lO&",
+	                     _rv,
+	                     UserDataObj_New, srefH);
+	return _res;
+}
+
+static PyObject *Qt_TCSetSourceRef(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	HandlerError _rv;
+	MediaHandler mh;
+	TimeCodeDescriptionHandle tcdH;
+	UserData srefH;
+#ifndef TCSetSourceRef
+	PyMac_PRECHECK(TCSetSourceRef);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&O&O&",
+	                      CmpInstObj_Convert, &mh,
+	                      ResObj_Convert, &tcdH,
+	                      UserDataObj_Convert, &srefH))
+		return NULL;
+	_rv = TCSetSourceRef(mh,
+	                     tcdH,
+	                     srefH);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_TCSetTimeCodeFlags(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	HandlerError _rv;
+	MediaHandler mh;
+	long flags;
+	long flagsMask;
+#ifndef TCSetTimeCodeFlags
+	PyMac_PRECHECK(TCSetTimeCodeFlags);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&ll",
+	                      CmpInstObj_Convert, &mh,
+	                      &flags,
+	                      &flagsMask))
+		return NULL;
+	_rv = TCSetTimeCodeFlags(mh,
+	                         flags,
+	                         flagsMask);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_TCGetTimeCodeFlags(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	HandlerError _rv;
+	MediaHandler mh;
+	long flags;
+#ifndef TCGetTimeCodeFlags
+	PyMac_PRECHECK(TCGetTimeCodeFlags);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpInstObj_Convert, &mh))
+		return NULL;
+	_rv = TCGetTimeCodeFlags(mh,
+	                         &flags);
+	_res = Py_BuildValue("ll",
+	                     _rv,
+	                     flags);
+	return _res;
+}
+
+static PyObject *Qt_MovieImportHandle(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	MovieImportComponent ci;
+	Handle dataH;
+	Movie theMovie;
+	Track targetTrack;
+	Track usedTrack;
+	TimeValue atTime;
+	TimeValue addedDuration;
+	long inFlags;
+	long outFlags;
+#ifndef MovieImportHandle
+	PyMac_PRECHECK(MovieImportHandle);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&O&O&O&ll",
+	                      CmpObj_Convert, &ci,
+	                      ResObj_Convert, &dataH,
+	                      MovieObj_Convert, &theMovie,
+	                      TrackObj_Convert, &targetTrack,
+	                      &atTime,
+	                      &inFlags))
+		return NULL;
+	_rv = MovieImportHandle(ci,
+	                        dataH,
+	                        theMovie,
+	                        targetTrack,
+	                        &usedTrack,
+	                        atTime,
+	                        &addedDuration,
+	                        inFlags,
+	                        &outFlags);
+	_res = Py_BuildValue("lO&ll",
+	                     _rv,
+	                     TrackObj_New, usedTrack,
+	                     addedDuration,
+	                     outFlags);
+	return _res;
+}
+
+static PyObject *Qt_MovieImportFile(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	MovieImportComponent ci;
+	FSSpec theFile;
+	Movie theMovie;
+	Track targetTrack;
+	Track usedTrack;
+	TimeValue atTime;
+	TimeValue addedDuration;
+	long inFlags;
+	long outFlags;
+#ifndef MovieImportFile
+	PyMac_PRECHECK(MovieImportFile);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&O&O&O&ll",
+	                      CmpObj_Convert, &ci,
+	                      PyMac_GetFSSpec, &theFile,
+	                      MovieObj_Convert, &theMovie,
+	                      TrackObj_Convert, &targetTrack,
+	                      &atTime,
+	                      &inFlags))
+		return NULL;
+	_rv = MovieImportFile(ci,
+	                      &theFile,
+	                      theMovie,
+	                      targetTrack,
+	                      &usedTrack,
+	                      atTime,
+	                      &addedDuration,
+	                      inFlags,
+	                      &outFlags);
+	_res = Py_BuildValue("lO&ll",
+	                     _rv,
+	                     TrackObj_New, usedTrack,
+	                     addedDuration,
+	                     outFlags);
+	return _res;
+}
+
+static PyObject *Qt_MovieImportSetSampleDuration(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	MovieImportComponent ci;
+	TimeValue duration;
+	TimeScale scale;
+#ifndef MovieImportSetSampleDuration
+	PyMac_PRECHECK(MovieImportSetSampleDuration);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&ll",
+	                      CmpObj_Convert, &ci,
+	                      &duration,
+	                      &scale))
+		return NULL;
+	_rv = MovieImportSetSampleDuration(ci,
+	                                   duration,
+	                                   scale);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_MovieImportSetSampleDescription(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	MovieImportComponent ci;
+	SampleDescriptionHandle desc;
+	OSType mediaType;
+#ifndef MovieImportSetSampleDescription
+	PyMac_PRECHECK(MovieImportSetSampleDescription);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&O&O&",
+	                      CmpObj_Convert, &ci,
+	                      ResObj_Convert, &desc,
+	                      PyMac_GetOSType, &mediaType))
+		return NULL;
+	_rv = MovieImportSetSampleDescription(ci,
+	                                      desc,
+	                                      mediaType);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_MovieImportSetMediaFile(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	MovieImportComponent ci;
+	AliasHandle alias;
+#ifndef MovieImportSetMediaFile
+	PyMac_PRECHECK(MovieImportSetMediaFile);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&O&",
+	                      CmpObj_Convert, &ci,
+	                      ResObj_Convert, &alias))
+		return NULL;
+	_rv = MovieImportSetMediaFile(ci,
+	                              alias);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_MovieImportSetDimensions(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	MovieImportComponent ci;
+	Fixed width;
+	Fixed height;
+#ifndef MovieImportSetDimensions
+	PyMac_PRECHECK(MovieImportSetDimensions);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&O&O&",
+	                      CmpObj_Convert, &ci,
+	                      PyMac_GetFixed, &width,
+	                      PyMac_GetFixed, &height))
+		return NULL;
+	_rv = MovieImportSetDimensions(ci,
+	                               width,
+	                               height);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_MovieImportSetChunkSize(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	MovieImportComponent ci;
+	long chunkSize;
+#ifndef MovieImportSetChunkSize
+	PyMac_PRECHECK(MovieImportSetChunkSize);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&l",
+	                      CmpObj_Convert, &ci,
+	                      &chunkSize))
+		return NULL;
+	_rv = MovieImportSetChunkSize(ci,
+	                              chunkSize);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_MovieImportSetAuxiliaryData(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	MovieImportComponent ci;
+	Handle data;
+	OSType handleType;
+#ifndef MovieImportSetAuxiliaryData
+	PyMac_PRECHECK(MovieImportSetAuxiliaryData);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&O&O&",
+	                      CmpObj_Convert, &ci,
+	                      ResObj_Convert, &data,
+	                      PyMac_GetOSType, &handleType))
+		return NULL;
+	_rv = MovieImportSetAuxiliaryData(ci,
+	                                  data,
+	                                  handleType);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_MovieImportSetFromScrap(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	MovieImportComponent ci;
+	Boolean fromScrap;
+#ifndef MovieImportSetFromScrap
+	PyMac_PRECHECK(MovieImportSetFromScrap);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&b",
+	                      CmpObj_Convert, &ci,
+	                      &fromScrap))
+		return NULL;
+	_rv = MovieImportSetFromScrap(ci,
+	                              fromScrap);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_MovieImportDoUserDialog(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	MovieImportComponent ci;
+	FSSpec theFile;
+	Handle theData;
+	Boolean canceled;
+#ifndef MovieImportDoUserDialog
+	PyMac_PRECHECK(MovieImportDoUserDialog);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&O&O&",
+	                      CmpObj_Convert, &ci,
+	                      PyMac_GetFSSpec, &theFile,
+	                      ResObj_Convert, &theData))
+		return NULL;
+	_rv = MovieImportDoUserDialog(ci,
+	                              &theFile,
+	                              theData,
+	                              &canceled);
+	_res = Py_BuildValue("lb",
+	                     _rv,
+	                     canceled);
+	return _res;
+}
+
+static PyObject *Qt_MovieImportSetDuration(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	MovieImportComponent ci;
+	TimeValue duration;
+#ifndef MovieImportSetDuration
+	PyMac_PRECHECK(MovieImportSetDuration);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&l",
+	                      CmpObj_Convert, &ci,
+	                      &duration))
+		return NULL;
+	_rv = MovieImportSetDuration(ci,
+	                             duration);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_MovieImportGetAuxiliaryDataType(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	MovieImportComponent ci;
+	OSType auxType;
+#ifndef MovieImportGetAuxiliaryDataType
+	PyMac_PRECHECK(MovieImportGetAuxiliaryDataType);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpObj_Convert, &ci))
+		return NULL;
+	_rv = MovieImportGetAuxiliaryDataType(ci,
+	                                      &auxType);
+	_res = Py_BuildValue("lO&",
+	                     _rv,
+	                     PyMac_BuildOSType, auxType);
+	return _res;
+}
+
+static PyObject *Qt_MovieImportValidate(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	MovieImportComponent ci;
+	FSSpec theFile;
+	Handle theData;
+	Boolean valid;
+#ifndef MovieImportValidate
+	PyMac_PRECHECK(MovieImportValidate);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&O&O&",
+	                      CmpObj_Convert, &ci,
+	                      PyMac_GetFSSpec, &theFile,
+	                      ResObj_Convert, &theData))
+		return NULL;
+	_rv = MovieImportValidate(ci,
+	                          &theFile,
+	                          theData,
+	                          &valid);
+	_res = Py_BuildValue("lb",
+	                     _rv,
+	                     valid);
+	return _res;
+}
+
+static PyObject *Qt_MovieImportGetFileType(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	MovieImportComponent ci;
+	OSType fileType;
+#ifndef MovieImportGetFileType
+	PyMac_PRECHECK(MovieImportGetFileType);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpObj_Convert, &ci))
+		return NULL;
+	_rv = MovieImportGetFileType(ci,
+	                             &fileType);
+	_res = Py_BuildValue("lO&",
+	                     _rv,
+	                     PyMac_BuildOSType, fileType);
+	return _res;
+}
+
+static PyObject *Qt_MovieImportDataRef(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	MovieImportComponent ci;
+	Handle dataRef;
+	OSType dataRefType;
+	Movie theMovie;
+	Track targetTrack;
+	Track usedTrack;
+	TimeValue atTime;
+	TimeValue addedDuration;
+	long inFlags;
+	long outFlags;
+#ifndef MovieImportDataRef
+	PyMac_PRECHECK(MovieImportDataRef);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&O&O&O&O&ll",
+	                      CmpObj_Convert, &ci,
+	                      ResObj_Convert, &dataRef,
+	                      PyMac_GetOSType, &dataRefType,
+	                      MovieObj_Convert, &theMovie,
+	                      TrackObj_Convert, &targetTrack,
+	                      &atTime,
+	                      &inFlags))
+		return NULL;
+	_rv = MovieImportDataRef(ci,
+	                         dataRef,
+	                         dataRefType,
+	                         theMovie,
+	                         targetTrack,
+	                         &usedTrack,
+	                         atTime,
+	                         &addedDuration,
+	                         inFlags,
+	                         &outFlags);
+	_res = Py_BuildValue("lO&ll",
+	                     _rv,
+	                     TrackObj_New, usedTrack,
+	                     addedDuration,
+	                     outFlags);
+	return _res;
+}
+
+static PyObject *Qt_MovieImportGetSampleDescription(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	MovieImportComponent ci;
+	SampleDescriptionHandle desc;
+	OSType mediaType;
+#ifndef MovieImportGetSampleDescription
+	PyMac_PRECHECK(MovieImportGetSampleDescription);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpObj_Convert, &ci))
+		return NULL;
+	_rv = MovieImportGetSampleDescription(ci,
+	                                      &desc,
+	                                      &mediaType);
+	_res = Py_BuildValue("lO&O&",
+	                     _rv,
+	                     ResObj_New, desc,
+	                     PyMac_BuildOSType, mediaType);
+	return _res;
+}
+
+static PyObject *Qt_MovieImportSetOffsetAndLimit(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	MovieImportComponent ci;
+	unsigned long offset;
+	unsigned long limit;
+#ifndef MovieImportSetOffsetAndLimit
+	PyMac_PRECHECK(MovieImportSetOffsetAndLimit);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&ll",
+	                      CmpObj_Convert, &ci,
+	                      &offset,
+	                      &limit))
+		return NULL;
+	_rv = MovieImportSetOffsetAndLimit(ci,
+	                                   offset,
+	                                   limit);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_MovieImportSetOffsetAndLimit64(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	MovieImportComponent ci;
+	wide offset;
+	wide limit;
+#ifndef MovieImportSetOffsetAndLimit64
+	PyMac_PRECHECK(MovieImportSetOffsetAndLimit64);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&O&O&",
+	                      CmpObj_Convert, &ci,
+	                      PyMac_Getwide, &offset,
+	                      PyMac_Getwide, &limit))
+		return NULL;
+	_rv = MovieImportSetOffsetAndLimit64(ci,
+	                                     &offset,
+	                                     &limit);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_MovieImportIdle(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	MovieImportComponent ci;
+	long inFlags;
+	long outFlags;
+#ifndef MovieImportIdle
+	PyMac_PRECHECK(MovieImportIdle);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&l",
+	                      CmpObj_Convert, &ci,
+	                      &inFlags))
+		return NULL;
+	_rv = MovieImportIdle(ci,
+	                      inFlags,
+	                      &outFlags);
+	_res = Py_BuildValue("ll",
+	                     _rv,
+	                     outFlags);
+	return _res;
+}
+
+static PyObject *Qt_MovieImportValidateDataRef(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	MovieImportComponent ci;
+	Handle dataRef;
+	OSType dataRefType;
+	UInt8 valid;
+#ifndef MovieImportValidateDataRef
+	PyMac_PRECHECK(MovieImportValidateDataRef);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&O&O&",
+	                      CmpObj_Convert, &ci,
+	                      ResObj_Convert, &dataRef,
+	                      PyMac_GetOSType, &dataRefType))
+		return NULL;
+	_rv = MovieImportValidateDataRef(ci,
+	                                 dataRef,
+	                                 dataRefType,
+	                                 &valid);
+	_res = Py_BuildValue("lb",
+	                     _rv,
+	                     valid);
+	return _res;
+}
+
+static PyObject *Qt_MovieImportGetLoadState(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	MovieImportComponent ci;
+	long importerLoadState;
+#ifndef MovieImportGetLoadState
+	PyMac_PRECHECK(MovieImportGetLoadState);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpObj_Convert, &ci))
+		return NULL;
+	_rv = MovieImportGetLoadState(ci,
+	                              &importerLoadState);
+	_res = Py_BuildValue("ll",
+	                     _rv,
+	                     importerLoadState);
+	return _res;
+}
+
+static PyObject *Qt_MovieImportGetMaxLoadedTime(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	MovieImportComponent ci;
+	TimeValue time;
+#ifndef MovieImportGetMaxLoadedTime
+	PyMac_PRECHECK(MovieImportGetMaxLoadedTime);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpObj_Convert, &ci))
+		return NULL;
+	_rv = MovieImportGetMaxLoadedTime(ci,
+	                                  &time);
+	_res = Py_BuildValue("ll",
+	                     _rv,
+	                     time);
+	return _res;
+}
+
+static PyObject *Qt_MovieImportEstimateCompletionTime(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	MovieImportComponent ci;
+	TimeRecord time;
+#ifndef MovieImportEstimateCompletionTime
+	PyMac_PRECHECK(MovieImportEstimateCompletionTime);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpObj_Convert, &ci))
+		return NULL;
+	_rv = MovieImportEstimateCompletionTime(ci,
+	                                        &time);
+	_res = Py_BuildValue("lO&",
+	                     _rv,
+	                     QtTimeRecord_New, &time);
+	return _res;
+}
+
+static PyObject *Qt_MovieImportSetDontBlock(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	MovieImportComponent ci;
+	Boolean dontBlock;
+#ifndef MovieImportSetDontBlock
+	PyMac_PRECHECK(MovieImportSetDontBlock);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&b",
+	                      CmpObj_Convert, &ci,
+	                      &dontBlock))
+		return NULL;
+	_rv = MovieImportSetDontBlock(ci,
+	                              dontBlock);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_MovieImportGetDontBlock(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	MovieImportComponent ci;
+	Boolean willBlock;
+#ifndef MovieImportGetDontBlock
+	PyMac_PRECHECK(MovieImportGetDontBlock);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpObj_Convert, &ci))
+		return NULL;
+	_rv = MovieImportGetDontBlock(ci,
+	                              &willBlock);
+	_res = Py_BuildValue("lb",
+	                     _rv,
+	                     willBlock);
+	return _res;
+}
+
+static PyObject *Qt_MovieImportSetIdleManager(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	MovieImportComponent ci;
+	IdleManager im;
+#ifndef MovieImportSetIdleManager
+	PyMac_PRECHECK(MovieImportSetIdleManager);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&O&",
+	                      CmpObj_Convert, &ci,
+	                      IdleManagerObj_Convert, &im))
+		return NULL;
+	_rv = MovieImportSetIdleManager(ci,
+	                                im);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_MovieImportSetNewMovieFlags(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	MovieImportComponent ci;
+	long newMovieFlags;
+#ifndef MovieImportSetNewMovieFlags
+	PyMac_PRECHECK(MovieImportSetNewMovieFlags);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&l",
+	                      CmpObj_Convert, &ci,
+	                      &newMovieFlags))
+		return NULL;
+	_rv = MovieImportSetNewMovieFlags(ci,
+	                                  newMovieFlags);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_MovieImportGetDestinationMediaType(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	MovieImportComponent ci;
+	OSType mediaType;
+#ifndef MovieImportGetDestinationMediaType
+	PyMac_PRECHECK(MovieImportGetDestinationMediaType);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpObj_Convert, &ci))
+		return NULL;
+	_rv = MovieImportGetDestinationMediaType(ci,
+	                                         &mediaType);
+	_res = Py_BuildValue("lO&",
+	                     _rv,
+	                     PyMac_BuildOSType, mediaType);
+	return _res;
+}
+
+static PyObject *Qt_MovieExportToHandle(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	MovieExportComponent ci;
+	Handle dataH;
+	Movie theMovie;
+	Track onlyThisTrack;
+	TimeValue startTime;
+	TimeValue duration;
+#ifndef MovieExportToHandle
+	PyMac_PRECHECK(MovieExportToHandle);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&O&O&O&ll",
+	                      CmpObj_Convert, &ci,
+	                      ResObj_Convert, &dataH,
+	                      MovieObj_Convert, &theMovie,
+	                      TrackObj_Convert, &onlyThisTrack,
+	                      &startTime,
+	                      &duration))
+		return NULL;
+	_rv = MovieExportToHandle(ci,
+	                          dataH,
+	                          theMovie,
+	                          onlyThisTrack,
+	                          startTime,
+	                          duration);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_MovieExportToFile(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	MovieExportComponent ci;
+	FSSpec theFile;
+	Movie theMovie;
+	Track onlyThisTrack;
+	TimeValue startTime;
+	TimeValue duration;
+#ifndef MovieExportToFile
+	PyMac_PRECHECK(MovieExportToFile);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&O&O&O&ll",
+	                      CmpObj_Convert, &ci,
+	                      PyMac_GetFSSpec, &theFile,
+	                      MovieObj_Convert, &theMovie,
+	                      TrackObj_Convert, &onlyThisTrack,
+	                      &startTime,
+	                      &duration))
+		return NULL;
+	_rv = MovieExportToFile(ci,
+	                        &theFile,
+	                        theMovie,
+	                        onlyThisTrack,
+	                        startTime,
+	                        duration);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_MovieExportGetAuxiliaryData(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	MovieExportComponent ci;
+	Handle dataH;
+	OSType handleType;
+#ifndef MovieExportGetAuxiliaryData
+	PyMac_PRECHECK(MovieExportGetAuxiliaryData);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&O&",
+	                      CmpObj_Convert, &ci,
+	                      ResObj_Convert, &dataH))
+		return NULL;
+	_rv = MovieExportGetAuxiliaryData(ci,
+	                                  dataH,
+	                                  &handleType);
+	_res = Py_BuildValue("lO&",
+	                     _rv,
+	                     PyMac_BuildOSType, handleType);
+	return _res;
+}
+
+static PyObject *Qt_MovieExportSetSampleDescription(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	MovieExportComponent ci;
+	SampleDescriptionHandle desc;
+	OSType mediaType;
+#ifndef MovieExportSetSampleDescription
+	PyMac_PRECHECK(MovieExportSetSampleDescription);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&O&O&",
+	                      CmpObj_Convert, &ci,
+	                      ResObj_Convert, &desc,
+	                      PyMac_GetOSType, &mediaType))
+		return NULL;
+	_rv = MovieExportSetSampleDescription(ci,
+	                                      desc,
+	                                      mediaType);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_MovieExportDoUserDialog(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	MovieExportComponent ci;
+	Movie theMovie;
+	Track onlyThisTrack;
+	TimeValue startTime;
+	TimeValue duration;
+	Boolean canceled;
+#ifndef MovieExportDoUserDialog
+	PyMac_PRECHECK(MovieExportDoUserDialog);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&O&O&ll",
+	                      CmpObj_Convert, &ci,
+	                      MovieObj_Convert, &theMovie,
+	                      TrackObj_Convert, &onlyThisTrack,
+	                      &startTime,
+	                      &duration))
+		return NULL;
+	_rv = MovieExportDoUserDialog(ci,
+	                              theMovie,
+	                              onlyThisTrack,
+	                              startTime,
+	                              duration,
+	                              &canceled);
+	_res = Py_BuildValue("lb",
+	                     _rv,
+	                     canceled);
+	return _res;
+}
+
+static PyObject *Qt_MovieExportGetCreatorType(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	MovieExportComponent ci;
+	OSType creator;
+#ifndef MovieExportGetCreatorType
+	PyMac_PRECHECK(MovieExportGetCreatorType);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpObj_Convert, &ci))
+		return NULL;
+	_rv = MovieExportGetCreatorType(ci,
+	                                &creator);
+	_res = Py_BuildValue("lO&",
+	                     _rv,
+	                     PyMac_BuildOSType, creator);
+	return _res;
+}
+
+static PyObject *Qt_MovieExportToDataRef(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	MovieExportComponent ci;
+	Handle dataRef;
+	OSType dataRefType;
+	Movie theMovie;
+	Track onlyThisTrack;
+	TimeValue startTime;
+	TimeValue duration;
+#ifndef MovieExportToDataRef
+	PyMac_PRECHECK(MovieExportToDataRef);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&O&O&O&O&ll",
+	                      CmpObj_Convert, &ci,
+	                      ResObj_Convert, &dataRef,
+	                      PyMac_GetOSType, &dataRefType,
+	                      MovieObj_Convert, &theMovie,
+	                      TrackObj_Convert, &onlyThisTrack,
+	                      &startTime,
+	                      &duration))
+		return NULL;
+	_rv = MovieExportToDataRef(ci,
+	                           dataRef,
+	                           dataRefType,
+	                           theMovie,
+	                           onlyThisTrack,
+	                           startTime,
+	                           duration);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_MovieExportFromProceduresToDataRef(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	MovieExportComponent ci;
+	Handle dataRef;
+	OSType dataRefType;
+#ifndef MovieExportFromProceduresToDataRef
+	PyMac_PRECHECK(MovieExportFromProceduresToDataRef);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&O&O&",
+	                      CmpObj_Convert, &ci,
+	                      ResObj_Convert, &dataRef,
+	                      PyMac_GetOSType, &dataRefType))
+		return NULL;
+	_rv = MovieExportFromProceduresToDataRef(ci,
+	                                         dataRef,
+	                                         dataRefType);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_MovieExportValidate(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	MovieExportComponent ci;
+	Movie theMovie;
+	Track onlyThisTrack;
+	Boolean valid;
+#ifndef MovieExportValidate
+	PyMac_PRECHECK(MovieExportValidate);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&O&O&",
+	                      CmpObj_Convert, &ci,
+	                      MovieObj_Convert, &theMovie,
+	                      TrackObj_Convert, &onlyThisTrack))
+		return NULL;
+	_rv = MovieExportValidate(ci,
+	                          theMovie,
+	                          onlyThisTrack,
+	                          &valid);
+	_res = Py_BuildValue("lb",
+	                     _rv,
+	                     valid);
+	return _res;
+}
+
+static PyObject *Qt_MovieExportGetFileNameExtension(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	MovieExportComponent ci;
+	OSType extension;
+#ifndef MovieExportGetFileNameExtension
+	PyMac_PRECHECK(MovieExportGetFileNameExtension);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpObj_Convert, &ci))
+		return NULL;
+	_rv = MovieExportGetFileNameExtension(ci,
+	                                      &extension);
+	_res = Py_BuildValue("lO&",
+	                     _rv,
+	                     PyMac_BuildOSType, extension);
+	return _res;
+}
+
+static PyObject *Qt_MovieExportGetShortFileTypeString(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	MovieExportComponent ci;
+	Str255 typeString;
+#ifndef MovieExportGetShortFileTypeString
+	PyMac_PRECHECK(MovieExportGetShortFileTypeString);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&O&",
+	                      CmpObj_Convert, &ci,
+	                      PyMac_GetStr255, typeString))
+		return NULL;
+	_rv = MovieExportGetShortFileTypeString(ci,
+	                                        typeString);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_MovieExportGetSourceMediaType(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	MovieExportComponent ci;
+	OSType mediaType;
+#ifndef MovieExportGetSourceMediaType
+	PyMac_PRECHECK(MovieExportGetSourceMediaType);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpObj_Convert, &ci))
+		return NULL;
+	_rv = MovieExportGetSourceMediaType(ci,
+	                                    &mediaType);
+	_res = Py_BuildValue("lO&",
+	                     _rv,
+	                     PyMac_BuildOSType, mediaType);
+	return _res;
+}
+
+static PyObject *Qt_TextExportGetTimeFraction(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	TextExportComponent ci;
+	long movieTimeFraction;
+#ifndef TextExportGetTimeFraction
+	PyMac_PRECHECK(TextExportGetTimeFraction);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpObj_Convert, &ci))
+		return NULL;
+	_rv = TextExportGetTimeFraction(ci,
+	                                &movieTimeFraction);
+	_res = Py_BuildValue("ll",
+	                     _rv,
+	                     movieTimeFraction);
+	return _res;
+}
+
+static PyObject *Qt_TextExportSetTimeFraction(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	TextExportComponent ci;
+	long movieTimeFraction;
+#ifndef TextExportSetTimeFraction
+	PyMac_PRECHECK(TextExportSetTimeFraction);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&l",
+	                      CmpObj_Convert, &ci,
+	                      &movieTimeFraction))
+		return NULL;
+	_rv = TextExportSetTimeFraction(ci,
+	                                movieTimeFraction);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_TextExportGetSettings(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	TextExportComponent ci;
+	long setting;
+#ifndef TextExportGetSettings
+	PyMac_PRECHECK(TextExportGetSettings);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpObj_Convert, &ci))
+		return NULL;
+	_rv = TextExportGetSettings(ci,
+	                            &setting);
+	_res = Py_BuildValue("ll",
+	                     _rv,
+	                     setting);
+	return _res;
+}
+
+static PyObject *Qt_TextExportSetSettings(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	TextExportComponent ci;
+	long setting;
+#ifndef TextExportSetSettings
+	PyMac_PRECHECK(TextExportSetSettings);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&l",
+	                      CmpObj_Convert, &ci,
+	                      &setting))
+		return NULL;
+	_rv = TextExportSetSettings(ci,
+	                            setting);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_MIDIImportGetSettings(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	TextExportComponent ci;
+	long setting;
+#ifndef MIDIImportGetSettings
+	PyMac_PRECHECK(MIDIImportGetSettings);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpObj_Convert, &ci))
+		return NULL;
+	_rv = MIDIImportGetSettings(ci,
+	                            &setting);
+	_res = Py_BuildValue("ll",
+	                     _rv,
+	                     setting);
+	return _res;
+}
+
+static PyObject *Qt_MIDIImportSetSettings(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	TextExportComponent ci;
+	long setting;
+#ifndef MIDIImportSetSettings
+	PyMac_PRECHECK(MIDIImportSetSettings);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&l",
+	                      CmpObj_Convert, &ci,
+	                      &setting))
+		return NULL;
+	_rv = MIDIImportSetSettings(ci,
+	                            setting);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_GraphicsImageImportSetSequenceEnabled(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	GraphicImageMovieImportComponent ci;
+	Boolean enable;
+#ifndef GraphicsImageImportSetSequenceEnabled
+	PyMac_PRECHECK(GraphicsImageImportSetSequenceEnabled);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&b",
+	                      CmpObj_Convert, &ci,
+	                      &enable))
+		return NULL;
+	_rv = GraphicsImageImportSetSequenceEnabled(ci,
+	                                            enable);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_GraphicsImageImportGetSequenceEnabled(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	GraphicImageMovieImportComponent ci;
+	Boolean enable;
+#ifndef GraphicsImageImportGetSequenceEnabled
+	PyMac_PRECHECK(GraphicsImageImportGetSequenceEnabled);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpObj_Convert, &ci))
+		return NULL;
+	_rv = GraphicsImageImportGetSequenceEnabled(ci,
+	                                            &enable);
+	_res = Py_BuildValue("lb",
+	                     _rv,
+	                     enable);
+	return _res;
+}
+
+static PyObject *Qt_PreviewShowData(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	pnotComponent p;
+	OSType dataType;
+	Handle data;
+	Rect inHere;
+#ifndef PreviewShowData
+	PyMac_PRECHECK(PreviewShowData);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&O&O&O&",
+	                      CmpObj_Convert, &p,
+	                      PyMac_GetOSType, &dataType,
+	                      ResObj_Convert, &data,
+	                      PyMac_GetRect, &inHere))
+		return NULL;
+	_rv = PreviewShowData(p,
+	                      dataType,
+	                      data,
+	                      &inHere);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_PreviewMakePreviewReference(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	pnotComponent p;
+	OSType previewType;
+	short resID;
+	FSSpec sourceFile;
+#ifndef PreviewMakePreviewReference
+	PyMac_PRECHECK(PreviewMakePreviewReference);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&O&",
+	                      CmpObj_Convert, &p,
+	                      PyMac_GetFSSpec, &sourceFile))
+		return NULL;
+	_rv = PreviewMakePreviewReference(p,
+	                                  &previewType,
+	                                  &resID,
+	                                  &sourceFile);
+	_res = Py_BuildValue("lO&h",
+	                     _rv,
+	                     PyMac_BuildOSType, previewType,
+	                     resID);
+	return _res;
+}
+
+static PyObject *Qt_PreviewEvent(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	pnotComponent p;
+	EventRecord e;
+	Boolean handledEvent;
+#ifndef PreviewEvent
+	PyMac_PRECHECK(PreviewEvent);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpObj_Convert, &p))
+		return NULL;
+	_rv = PreviewEvent(p,
+	                   &e,
+	                   &handledEvent);
+	_res = Py_BuildValue("lO&b",
+	                     _rv,
+	                     PyMac_BuildEventRecord, &e,
+	                     handledEvent);
+	return _res;
+}
+
+static PyObject *Qt_DataCodecDecompress(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	DataCodecComponent dc;
+	void * srcData;
+	UInt32 srcSize;
+	void * dstData;
+	UInt32 dstBufferSize;
+#ifndef DataCodecDecompress
+	PyMac_PRECHECK(DataCodecDecompress);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&slsl",
+	                      CmpObj_Convert, &dc,
+	                      &srcData,
+	                      &srcSize,
+	                      &dstData,
+	                      &dstBufferSize))
+		return NULL;
+	_rv = DataCodecDecompress(dc,
+	                          srcData,
+	                          srcSize,
+	                          dstData,
+	                          dstBufferSize);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_DataCodecGetCompressBufferSize(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	DataCodecComponent dc;
+	UInt32 srcSize;
+	UInt32 dstSize;
+#ifndef DataCodecGetCompressBufferSize
+	PyMac_PRECHECK(DataCodecGetCompressBufferSize);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&l",
+	                      CmpObj_Convert, &dc,
+	                      &srcSize))
+		return NULL;
+	_rv = DataCodecGetCompressBufferSize(dc,
+	                                     srcSize,
+	                                     &dstSize);
+	_res = Py_BuildValue("ll",
+	                     _rv,
+	                     dstSize);
+	return _res;
+}
+
+static PyObject *Qt_DataCodecCompress(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	DataCodecComponent dc;
+	void * srcData;
+	UInt32 srcSize;
+	void * dstData;
+	UInt32 dstBufferSize;
+	UInt32 actualDstSize;
+	UInt32 decompressSlop;
+#ifndef DataCodecCompress
+	PyMac_PRECHECK(DataCodecCompress);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&slsl",
+	                      CmpObj_Convert, &dc,
+	                      &srcData,
+	                      &srcSize,
+	                      &dstData,
+	                      &dstBufferSize))
+		return NULL;
+	_rv = DataCodecCompress(dc,
+	                        srcData,
+	                        srcSize,
+	                        dstData,
+	                        dstBufferSize,
+	                        &actualDstSize,
+	                        &decompressSlop);
+	_res = Py_BuildValue("lll",
+	                     _rv,
+	                     actualDstSize,
+	                     decompressSlop);
+	return _res;
+}
+
+static PyObject *Qt_DataCodecBeginInterruptSafe(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	DataCodecComponent dc;
+	unsigned long maxSrcSize;
+#ifndef DataCodecBeginInterruptSafe
+	PyMac_PRECHECK(DataCodecBeginInterruptSafe);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&l",
+	                      CmpObj_Convert, &dc,
+	                      &maxSrcSize))
+		return NULL;
+	_rv = DataCodecBeginInterruptSafe(dc,
+	                                  maxSrcSize);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_DataCodecEndInterruptSafe(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	DataCodecComponent dc;
+#ifndef DataCodecEndInterruptSafe
+	PyMac_PRECHECK(DataCodecEndInterruptSafe);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpObj_Convert, &dc))
+		return NULL;
+	_rv = DataCodecEndInterruptSafe(dc);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_DataHGetData(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	DataHandler dh;
+	Handle h;
+	long hOffset;
+	long offset;
+	long size;
+#ifndef DataHGetData
+	PyMac_PRECHECK(DataHGetData);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&O&lll",
+	                      CmpInstObj_Convert, &dh,
+	                      ResObj_Convert, &h,
+	                      &hOffset,
+	                      &offset,
+	                      &size))
+		return NULL;
+	_rv = DataHGetData(dh,
+	                   h,
+	                   hOffset,
+	                   offset,
+	                   size);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_DataHPutData(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	DataHandler dh;
+	Handle h;
+	long hOffset;
+	long offset;
+	long size;
+#ifndef DataHPutData
+	PyMac_PRECHECK(DataHPutData);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&O&ll",
+	                      CmpInstObj_Convert, &dh,
+	                      ResObj_Convert, &h,
+	                      &hOffset,
+	                      &size))
+		return NULL;
+	_rv = DataHPutData(dh,
+	                   h,
+	                   hOffset,
+	                   &offset,
+	                   size);
+	_res = Py_BuildValue("ll",
+	                     _rv,
+	                     offset);
+	return _res;
+}
+
+static PyObject *Qt_DataHFlushData(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	DataHandler dh;
+#ifndef DataHFlushData
+	PyMac_PRECHECK(DataHFlushData);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpInstObj_Convert, &dh))
+		return NULL;
+	_rv = DataHFlushData(dh);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_DataHOpenForWrite(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	DataHandler dh;
+#ifndef DataHOpenForWrite
+	PyMac_PRECHECK(DataHOpenForWrite);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpInstObj_Convert, &dh))
+		return NULL;
+	_rv = DataHOpenForWrite(dh);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_DataHCloseForWrite(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	DataHandler dh;
+#ifndef DataHCloseForWrite
+	PyMac_PRECHECK(DataHCloseForWrite);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpInstObj_Convert, &dh))
+		return NULL;
+	_rv = DataHCloseForWrite(dh);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_DataHOpenForRead(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	DataHandler dh;
+#ifndef DataHOpenForRead
+	PyMac_PRECHECK(DataHOpenForRead);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpInstObj_Convert, &dh))
+		return NULL;
+	_rv = DataHOpenForRead(dh);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_DataHCloseForRead(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	DataHandler dh;
+#ifndef DataHCloseForRead
+	PyMac_PRECHECK(DataHCloseForRead);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpInstObj_Convert, &dh))
+		return NULL;
+	_rv = DataHCloseForRead(dh);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_DataHSetDataRef(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	DataHandler dh;
+	Handle dataRef;
+#ifndef DataHSetDataRef
+	PyMac_PRECHECK(DataHSetDataRef);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&O&",
+	                      CmpInstObj_Convert, &dh,
+	                      ResObj_Convert, &dataRef))
+		return NULL;
+	_rv = DataHSetDataRef(dh,
+	                      dataRef);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_DataHGetDataRef(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	DataHandler dh;
+	Handle dataRef;
+#ifndef DataHGetDataRef
+	PyMac_PRECHECK(DataHGetDataRef);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpInstObj_Convert, &dh))
+		return NULL;
+	_rv = DataHGetDataRef(dh,
+	                      &dataRef);
+	_res = Py_BuildValue("lO&",
+	                     _rv,
+	                     ResObj_New, dataRef);
+	return _res;
+}
+
+static PyObject *Qt_DataHCompareDataRef(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	DataHandler dh;
+	Handle dataRef;
+	Boolean equal;
+#ifndef DataHCompareDataRef
+	PyMac_PRECHECK(DataHCompareDataRef);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&O&",
+	                      CmpInstObj_Convert, &dh,
+	                      ResObj_Convert, &dataRef))
+		return NULL;
+	_rv = DataHCompareDataRef(dh,
+	                          dataRef,
+	                          &equal);
+	_res = Py_BuildValue("lb",
+	                     _rv,
+	                     equal);
+	return _res;
+}
+
+static PyObject *Qt_DataHTask(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	DataHandler dh;
+#ifndef DataHTask
+	PyMac_PRECHECK(DataHTask);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpInstObj_Convert, &dh))
+		return NULL;
+	_rv = DataHTask(dh);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_DataHFinishData(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	DataHandler dh;
+	Ptr PlaceToPutDataPtr;
+	Boolean Cancel;
+#ifndef DataHFinishData
+	PyMac_PRECHECK(DataHFinishData);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&sb",
+	                      CmpInstObj_Convert, &dh,
+	                      &PlaceToPutDataPtr,
+	                      &Cancel))
+		return NULL;
+	_rv = DataHFinishData(dh,
+	                      PlaceToPutDataPtr,
+	                      Cancel);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_DataHFlushCache(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	DataHandler dh;
+#ifndef DataHFlushCache
+	PyMac_PRECHECK(DataHFlushCache);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpInstObj_Convert, &dh))
+		return NULL;
+	_rv = DataHFlushCache(dh);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_DataHResolveDataRef(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	DataHandler dh;
+	Handle theDataRef;
+	Boolean wasChanged;
+	Boolean userInterfaceAllowed;
+#ifndef DataHResolveDataRef
+	PyMac_PRECHECK(DataHResolveDataRef);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&O&b",
+	                      CmpInstObj_Convert, &dh,
+	                      ResObj_Convert, &theDataRef,
+	                      &userInterfaceAllowed))
+		return NULL;
+	_rv = DataHResolveDataRef(dh,
+	                          theDataRef,
+	                          &wasChanged,
+	                          userInterfaceAllowed);
+	_res = Py_BuildValue("lb",
+	                     _rv,
+	                     wasChanged);
+	return _res;
+}
+
+static PyObject *Qt_DataHGetFileSize(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	DataHandler dh;
+	long fileSize;
+#ifndef DataHGetFileSize
+	PyMac_PRECHECK(DataHGetFileSize);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpInstObj_Convert, &dh))
+		return NULL;
+	_rv = DataHGetFileSize(dh,
+	                       &fileSize);
+	_res = Py_BuildValue("ll",
+	                     _rv,
+	                     fileSize);
+	return _res;
+}
+
+static PyObject *Qt_DataHCanUseDataRef(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	DataHandler dh;
+	Handle dataRef;
+	long useFlags;
+#ifndef DataHCanUseDataRef
+	PyMac_PRECHECK(DataHCanUseDataRef);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&O&",
+	                      CmpInstObj_Convert, &dh,
+	                      ResObj_Convert, &dataRef))
+		return NULL;
+	_rv = DataHCanUseDataRef(dh,
+	                         dataRef,
+	                         &useFlags);
+	_res = Py_BuildValue("ll",
+	                     _rv,
+	                     useFlags);
+	return _res;
+}
+
+static PyObject *Qt_DataHPreextend(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	DataHandler dh;
+	unsigned long maxToAdd;
+	unsigned long spaceAdded;
+#ifndef DataHPreextend
+	PyMac_PRECHECK(DataHPreextend);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&l",
+	                      CmpInstObj_Convert, &dh,
+	                      &maxToAdd))
+		return NULL;
+	_rv = DataHPreextend(dh,
+	                     maxToAdd,
+	                     &spaceAdded);
+	_res = Py_BuildValue("ll",
+	                     _rv,
+	                     spaceAdded);
+	return _res;
+}
+
+static PyObject *Qt_DataHSetFileSize(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	DataHandler dh;
+	long fileSize;
+#ifndef DataHSetFileSize
+	PyMac_PRECHECK(DataHSetFileSize);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&l",
+	                      CmpInstObj_Convert, &dh,
+	                      &fileSize))
+		return NULL;
+	_rv = DataHSetFileSize(dh,
+	                       fileSize);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_DataHGetFreeSpace(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	DataHandler dh;
+	unsigned long freeSize;
+#ifndef DataHGetFreeSpace
+	PyMac_PRECHECK(DataHGetFreeSpace);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpInstObj_Convert, &dh))
+		return NULL;
+	_rv = DataHGetFreeSpace(dh,
+	                        &freeSize);
+	_res = Py_BuildValue("ll",
+	                     _rv,
+	                     freeSize);
+	return _res;
+}
+
+static PyObject *Qt_DataHCreateFile(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	DataHandler dh;
+	OSType creator;
+	Boolean deleteExisting;
+#ifndef DataHCreateFile
+	PyMac_PRECHECK(DataHCreateFile);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&O&b",
+	                      CmpInstObj_Convert, &dh,
+	                      PyMac_GetOSType, &creator,
+	                      &deleteExisting))
+		return NULL;
+	_rv = DataHCreateFile(dh,
+	                      creator,
+	                      deleteExisting);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_DataHGetPreferredBlockSize(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	DataHandler dh;
+	long blockSize;
+#ifndef DataHGetPreferredBlockSize
+	PyMac_PRECHECK(DataHGetPreferredBlockSize);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpInstObj_Convert, &dh))
+		return NULL;
+	_rv = DataHGetPreferredBlockSize(dh,
+	                                 &blockSize);
+	_res = Py_BuildValue("ll",
+	                     _rv,
+	                     blockSize);
+	return _res;
+}
+
+static PyObject *Qt_DataHGetDeviceIndex(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	DataHandler dh;
+	long deviceIndex;
+#ifndef DataHGetDeviceIndex
+	PyMac_PRECHECK(DataHGetDeviceIndex);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpInstObj_Convert, &dh))
+		return NULL;
+	_rv = DataHGetDeviceIndex(dh,
+	                          &deviceIndex);
+	_res = Py_BuildValue("ll",
+	                     _rv,
+	                     deviceIndex);
+	return _res;
+}
+
+static PyObject *Qt_DataHIsStreamingDataHandler(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	DataHandler dh;
+	Boolean yes;
+#ifndef DataHIsStreamingDataHandler
+	PyMac_PRECHECK(DataHIsStreamingDataHandler);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpInstObj_Convert, &dh))
+		return NULL;
+	_rv = DataHIsStreamingDataHandler(dh,
+	                                  &yes);
+	_res = Py_BuildValue("lb",
+	                     _rv,
+	                     yes);
+	return _res;
+}
+
+static PyObject *Qt_DataHGetDataInBuffer(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	DataHandler dh;
+	long startOffset;
+	long size;
+#ifndef DataHGetDataInBuffer
+	PyMac_PRECHECK(DataHGetDataInBuffer);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&l",
+	                      CmpInstObj_Convert, &dh,
+	                      &startOffset))
+		return NULL;
+	_rv = DataHGetDataInBuffer(dh,
+	                           startOffset,
+	                           &size);
+	_res = Py_BuildValue("ll",
+	                     _rv,
+	                     size);
+	return _res;
+}
+
+static PyObject *Qt_DataHGetScheduleAheadTime(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	DataHandler dh;
+	long millisecs;
+#ifndef DataHGetScheduleAheadTime
+	PyMac_PRECHECK(DataHGetScheduleAheadTime);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpInstObj_Convert, &dh))
+		return NULL;
+	_rv = DataHGetScheduleAheadTime(dh,
+	                                &millisecs);
+	_res = Py_BuildValue("ll",
+	                     _rv,
+	                     millisecs);
+	return _res;
+}
+
+static PyObject *Qt_DataHSetCacheSizeLimit(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	DataHandler dh;
+	Size cacheSizeLimit;
+#ifndef DataHSetCacheSizeLimit
+	PyMac_PRECHECK(DataHSetCacheSizeLimit);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&l",
+	                      CmpInstObj_Convert, &dh,
+	                      &cacheSizeLimit))
+		return NULL;
+	_rv = DataHSetCacheSizeLimit(dh,
+	                             cacheSizeLimit);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_DataHGetCacheSizeLimit(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	DataHandler dh;
+	Size cacheSizeLimit;
+#ifndef DataHGetCacheSizeLimit
+	PyMac_PRECHECK(DataHGetCacheSizeLimit);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpInstObj_Convert, &dh))
+		return NULL;
+	_rv = DataHGetCacheSizeLimit(dh,
+	                             &cacheSizeLimit);
+	_res = Py_BuildValue("ll",
+	                     _rv,
+	                     cacheSizeLimit);
+	return _res;
+}
+
+static PyObject *Qt_DataHGetMovie(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	DataHandler dh;
+	Movie theMovie;
+	short id;
+#ifndef DataHGetMovie
+	PyMac_PRECHECK(DataHGetMovie);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpInstObj_Convert, &dh))
+		return NULL;
+	_rv = DataHGetMovie(dh,
+	                    &theMovie,
+	                    &id);
+	_res = Py_BuildValue("lO&h",
+	                     _rv,
+	                     MovieObj_New, theMovie,
+	                     id);
+	return _res;
+}
+
+static PyObject *Qt_DataHAddMovie(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	DataHandler dh;
+	Movie theMovie;
+	short id;
+#ifndef DataHAddMovie
+	PyMac_PRECHECK(DataHAddMovie);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&O&",
+	                      CmpInstObj_Convert, &dh,
+	                      MovieObj_Convert, &theMovie))
+		return NULL;
+	_rv = DataHAddMovie(dh,
+	                    theMovie,
+	                    &id);
+	_res = Py_BuildValue("lh",
+	                     _rv,
+	                     id);
+	return _res;
+}
+
+static PyObject *Qt_DataHUpdateMovie(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	DataHandler dh;
+	Movie theMovie;
+	short id;
+#ifndef DataHUpdateMovie
+	PyMac_PRECHECK(DataHUpdateMovie);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&O&h",
+	                      CmpInstObj_Convert, &dh,
+	                      MovieObj_Convert, &theMovie,
+	                      &id))
+		return NULL;
+	_rv = DataHUpdateMovie(dh,
+	                       theMovie,
+	                       id);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_DataHDoesBuffer(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	DataHandler dh;
+	Boolean buffersReads;
+	Boolean buffersWrites;
+#ifndef DataHDoesBuffer
+	PyMac_PRECHECK(DataHDoesBuffer);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpInstObj_Convert, &dh))
+		return NULL;
+	_rv = DataHDoesBuffer(dh,
+	                      &buffersReads,
+	                      &buffersWrites);
+	_res = Py_BuildValue("lbb",
+	                     _rv,
+	                     buffersReads,
+	                     buffersWrites);
+	return _res;
+}
+
+static PyObject *Qt_DataHGetFileName(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	DataHandler dh;
+	Str255 str;
+#ifndef DataHGetFileName
+	PyMac_PRECHECK(DataHGetFileName);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&O&",
+	                      CmpInstObj_Convert, &dh,
+	                      PyMac_GetStr255, str))
+		return NULL;
+	_rv = DataHGetFileName(dh,
+	                       str);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_DataHGetAvailableFileSize(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	DataHandler dh;
+	long fileSize;
+#ifndef DataHGetAvailableFileSize
+	PyMac_PRECHECK(DataHGetAvailableFileSize);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpInstObj_Convert, &dh))
+		return NULL;
+	_rv = DataHGetAvailableFileSize(dh,
+	                                &fileSize);
+	_res = Py_BuildValue("ll",
+	                     _rv,
+	                     fileSize);
+	return _res;
+}
+
+static PyObject *Qt_DataHGetMacOSFileType(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	DataHandler dh;
+	OSType fileType;
+#ifndef DataHGetMacOSFileType
+	PyMac_PRECHECK(DataHGetMacOSFileType);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpInstObj_Convert, &dh))
+		return NULL;
+	_rv = DataHGetMacOSFileType(dh,
+	                            &fileType);
+	_res = Py_BuildValue("lO&",
+	                     _rv,
+	                     PyMac_BuildOSType, fileType);
+	return _res;
+}
+
+static PyObject *Qt_DataHGetMIMEType(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	DataHandler dh;
+	Str255 mimeType;
+#ifndef DataHGetMIMEType
+	PyMac_PRECHECK(DataHGetMIMEType);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&O&",
+	                      CmpInstObj_Convert, &dh,
+	                      PyMac_GetStr255, mimeType))
+		return NULL;
+	_rv = DataHGetMIMEType(dh,
+	                       mimeType);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_DataHSetDataRefWithAnchor(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	DataHandler dh;
+	Handle anchorDataRef;
+	OSType dataRefType;
+	Handle dataRef;
+#ifndef DataHSetDataRefWithAnchor
+	PyMac_PRECHECK(DataHSetDataRefWithAnchor);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&O&O&O&",
+	                      CmpInstObj_Convert, &dh,
+	                      ResObj_Convert, &anchorDataRef,
+	                      PyMac_GetOSType, &dataRefType,
+	                      ResObj_Convert, &dataRef))
+		return NULL;
+	_rv = DataHSetDataRefWithAnchor(dh,
+	                                anchorDataRef,
+	                                dataRefType,
+	                                dataRef);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_DataHGetDataRefWithAnchor(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	DataHandler dh;
+	Handle anchorDataRef;
+	OSType dataRefType;
+	Handle dataRef;
+#ifndef DataHGetDataRefWithAnchor
+	PyMac_PRECHECK(DataHGetDataRefWithAnchor);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&O&O&",
+	                      CmpInstObj_Convert, &dh,
+	                      ResObj_Convert, &anchorDataRef,
+	                      PyMac_GetOSType, &dataRefType))
+		return NULL;
+	_rv = DataHGetDataRefWithAnchor(dh,
+	                                anchorDataRef,
+	                                dataRefType,
+	                                &dataRef);
+	_res = Py_BuildValue("lO&",
+	                     _rv,
+	                     ResObj_New, dataRef);
+	return _res;
+}
+
+static PyObject *Qt_DataHSetMacOSFileType(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	DataHandler dh;
+	OSType fileType;
+#ifndef DataHSetMacOSFileType
+	PyMac_PRECHECK(DataHSetMacOSFileType);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&O&",
+	                      CmpInstObj_Convert, &dh,
+	                      PyMac_GetOSType, &fileType))
+		return NULL;
+	_rv = DataHSetMacOSFileType(dh,
+	                            fileType);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_DataHSetTimeBase(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	DataHandler dh;
+	TimeBase tb;
+#ifndef DataHSetTimeBase
+	PyMac_PRECHECK(DataHSetTimeBase);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&O&",
+	                      CmpInstObj_Convert, &dh,
+	                      TimeBaseObj_Convert, &tb))
+		return NULL;
+	_rv = DataHSetTimeBase(dh,
+	                       tb);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_DataHGetInfoFlags(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	DataHandler dh;
+	UInt32 flags;
+#ifndef DataHGetInfoFlags
+	PyMac_PRECHECK(DataHGetInfoFlags);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpInstObj_Convert, &dh))
+		return NULL;
+	_rv = DataHGetInfoFlags(dh,
+	                        &flags);
+	_res = Py_BuildValue("ll",
+	                     _rv,
+	                     flags);
+	return _res;
+}
+
+static PyObject *Qt_DataHGetFileSize64(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	DataHandler dh;
+	wide fileSize;
+#ifndef DataHGetFileSize64
+	PyMac_PRECHECK(DataHGetFileSize64);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpInstObj_Convert, &dh))
+		return NULL;
+	_rv = DataHGetFileSize64(dh,
+	                         &fileSize);
+	_res = Py_BuildValue("lO&",
+	                     _rv,
+	                     PyMac_Buildwide, fileSize);
+	return _res;
+}
+
+static PyObject *Qt_DataHPreextend64(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	DataHandler dh;
+	wide maxToAdd;
+	wide spaceAdded;
+#ifndef DataHPreextend64
+	PyMac_PRECHECK(DataHPreextend64);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&O&",
+	                      CmpInstObj_Convert, &dh,
+	                      PyMac_Getwide, &maxToAdd))
+		return NULL;
+	_rv = DataHPreextend64(dh,
+	                       &maxToAdd,
+	                       &spaceAdded);
+	_res = Py_BuildValue("lO&",
+	                     _rv,
+	                     PyMac_Buildwide, spaceAdded);
+	return _res;
+}
+
+static PyObject *Qt_DataHSetFileSize64(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	DataHandler dh;
+	wide fileSize;
+#ifndef DataHSetFileSize64
+	PyMac_PRECHECK(DataHSetFileSize64);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&O&",
+	                      CmpInstObj_Convert, &dh,
+	                      PyMac_Getwide, &fileSize))
+		return NULL;
+	_rv = DataHSetFileSize64(dh,
+	                         &fileSize);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_DataHGetFreeSpace64(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	DataHandler dh;
+	wide freeSize;
+#ifndef DataHGetFreeSpace64
+	PyMac_PRECHECK(DataHGetFreeSpace64);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpInstObj_Convert, &dh))
+		return NULL;
+	_rv = DataHGetFreeSpace64(dh,
+	                          &freeSize);
+	_res = Py_BuildValue("lO&",
+	                     _rv,
+	                     PyMac_Buildwide, freeSize);
+	return _res;
+}
+
+static PyObject *Qt_DataHAppend64(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	DataHandler dh;
+	void * data;
+	wide fileOffset;
+	unsigned long size;
+#ifndef DataHAppend64
+	PyMac_PRECHECK(DataHAppend64);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&sl",
+	                      CmpInstObj_Convert, &dh,
+	                      &data,
+	                      &size))
+		return NULL;
+	_rv = DataHAppend64(dh,
+	                    data,
+	                    &fileOffset,
+	                    size);
+	_res = Py_BuildValue("lO&",
+	                     _rv,
+	                     PyMac_Buildwide, fileOffset);
+	return _res;
+}
+
+static PyObject *Qt_DataHPollRead(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	DataHandler dh;
+	void * dataPtr;
+	UInt32 dataSizeSoFar;
+#ifndef DataHPollRead
+	PyMac_PRECHECK(DataHPollRead);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&s",
+	                      CmpInstObj_Convert, &dh,
+	                      &dataPtr))
+		return NULL;
+	_rv = DataHPollRead(dh,
+	                    dataPtr,
+	                    &dataSizeSoFar);
+	_res = Py_BuildValue("ll",
+	                     _rv,
+	                     dataSizeSoFar);
+	return _res;
+}
+
+static PyObject *Qt_DataHGetDataAvailability(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	DataHandler dh;
+	long offset;
+	long len;
+	long missing_offset;
+	long missing_len;
+#ifndef DataHGetDataAvailability
+	PyMac_PRECHECK(DataHGetDataAvailability);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&ll",
+	                      CmpInstObj_Convert, &dh,
+	                      &offset,
+	                      &len))
+		return NULL;
+	_rv = DataHGetDataAvailability(dh,
+	                               offset,
+	                               len,
+	                               &missing_offset,
+	                               &missing_len);
+	_res = Py_BuildValue("lll",
+	                     _rv,
+	                     missing_offset,
+	                     missing_len);
+	return _res;
+}
+
+static PyObject *Qt_DataHGetDataRefAsType(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	DataHandler dh;
+	OSType requestedType;
+	Handle dataRef;
+#ifndef DataHGetDataRefAsType
+	PyMac_PRECHECK(DataHGetDataRefAsType);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&O&",
+	                      CmpInstObj_Convert, &dh,
+	                      PyMac_GetOSType, &requestedType))
+		return NULL;
+	_rv = DataHGetDataRefAsType(dh,
+	                            requestedType,
+	                            &dataRef);
+	_res = Py_BuildValue("lO&",
+	                     _rv,
+	                     ResObj_New, dataRef);
+	return _res;
+}
+
+static PyObject *Qt_DataHSetDataRefExtension(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	DataHandler dh;
+	Handle extension;
+	OSType idType;
+#ifndef DataHSetDataRefExtension
+	PyMac_PRECHECK(DataHSetDataRefExtension);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&O&O&",
+	                      CmpInstObj_Convert, &dh,
+	                      ResObj_Convert, &extension,
+	                      PyMac_GetOSType, &idType))
+		return NULL;
+	_rv = DataHSetDataRefExtension(dh,
+	                               extension,
+	                               idType);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_DataHGetDataRefExtension(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	DataHandler dh;
+	Handle extension;
+	OSType idType;
+#ifndef DataHGetDataRefExtension
+	PyMac_PRECHECK(DataHGetDataRefExtension);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&O&",
+	                      CmpInstObj_Convert, &dh,
+	                      PyMac_GetOSType, &idType))
+		return NULL;
+	_rv = DataHGetDataRefExtension(dh,
+	                               &extension,
+	                               idType);
+	_res = Py_BuildValue("lO&",
+	                     _rv,
+	                     ResObj_New, extension);
+	return _res;
+}
+
+static PyObject *Qt_DataHGetMovieWithFlags(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	DataHandler dh;
+	Movie theMovie;
+	short id;
+	short flags;
+#ifndef DataHGetMovieWithFlags
+	PyMac_PRECHECK(DataHGetMovieWithFlags);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&h",
+	                      CmpInstObj_Convert, &dh,
+	                      &flags))
+		return NULL;
+	_rv = DataHGetMovieWithFlags(dh,
+	                             &theMovie,
+	                             &id,
+	                             flags);
+	_res = Py_BuildValue("lO&h",
+	                     _rv,
+	                     MovieObj_New, theMovie,
+	                     id);
+	return _res;
+}
+
+static PyObject *Qt_DataHGetFileTypeOrdering(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	DataHandler dh;
+	DataHFileTypeOrderingHandle orderingListHandle;
+#ifndef DataHGetFileTypeOrdering
+	PyMac_PRECHECK(DataHGetFileTypeOrdering);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpInstObj_Convert, &dh))
+		return NULL;
+	_rv = DataHGetFileTypeOrdering(dh,
+	                               &orderingListHandle);
+	_res = Py_BuildValue("lO&",
+	                     _rv,
+	                     ResObj_New, orderingListHandle);
+	return _res;
+}
+
+static PyObject *Qt_DataHCreateFileWithFlags(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	DataHandler dh;
+	OSType creator;
+	Boolean deleteExisting;
+	UInt32 flags;
+#ifndef DataHCreateFileWithFlags
+	PyMac_PRECHECK(DataHCreateFileWithFlags);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&O&bl",
+	                      CmpInstObj_Convert, &dh,
+	                      PyMac_GetOSType, &creator,
+	                      &deleteExisting,
+	                      &flags))
+		return NULL;
+	_rv = DataHCreateFileWithFlags(dh,
+	                               creator,
+	                               deleteExisting,
+	                               flags);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_DataHGetInfo(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	DataHandler dh;
+	OSType what;
+	void * info;
+#ifndef DataHGetInfo
+	PyMac_PRECHECK(DataHGetInfo);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&O&s",
+	                      CmpInstObj_Convert, &dh,
+	                      PyMac_GetOSType, &what,
+	                      &info))
+		return NULL;
+	_rv = DataHGetInfo(dh,
+	                   what,
+	                   info);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_DataHSetIdleManager(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	DataHandler dh;
+	IdleManager im;
+#ifndef DataHSetIdleManager
+	PyMac_PRECHECK(DataHSetIdleManager);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&O&",
+	                      CmpInstObj_Convert, &dh,
+	                      IdleManagerObj_Convert, &im))
+		return NULL;
+	_rv = DataHSetIdleManager(dh,
+	                          im);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_DataHDeleteFile(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	DataHandler dh;
+#ifndef DataHDeleteFile
+	PyMac_PRECHECK(DataHDeleteFile);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpInstObj_Convert, &dh))
+		return NULL;
+	_rv = DataHDeleteFile(dh);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_DataHSetMovieUsageFlags(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	DataHandler dh;
+	long flags;
+#ifndef DataHSetMovieUsageFlags
+	PyMac_PRECHECK(DataHSetMovieUsageFlags);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&l",
+	                      CmpInstObj_Convert, &dh,
+	                      &flags))
+		return NULL;
+	_rv = DataHSetMovieUsageFlags(dh,
+	                              flags);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_DataHUseTemporaryDataRef(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	DataHandler dh;
+	long inFlags;
+#ifndef DataHUseTemporaryDataRef
+	PyMac_PRECHECK(DataHUseTemporaryDataRef);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&l",
+	                      CmpInstObj_Convert, &dh,
+	                      &inFlags))
+		return NULL;
+	_rv = DataHUseTemporaryDataRef(dh,
+	                               inFlags);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_DataHGetTemporaryDataRefCapabilities(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	DataHandler dh;
+	long outUnderstoodFlags;
+#ifndef DataHGetTemporaryDataRefCapabilities
+	PyMac_PRECHECK(DataHGetTemporaryDataRefCapabilities);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpInstObj_Convert, &dh))
+		return NULL;
+	_rv = DataHGetTemporaryDataRefCapabilities(dh,
+	                                           &outUnderstoodFlags);
+	_res = Py_BuildValue("ll",
+	                     _rv,
+	                     outUnderstoodFlags);
+	return _res;
+}
+
+static PyObject *Qt_DataHRenameFile(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	DataHandler dh;
+	Handle newDataRef;
+#ifndef DataHRenameFile
+	PyMac_PRECHECK(DataHRenameFile);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&O&",
+	                      CmpInstObj_Convert, &dh,
+	                      ResObj_Convert, &newDataRef))
+		return NULL;
+	_rv = DataHRenameFile(dh,
+	                      newDataRef);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_DataHPlaybackHints(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	DataHandler dh;
+	long flags;
+	unsigned long minFileOffset;
+	unsigned long maxFileOffset;
+	long bytesPerSecond;
+#ifndef DataHPlaybackHints
+	PyMac_PRECHECK(DataHPlaybackHints);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&llll",
+	                      CmpInstObj_Convert, &dh,
+	                      &flags,
+	                      &minFileOffset,
+	                      &maxFileOffset,
+	                      &bytesPerSecond))
+		return NULL;
+	_rv = DataHPlaybackHints(dh,
+	                         flags,
+	                         minFileOffset,
+	                         maxFileOffset,
+	                         bytesPerSecond);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_DataHPlaybackHints64(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	DataHandler dh;
+	long flags;
+	wide minFileOffset;
+	wide maxFileOffset;
+	long bytesPerSecond;
+#ifndef DataHPlaybackHints64
+	PyMac_PRECHECK(DataHPlaybackHints64);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&lO&O&l",
+	                      CmpInstObj_Convert, &dh,
+	                      &flags,
+	                      PyMac_Getwide, &minFileOffset,
+	                      PyMac_Getwide, &maxFileOffset,
+	                      &bytesPerSecond))
+		return NULL;
+	_rv = DataHPlaybackHints64(dh,
+	                           flags,
+	                           &minFileOffset,
+	                           &maxFileOffset,
+	                           bytesPerSecond);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_DataHGetDataRate(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	DataHandler dh;
+	long flags;
+	long bytesPerSecond;
+#ifndef DataHGetDataRate
+	PyMac_PRECHECK(DataHGetDataRate);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&l",
+	                      CmpInstObj_Convert, &dh,
+	                      &flags))
+		return NULL;
+	_rv = DataHGetDataRate(dh,
+	                       flags,
+	                       &bytesPerSecond);
+	_res = Py_BuildValue("ll",
+	                     _rv,
+	                     bytesPerSecond);
+	return _res;
+}
+
+static PyObject *Qt_DataHSetTimeHints(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	DataHandler dh;
+	long flags;
+	long bandwidthPriority;
+	TimeScale scale;
+	TimeValue minTime;
+	TimeValue maxTime;
+#ifndef DataHSetTimeHints
+	PyMac_PRECHECK(DataHSetTimeHints);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&lllll",
+	                      CmpInstObj_Convert, &dh,
+	                      &flags,
+	                      &bandwidthPriority,
+	                      &scale,
+	                      &minTime,
+	                      &maxTime))
+		return NULL;
+	_rv = DataHSetTimeHints(dh,
+	                        flags,
+	                        bandwidthPriority,
+	                        scale,
+	                        minTime,
+	                        maxTime);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_VDGetMaxSrcRect(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	VideoDigitizerComponent ci;
+	short inputStd;
+	Rect maxSrcRect;
+#ifndef VDGetMaxSrcRect
+	PyMac_PRECHECK(VDGetMaxSrcRect);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&h",
+	                      CmpObj_Convert, &ci,
+	                      &inputStd))
+		return NULL;
+	_rv = VDGetMaxSrcRect(ci,
+	                      inputStd,
+	                      &maxSrcRect);
+	_res = Py_BuildValue("lO&",
+	                     _rv,
+	                     PyMac_BuildRect, &maxSrcRect);
+	return _res;
+}
+
+static PyObject *Qt_VDGetActiveSrcRect(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	VideoDigitizerComponent ci;
+	short inputStd;
+	Rect activeSrcRect;
+#ifndef VDGetActiveSrcRect
+	PyMac_PRECHECK(VDGetActiveSrcRect);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&h",
+	                      CmpObj_Convert, &ci,
+	                      &inputStd))
+		return NULL;
+	_rv = VDGetActiveSrcRect(ci,
+	                         inputStd,
+	                         &activeSrcRect);
+	_res = Py_BuildValue("lO&",
+	                     _rv,
+	                     PyMac_BuildRect, &activeSrcRect);
+	return _res;
+}
+
+static PyObject *Qt_VDSetDigitizerRect(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	VideoDigitizerComponent ci;
+	Rect digitizerRect;
+#ifndef VDSetDigitizerRect
+	PyMac_PRECHECK(VDSetDigitizerRect);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpObj_Convert, &ci))
+		return NULL;
+	_rv = VDSetDigitizerRect(ci,
+	                         &digitizerRect);
+	_res = Py_BuildValue("lO&",
+	                     _rv,
+	                     PyMac_BuildRect, &digitizerRect);
+	return _res;
+}
+
+static PyObject *Qt_VDGetDigitizerRect(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	VideoDigitizerComponent ci;
+	Rect digitizerRect;
+#ifndef VDGetDigitizerRect
+	PyMac_PRECHECK(VDGetDigitizerRect);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpObj_Convert, &ci))
+		return NULL;
+	_rv = VDGetDigitizerRect(ci,
+	                         &digitizerRect);
+	_res = Py_BuildValue("lO&",
+	                     _rv,
+	                     PyMac_BuildRect, &digitizerRect);
+	return _res;
+}
+
+static PyObject *Qt_VDGetVBlankRect(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	VideoDigitizerComponent ci;
+	short inputStd;
+	Rect vBlankRect;
+#ifndef VDGetVBlankRect
+	PyMac_PRECHECK(VDGetVBlankRect);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&h",
+	                      CmpObj_Convert, &ci,
+	                      &inputStd))
+		return NULL;
+	_rv = VDGetVBlankRect(ci,
+	                      inputStd,
+	                      &vBlankRect);
+	_res = Py_BuildValue("lO&",
+	                     _rv,
+	                     PyMac_BuildRect, &vBlankRect);
+	return _res;
+}
+
+static PyObject *Qt_VDGetMaskPixMap(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	VideoDigitizerComponent ci;
+	PixMapHandle maskPixMap;
+#ifndef VDGetMaskPixMap
+	PyMac_PRECHECK(VDGetMaskPixMap);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&O&",
+	                      CmpObj_Convert, &ci,
+	                      ResObj_Convert, &maskPixMap))
+		return NULL;
+	_rv = VDGetMaskPixMap(ci,
+	                      maskPixMap);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_VDUseThisCLUT(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	VideoDigitizerComponent ci;
+	CTabHandle colorTableHandle;
+#ifndef VDUseThisCLUT
+	PyMac_PRECHECK(VDUseThisCLUT);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&O&",
+	                      CmpObj_Convert, &ci,
+	                      ResObj_Convert, &colorTableHandle))
+		return NULL;
+	_rv = VDUseThisCLUT(ci,
+	                    colorTableHandle);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_VDSetInputGammaValue(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	VideoDigitizerComponent ci;
+	Fixed channel1;
+	Fixed channel2;
+	Fixed channel3;
+#ifndef VDSetInputGammaValue
+	PyMac_PRECHECK(VDSetInputGammaValue);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&O&O&O&",
+	                      CmpObj_Convert, &ci,
+	                      PyMac_GetFixed, &channel1,
+	                      PyMac_GetFixed, &channel2,
+	                      PyMac_GetFixed, &channel3))
+		return NULL;
+	_rv = VDSetInputGammaValue(ci,
+	                           channel1,
+	                           channel2,
+	                           channel3);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_VDGetInputGammaValue(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	VideoDigitizerComponent ci;
+	Fixed channel1;
+	Fixed channel2;
+	Fixed channel3;
+#ifndef VDGetInputGammaValue
+	PyMac_PRECHECK(VDGetInputGammaValue);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpObj_Convert, &ci))
+		return NULL;
+	_rv = VDGetInputGammaValue(ci,
+	                           &channel1,
+	                           &channel2,
+	                           &channel3);
+	_res = Py_BuildValue("lO&O&O&",
+	                     _rv,
+	                     PyMac_BuildFixed, channel1,
+	                     PyMac_BuildFixed, channel2,
+	                     PyMac_BuildFixed, channel3);
+	return _res;
+}
+
+static PyObject *Qt_VDSetBrightness(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	VideoDigitizerComponent ci;
+	unsigned short brightness;
+#ifndef VDSetBrightness
+	PyMac_PRECHECK(VDSetBrightness);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpObj_Convert, &ci))
+		return NULL;
+	_rv = VDSetBrightness(ci,
+	                      &brightness);
+	_res = Py_BuildValue("lH",
+	                     _rv,
+	                     brightness);
+	return _res;
+}
+
+static PyObject *Qt_VDGetBrightness(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	VideoDigitizerComponent ci;
+	unsigned short brightness;
+#ifndef VDGetBrightness
+	PyMac_PRECHECK(VDGetBrightness);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpObj_Convert, &ci))
+		return NULL;
+	_rv = VDGetBrightness(ci,
+	                      &brightness);
+	_res = Py_BuildValue("lH",
+	                     _rv,
+	                     brightness);
+	return _res;
+}
+
+static PyObject *Qt_VDSetContrast(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	VideoDigitizerComponent ci;
+	unsigned short contrast;
+#ifndef VDSetContrast
+	PyMac_PRECHECK(VDSetContrast);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpObj_Convert, &ci))
+		return NULL;
+	_rv = VDSetContrast(ci,
+	                    &contrast);
+	_res = Py_BuildValue("lH",
+	                     _rv,
+	                     contrast);
+	return _res;
+}
+
+static PyObject *Qt_VDSetHue(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	VideoDigitizerComponent ci;
+	unsigned short hue;
+#ifndef VDSetHue
+	PyMac_PRECHECK(VDSetHue);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpObj_Convert, &ci))
+		return NULL;
+	_rv = VDSetHue(ci,
+	               &hue);
+	_res = Py_BuildValue("lH",
+	                     _rv,
+	                     hue);
+	return _res;
+}
+
+static PyObject *Qt_VDSetSharpness(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	VideoDigitizerComponent ci;
+	unsigned short sharpness;
+#ifndef VDSetSharpness
+	PyMac_PRECHECK(VDSetSharpness);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpObj_Convert, &ci))
+		return NULL;
+	_rv = VDSetSharpness(ci,
+	                     &sharpness);
+	_res = Py_BuildValue("lH",
+	                     _rv,
+	                     sharpness);
+	return _res;
+}
+
+static PyObject *Qt_VDSetSaturation(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	VideoDigitizerComponent ci;
+	unsigned short saturation;
+#ifndef VDSetSaturation
+	PyMac_PRECHECK(VDSetSaturation);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpObj_Convert, &ci))
+		return NULL;
+	_rv = VDSetSaturation(ci,
+	                      &saturation);
+	_res = Py_BuildValue("lH",
+	                     _rv,
+	                     saturation);
+	return _res;
+}
+
+static PyObject *Qt_VDGetContrast(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	VideoDigitizerComponent ci;
+	unsigned short contrast;
+#ifndef VDGetContrast
+	PyMac_PRECHECK(VDGetContrast);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpObj_Convert, &ci))
+		return NULL;
+	_rv = VDGetContrast(ci,
+	                    &contrast);
+	_res = Py_BuildValue("lH",
+	                     _rv,
+	                     contrast);
+	return _res;
+}
+
+static PyObject *Qt_VDGetHue(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	VideoDigitizerComponent ci;
+	unsigned short hue;
+#ifndef VDGetHue
+	PyMac_PRECHECK(VDGetHue);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpObj_Convert, &ci))
+		return NULL;
+	_rv = VDGetHue(ci,
+	               &hue);
+	_res = Py_BuildValue("lH",
+	                     _rv,
+	                     hue);
+	return _res;
+}
+
+static PyObject *Qt_VDGetSharpness(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	VideoDigitizerComponent ci;
+	unsigned short sharpness;
+#ifndef VDGetSharpness
+	PyMac_PRECHECK(VDGetSharpness);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpObj_Convert, &ci))
+		return NULL;
+	_rv = VDGetSharpness(ci,
+	                     &sharpness);
+	_res = Py_BuildValue("lH",
+	                     _rv,
+	                     sharpness);
+	return _res;
+}
+
+static PyObject *Qt_VDGetSaturation(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	VideoDigitizerComponent ci;
+	unsigned short saturation;
+#ifndef VDGetSaturation
+	PyMac_PRECHECK(VDGetSaturation);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpObj_Convert, &ci))
+		return NULL;
+	_rv = VDGetSaturation(ci,
+	                      &saturation);
+	_res = Py_BuildValue("lH",
+	                     _rv,
+	                     saturation);
+	return _res;
+}
+
+static PyObject *Qt_VDGrabOneFrame(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	VideoDigitizerComponent ci;
+#ifndef VDGrabOneFrame
+	PyMac_PRECHECK(VDGrabOneFrame);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpObj_Convert, &ci))
+		return NULL;
+	_rv = VDGrabOneFrame(ci);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_VDGetMaxAuxBuffer(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	VideoDigitizerComponent ci;
+	PixMapHandle pm;
+	Rect r;
+#ifndef VDGetMaxAuxBuffer
+	PyMac_PRECHECK(VDGetMaxAuxBuffer);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpObj_Convert, &ci))
+		return NULL;
+	_rv = VDGetMaxAuxBuffer(ci,
+	                        &pm,
+	                        &r);
+	_res = Py_BuildValue("lO&O&",
+	                     _rv,
+	                     ResObj_New, pm,
+	                     PyMac_BuildRect, &r);
+	return _res;
+}
+
+static PyObject *Qt_VDGetCurrentFlags(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	VideoDigitizerComponent ci;
+	long inputCurrentFlag;
+	long outputCurrentFlag;
+#ifndef VDGetCurrentFlags
+	PyMac_PRECHECK(VDGetCurrentFlags);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpObj_Convert, &ci))
+		return NULL;
+	_rv = VDGetCurrentFlags(ci,
+	                        &inputCurrentFlag,
+	                        &outputCurrentFlag);
+	_res = Py_BuildValue("lll",
+	                     _rv,
+	                     inputCurrentFlag,
+	                     outputCurrentFlag);
+	return _res;
+}
+
+static PyObject *Qt_VDSetKeyColor(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	VideoDigitizerComponent ci;
+	long index;
+#ifndef VDSetKeyColor
+	PyMac_PRECHECK(VDSetKeyColor);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&l",
+	                      CmpObj_Convert, &ci,
+	                      &index))
+		return NULL;
+	_rv = VDSetKeyColor(ci,
+	                    index);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_VDGetKeyColor(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	VideoDigitizerComponent ci;
+	long index;
+#ifndef VDGetKeyColor
+	PyMac_PRECHECK(VDGetKeyColor);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpObj_Convert, &ci))
+		return NULL;
+	_rv = VDGetKeyColor(ci,
+	                    &index);
+	_res = Py_BuildValue("ll",
+	                     _rv,
+	                     index);
+	return _res;
+}
+
+static PyObject *Qt_VDAddKeyColor(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	VideoDigitizerComponent ci;
+	long index;
+#ifndef VDAddKeyColor
+	PyMac_PRECHECK(VDAddKeyColor);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpObj_Convert, &ci))
+		return NULL;
+	_rv = VDAddKeyColor(ci,
+	                    &index);
+	_res = Py_BuildValue("ll",
+	                     _rv,
+	                     index);
+	return _res;
+}
+
+static PyObject *Qt_VDGetNextKeyColor(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	VideoDigitizerComponent ci;
+	long index;
+#ifndef VDGetNextKeyColor
+	PyMac_PRECHECK(VDGetNextKeyColor);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&l",
+	                      CmpObj_Convert, &ci,
+	                      &index))
+		return NULL;
+	_rv = VDGetNextKeyColor(ci,
+	                        index);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_VDSetKeyColorRange(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	VideoDigitizerComponent ci;
+	RGBColor minRGB;
+	RGBColor maxRGB;
+#ifndef VDSetKeyColorRange
+	PyMac_PRECHECK(VDSetKeyColorRange);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpObj_Convert, &ci))
+		return NULL;
+	_rv = VDSetKeyColorRange(ci,
+	                         &minRGB,
+	                         &maxRGB);
+	_res = Py_BuildValue("lO&O&",
+	                     _rv,
+	                     QdRGB_New, &minRGB,
+	                     QdRGB_New, &maxRGB);
+	return _res;
+}
+
+static PyObject *Qt_VDGetKeyColorRange(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	VideoDigitizerComponent ci;
+	RGBColor minRGB;
+	RGBColor maxRGB;
+#ifndef VDGetKeyColorRange
+	PyMac_PRECHECK(VDGetKeyColorRange);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpObj_Convert, &ci))
+		return NULL;
+	_rv = VDGetKeyColorRange(ci,
+	                         &minRGB,
+	                         &maxRGB);
+	_res = Py_BuildValue("lO&O&",
+	                     _rv,
+	                     QdRGB_New, &minRGB,
+	                     QdRGB_New, &maxRGB);
+	return _res;
+}
+
+static PyObject *Qt_VDSetInputColorSpaceMode(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	VideoDigitizerComponent ci;
+	short colorSpaceMode;
+#ifndef VDSetInputColorSpaceMode
+	PyMac_PRECHECK(VDSetInputColorSpaceMode);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&h",
+	                      CmpObj_Convert, &ci,
+	                      &colorSpaceMode))
+		return NULL;
+	_rv = VDSetInputColorSpaceMode(ci,
+	                               colorSpaceMode);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_VDGetInputColorSpaceMode(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	VideoDigitizerComponent ci;
+	short colorSpaceMode;
+#ifndef VDGetInputColorSpaceMode
+	PyMac_PRECHECK(VDGetInputColorSpaceMode);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpObj_Convert, &ci))
+		return NULL;
+	_rv = VDGetInputColorSpaceMode(ci,
+	                               &colorSpaceMode);
+	_res = Py_BuildValue("lh",
+	                     _rv,
+	                     colorSpaceMode);
+	return _res;
+}
+
+static PyObject *Qt_VDSetClipState(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	VideoDigitizerComponent ci;
+	short clipEnable;
+#ifndef VDSetClipState
+	PyMac_PRECHECK(VDSetClipState);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&h",
+	                      CmpObj_Convert, &ci,
+	                      &clipEnable))
+		return NULL;
+	_rv = VDSetClipState(ci,
+	                     clipEnable);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_VDGetClipState(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	VideoDigitizerComponent ci;
+	short clipEnable;
+#ifndef VDGetClipState
+	PyMac_PRECHECK(VDGetClipState);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpObj_Convert, &ci))
+		return NULL;
+	_rv = VDGetClipState(ci,
+	                     &clipEnable);
+	_res = Py_BuildValue("lh",
+	                     _rv,
+	                     clipEnable);
+	return _res;
+}
+
+static PyObject *Qt_VDSetClipRgn(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	VideoDigitizerComponent ci;
+	RgnHandle clipRegion;
+#ifndef VDSetClipRgn
+	PyMac_PRECHECK(VDSetClipRgn);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&O&",
+	                      CmpObj_Convert, &ci,
+	                      ResObj_Convert, &clipRegion))
+		return NULL;
+	_rv = VDSetClipRgn(ci,
+	                   clipRegion);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_VDClearClipRgn(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	VideoDigitizerComponent ci;
+	RgnHandle clipRegion;
+#ifndef VDClearClipRgn
+	PyMac_PRECHECK(VDClearClipRgn);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&O&",
+	                      CmpObj_Convert, &ci,
+	                      ResObj_Convert, &clipRegion))
+		return NULL;
+	_rv = VDClearClipRgn(ci,
+	                     clipRegion);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_VDGetCLUTInUse(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	VideoDigitizerComponent ci;
+	CTabHandle colorTableHandle;
+#ifndef VDGetCLUTInUse
+	PyMac_PRECHECK(VDGetCLUTInUse);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpObj_Convert, &ci))
+		return NULL;
+	_rv = VDGetCLUTInUse(ci,
+	                     &colorTableHandle);
+	_res = Py_BuildValue("lO&",
+	                     _rv,
+	                     ResObj_New, colorTableHandle);
+	return _res;
+}
+
+static PyObject *Qt_VDSetPLLFilterType(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	VideoDigitizerComponent ci;
+	short pllType;
+#ifndef VDSetPLLFilterType
+	PyMac_PRECHECK(VDSetPLLFilterType);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&h",
+	                      CmpObj_Convert, &ci,
+	                      &pllType))
+		return NULL;
+	_rv = VDSetPLLFilterType(ci,
+	                         pllType);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_VDGetPLLFilterType(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	VideoDigitizerComponent ci;
+	short pllType;
+#ifndef VDGetPLLFilterType
+	PyMac_PRECHECK(VDGetPLLFilterType);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpObj_Convert, &ci))
+		return NULL;
+	_rv = VDGetPLLFilterType(ci,
+	                         &pllType);
+	_res = Py_BuildValue("lh",
+	                     _rv,
+	                     pllType);
+	return _res;
+}
+
+static PyObject *Qt_VDGetMaskandValue(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	VideoDigitizerComponent ci;
+	unsigned short blendLevel;
+	long mask;
+	long value;
+#ifndef VDGetMaskandValue
+	PyMac_PRECHECK(VDGetMaskandValue);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&H",
+	                      CmpObj_Convert, &ci,
+	                      &blendLevel))
+		return NULL;
+	_rv = VDGetMaskandValue(ci,
+	                        blendLevel,
+	                        &mask,
+	                        &value);
+	_res = Py_BuildValue("lll",
+	                     _rv,
+	                     mask,
+	                     value);
+	return _res;
+}
+
+static PyObject *Qt_VDSetMasterBlendLevel(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	VideoDigitizerComponent ci;
+	unsigned short blendLevel;
+#ifndef VDSetMasterBlendLevel
+	PyMac_PRECHECK(VDSetMasterBlendLevel);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpObj_Convert, &ci))
+		return NULL;
+	_rv = VDSetMasterBlendLevel(ci,
+	                            &blendLevel);
+	_res = Py_BuildValue("lH",
+	                     _rv,
+	                     blendLevel);
+	return _res;
+}
+
+static PyObject *Qt_VDSetPlayThruOnOff(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	VideoDigitizerComponent ci;
+	short state;
+#ifndef VDSetPlayThruOnOff
+	PyMac_PRECHECK(VDSetPlayThruOnOff);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&h",
+	                      CmpObj_Convert, &ci,
+	                      &state))
+		return NULL;
+	_rv = VDSetPlayThruOnOff(ci,
+	                         state);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_VDSetFieldPreference(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	VideoDigitizerComponent ci;
+	short fieldFlag;
+#ifndef VDSetFieldPreference
+	PyMac_PRECHECK(VDSetFieldPreference);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&h",
+	                      CmpObj_Convert, &ci,
+	                      &fieldFlag))
+		return NULL;
+	_rv = VDSetFieldPreference(ci,
+	                           fieldFlag);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_VDGetFieldPreference(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	VideoDigitizerComponent ci;
+	short fieldFlag;
+#ifndef VDGetFieldPreference
+	PyMac_PRECHECK(VDGetFieldPreference);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpObj_Convert, &ci))
+		return NULL;
+	_rv = VDGetFieldPreference(ci,
+	                           &fieldFlag);
+	_res = Py_BuildValue("lh",
+	                     _rv,
+	                     fieldFlag);
+	return _res;
+}
+
+static PyObject *Qt_VDPreflightGlobalRect(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	VideoDigitizerComponent ci;
+	GrafPtr theWindow;
+	Rect globalRect;
+#ifndef VDPreflightGlobalRect
+	PyMac_PRECHECK(VDPreflightGlobalRect);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&O&",
+	                      CmpObj_Convert, &ci,
+	                      GrafObj_Convert, &theWindow))
+		return NULL;
+	_rv = VDPreflightGlobalRect(ci,
+	                            theWindow,
+	                            &globalRect);
+	_res = Py_BuildValue("lO&",
+	                     _rv,
+	                     PyMac_BuildRect, &globalRect);
+	return _res;
+}
+
+static PyObject *Qt_VDSetPlayThruGlobalRect(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	VideoDigitizerComponent ci;
+	GrafPtr theWindow;
+	Rect globalRect;
+#ifndef VDSetPlayThruGlobalRect
+	PyMac_PRECHECK(VDSetPlayThruGlobalRect);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&O&",
+	                      CmpObj_Convert, &ci,
+	                      GrafObj_Convert, &theWindow))
+		return NULL;
+	_rv = VDSetPlayThruGlobalRect(ci,
+	                              theWindow,
+	                              &globalRect);
+	_res = Py_BuildValue("lO&",
+	                     _rv,
+	                     PyMac_BuildRect, &globalRect);
+	return _res;
+}
+
+static PyObject *Qt_VDSetBlackLevelValue(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	VideoDigitizerComponent ci;
+	unsigned short blackLevel;
+#ifndef VDSetBlackLevelValue
+	PyMac_PRECHECK(VDSetBlackLevelValue);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpObj_Convert, &ci))
+		return NULL;
+	_rv = VDSetBlackLevelValue(ci,
+	                           &blackLevel);
+	_res = Py_BuildValue("lH",
+	                     _rv,
+	                     blackLevel);
+	return _res;
+}
+
+static PyObject *Qt_VDGetBlackLevelValue(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	VideoDigitizerComponent ci;
+	unsigned short blackLevel;
+#ifndef VDGetBlackLevelValue
+	PyMac_PRECHECK(VDGetBlackLevelValue);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpObj_Convert, &ci))
+		return NULL;
+	_rv = VDGetBlackLevelValue(ci,
+	                           &blackLevel);
+	_res = Py_BuildValue("lH",
+	                     _rv,
+	                     blackLevel);
+	return _res;
+}
+
+static PyObject *Qt_VDSetWhiteLevelValue(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	VideoDigitizerComponent ci;
+	unsigned short whiteLevel;
+#ifndef VDSetWhiteLevelValue
+	PyMac_PRECHECK(VDSetWhiteLevelValue);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpObj_Convert, &ci))
+		return NULL;
+	_rv = VDSetWhiteLevelValue(ci,
+	                           &whiteLevel);
+	_res = Py_BuildValue("lH",
+	                     _rv,
+	                     whiteLevel);
+	return _res;
+}
+
+static PyObject *Qt_VDGetWhiteLevelValue(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	VideoDigitizerComponent ci;
+	unsigned short whiteLevel;
+#ifndef VDGetWhiteLevelValue
+	PyMac_PRECHECK(VDGetWhiteLevelValue);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpObj_Convert, &ci))
+		return NULL;
+	_rv = VDGetWhiteLevelValue(ci,
+	                           &whiteLevel);
+	_res = Py_BuildValue("lH",
+	                     _rv,
+	                     whiteLevel);
+	return _res;
+}
+
+static PyObject *Qt_VDGetVideoDefaults(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	VideoDigitizerComponent ci;
+	unsigned short blackLevel;
+	unsigned short whiteLevel;
+	unsigned short brightness;
+	unsigned short hue;
+	unsigned short saturation;
+	unsigned short contrast;
+	unsigned short sharpness;
+#ifndef VDGetVideoDefaults
+	PyMac_PRECHECK(VDGetVideoDefaults);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpObj_Convert, &ci))
+		return NULL;
+	_rv = VDGetVideoDefaults(ci,
+	                         &blackLevel,
+	                         &whiteLevel,
+	                         &brightness,
+	                         &hue,
+	                         &saturation,
+	                         &contrast,
+	                         &sharpness);
+	_res = Py_BuildValue("lHHHHHHH",
+	                     _rv,
+	                     blackLevel,
+	                     whiteLevel,
+	                     brightness,
+	                     hue,
+	                     saturation,
+	                     contrast,
+	                     sharpness);
+	return _res;
+}
+
+static PyObject *Qt_VDGetNumberOfInputs(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	VideoDigitizerComponent ci;
+	short inputs;
+#ifndef VDGetNumberOfInputs
+	PyMac_PRECHECK(VDGetNumberOfInputs);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpObj_Convert, &ci))
+		return NULL;
+	_rv = VDGetNumberOfInputs(ci,
+	                          &inputs);
+	_res = Py_BuildValue("lh",
+	                     _rv,
+	                     inputs);
+	return _res;
+}
+
+static PyObject *Qt_VDGetInputFormat(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	VideoDigitizerComponent ci;
+	short input;
+	short format;
+#ifndef VDGetInputFormat
+	PyMac_PRECHECK(VDGetInputFormat);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&h",
+	                      CmpObj_Convert, &ci,
+	                      &input))
+		return NULL;
+	_rv = VDGetInputFormat(ci,
+	                       input,
+	                       &format);
+	_res = Py_BuildValue("lh",
+	                     _rv,
+	                     format);
+	return _res;
+}
+
+static PyObject *Qt_VDSetInput(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	VideoDigitizerComponent ci;
+	short input;
+#ifndef VDSetInput
+	PyMac_PRECHECK(VDSetInput);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&h",
+	                      CmpObj_Convert, &ci,
+	                      &input))
+		return NULL;
+	_rv = VDSetInput(ci,
+	                 input);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_VDGetInput(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	VideoDigitizerComponent ci;
+	short input;
+#ifndef VDGetInput
+	PyMac_PRECHECK(VDGetInput);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpObj_Convert, &ci))
+		return NULL;
+	_rv = VDGetInput(ci,
+	                 &input);
+	_res = Py_BuildValue("lh",
+	                     _rv,
+	                     input);
+	return _res;
+}
+
+static PyObject *Qt_VDSetInputStandard(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	VideoDigitizerComponent ci;
+	short inputStandard;
+#ifndef VDSetInputStandard
+	PyMac_PRECHECK(VDSetInputStandard);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&h",
+	                      CmpObj_Convert, &ci,
+	                      &inputStandard))
+		return NULL;
+	_rv = VDSetInputStandard(ci,
+	                         inputStandard);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_VDSetupBuffers(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	VideoDigitizerComponent ci;
+	VdigBufferRecListHandle bufferList;
+#ifndef VDSetupBuffers
+	PyMac_PRECHECK(VDSetupBuffers);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&O&",
+	                      CmpObj_Convert, &ci,
+	                      ResObj_Convert, &bufferList))
+		return NULL;
+	_rv = VDSetupBuffers(ci,
+	                     bufferList);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_VDGrabOneFrameAsync(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	VideoDigitizerComponent ci;
+	short buffer;
+#ifndef VDGrabOneFrameAsync
+	PyMac_PRECHECK(VDGrabOneFrameAsync);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&h",
+	                      CmpObj_Convert, &ci,
+	                      &buffer))
+		return NULL;
+	_rv = VDGrabOneFrameAsync(ci,
+	                          buffer);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_VDDone(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	VideoDigitizerComponent ci;
+	short buffer;
+#ifndef VDDone
+	PyMac_PRECHECK(VDDone);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&h",
+	                      CmpObj_Convert, &ci,
+	                      &buffer))
+		return NULL;
+	_rv = VDDone(ci,
+	             buffer);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_VDSetCompression(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	VideoDigitizerComponent ci;
+	OSType compressType;
+	short depth;
+	Rect bounds;
+	CodecQ spatialQuality;
+	CodecQ temporalQuality;
+	long keyFrameRate;
+#ifndef VDSetCompression
+	PyMac_PRECHECK(VDSetCompression);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&O&hlll",
+	                      CmpObj_Convert, &ci,
+	                      PyMac_GetOSType, &compressType,
+	                      &depth,
+	                      &spatialQuality,
+	                      &temporalQuality,
+	                      &keyFrameRate))
+		return NULL;
+	_rv = VDSetCompression(ci,
+	                       compressType,
+	                       depth,
+	                       &bounds,
+	                       spatialQuality,
+	                       temporalQuality,
+	                       keyFrameRate);
+	_res = Py_BuildValue("lO&",
+	                     _rv,
+	                     PyMac_BuildRect, &bounds);
+	return _res;
+}
+
+static PyObject *Qt_VDCompressOneFrameAsync(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	VideoDigitizerComponent ci;
+#ifndef VDCompressOneFrameAsync
+	PyMac_PRECHECK(VDCompressOneFrameAsync);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpObj_Convert, &ci))
+		return NULL;
+	_rv = VDCompressOneFrameAsync(ci);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_VDGetImageDescription(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	VideoDigitizerComponent ci;
+	ImageDescriptionHandle desc;
+#ifndef VDGetImageDescription
+	PyMac_PRECHECK(VDGetImageDescription);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&O&",
+	                      CmpObj_Convert, &ci,
+	                      ResObj_Convert, &desc))
+		return NULL;
+	_rv = VDGetImageDescription(ci,
+	                            desc);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_VDResetCompressSequence(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	VideoDigitizerComponent ci;
+#ifndef VDResetCompressSequence
+	PyMac_PRECHECK(VDResetCompressSequence);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpObj_Convert, &ci))
+		return NULL;
+	_rv = VDResetCompressSequence(ci);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_VDSetCompressionOnOff(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	VideoDigitizerComponent ci;
+	Boolean state;
+#ifndef VDSetCompressionOnOff
+	PyMac_PRECHECK(VDSetCompressionOnOff);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&b",
+	                      CmpObj_Convert, &ci,
+	                      &state))
+		return NULL;
+	_rv = VDSetCompressionOnOff(ci,
+	                            state);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_VDGetCompressionTypes(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	VideoDigitizerComponent ci;
+	VDCompressionListHandle h;
+#ifndef VDGetCompressionTypes
+	PyMac_PRECHECK(VDGetCompressionTypes);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&O&",
+	                      CmpObj_Convert, &ci,
+	                      ResObj_Convert, &h))
+		return NULL;
+	_rv = VDGetCompressionTypes(ci,
+	                            h);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_VDSetTimeBase(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	VideoDigitizerComponent ci;
+	TimeBase t;
+#ifndef VDSetTimeBase
+	PyMac_PRECHECK(VDSetTimeBase);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&O&",
+	                      CmpObj_Convert, &ci,
+	                      TimeBaseObj_Convert, &t))
+		return NULL;
+	_rv = VDSetTimeBase(ci,
+	                    t);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_VDSetFrameRate(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	VideoDigitizerComponent ci;
+	Fixed framesPerSecond;
+#ifndef VDSetFrameRate
+	PyMac_PRECHECK(VDSetFrameRate);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&O&",
+	                      CmpObj_Convert, &ci,
+	                      PyMac_GetFixed, &framesPerSecond))
+		return NULL;
+	_rv = VDSetFrameRate(ci,
+	                     framesPerSecond);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_VDGetDataRate(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	VideoDigitizerComponent ci;
+	long milliSecPerFrame;
+	Fixed framesPerSecond;
+	long bytesPerSecond;
+#ifndef VDGetDataRate
+	PyMac_PRECHECK(VDGetDataRate);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpObj_Convert, &ci))
+		return NULL;
+	_rv = VDGetDataRate(ci,
+	                    &milliSecPerFrame,
+	                    &framesPerSecond,
+	                    &bytesPerSecond);
+	_res = Py_BuildValue("llO&l",
+	                     _rv,
+	                     milliSecPerFrame,
+	                     PyMac_BuildFixed, framesPerSecond,
+	                     bytesPerSecond);
+	return _res;
+}
+
+static PyObject *Qt_VDGetSoundInputDriver(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	VideoDigitizerComponent ci;
+	Str255 soundDriverName;
+#ifndef VDGetSoundInputDriver
+	PyMac_PRECHECK(VDGetSoundInputDriver);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&O&",
+	                      CmpObj_Convert, &ci,
+	                      PyMac_GetStr255, soundDriverName))
+		return NULL;
+	_rv = VDGetSoundInputDriver(ci,
+	                            soundDriverName);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_VDGetDMADepths(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	VideoDigitizerComponent ci;
+	long depthArray;
+	long preferredDepth;
+#ifndef VDGetDMADepths
+	PyMac_PRECHECK(VDGetDMADepths);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpObj_Convert, &ci))
+		return NULL;
+	_rv = VDGetDMADepths(ci,
+	                     &depthArray,
+	                     &preferredDepth);
+	_res = Py_BuildValue("lll",
+	                     _rv,
+	                     depthArray,
+	                     preferredDepth);
+	return _res;
+}
+
+static PyObject *Qt_VDGetPreferredTimeScale(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	VideoDigitizerComponent ci;
+	TimeScale preferred;
+#ifndef VDGetPreferredTimeScale
+	PyMac_PRECHECK(VDGetPreferredTimeScale);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpObj_Convert, &ci))
+		return NULL;
+	_rv = VDGetPreferredTimeScale(ci,
+	                              &preferred);
+	_res = Py_BuildValue("ll",
+	                     _rv,
+	                     preferred);
+	return _res;
+}
+
+static PyObject *Qt_VDReleaseAsyncBuffers(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	VideoDigitizerComponent ci;
+#ifndef VDReleaseAsyncBuffers
+	PyMac_PRECHECK(VDReleaseAsyncBuffers);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpObj_Convert, &ci))
+		return NULL;
+	_rv = VDReleaseAsyncBuffers(ci);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_VDSetDataRate(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	VideoDigitizerComponent ci;
+	long bytesPerSecond;
+#ifndef VDSetDataRate
+	PyMac_PRECHECK(VDSetDataRate);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&l",
+	                      CmpObj_Convert, &ci,
+	                      &bytesPerSecond))
+		return NULL;
+	_rv = VDSetDataRate(ci,
+	                    bytesPerSecond);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_VDGetTimeCode(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	VideoDigitizerComponent ci;
+	TimeRecord atTime;
+	void * timeCodeFormat;
+	void * timeCodeTime;
+#ifndef VDGetTimeCode
+	PyMac_PRECHECK(VDGetTimeCode);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&ss",
+	                      CmpObj_Convert, &ci,
+	                      &timeCodeFormat,
+	                      &timeCodeTime))
+		return NULL;
+	_rv = VDGetTimeCode(ci,
+	                    &atTime,
+	                    timeCodeFormat,
+	                    timeCodeTime);
+	_res = Py_BuildValue("lO&",
+	                     _rv,
+	                     QtTimeRecord_New, &atTime);
+	return _res;
+}
+
+static PyObject *Qt_VDUseSafeBuffers(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	VideoDigitizerComponent ci;
+	Boolean useSafeBuffers;
+#ifndef VDUseSafeBuffers
+	PyMac_PRECHECK(VDUseSafeBuffers);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&b",
+	                      CmpObj_Convert, &ci,
+	                      &useSafeBuffers))
+		return NULL;
+	_rv = VDUseSafeBuffers(ci,
+	                       useSafeBuffers);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_VDGetSoundInputSource(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	VideoDigitizerComponent ci;
+	long videoInput;
+	long soundInput;
+#ifndef VDGetSoundInputSource
+	PyMac_PRECHECK(VDGetSoundInputSource);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&l",
+	                      CmpObj_Convert, &ci,
+	                      &videoInput))
+		return NULL;
+	_rv = VDGetSoundInputSource(ci,
+	                            videoInput,
+	                            &soundInput);
+	_res = Py_BuildValue("ll",
+	                     _rv,
+	                     soundInput);
+	return _res;
+}
+
+static PyObject *Qt_VDGetCompressionTime(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	VideoDigitizerComponent ci;
+	OSType compressionType;
+	short depth;
+	Rect srcRect;
+	CodecQ spatialQuality;
+	CodecQ temporalQuality;
+	unsigned long compressTime;
+#ifndef VDGetCompressionTime
+	PyMac_PRECHECK(VDGetCompressionTime);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&O&h",
+	                      CmpObj_Convert, &ci,
+	                      PyMac_GetOSType, &compressionType,
+	                      &depth))
+		return NULL;
+	_rv = VDGetCompressionTime(ci,
+	                           compressionType,
+	                           depth,
+	                           &srcRect,
+	                           &spatialQuality,
+	                           &temporalQuality,
+	                           &compressTime);
+	_res = Py_BuildValue("lO&lll",
+	                     _rv,
+	                     PyMac_BuildRect, &srcRect,
+	                     spatialQuality,
+	                     temporalQuality,
+	                     compressTime);
+	return _res;
+}
+
+static PyObject *Qt_VDSetPreferredPacketSize(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	VideoDigitizerComponent ci;
+	long preferredPacketSizeInBytes;
+#ifndef VDSetPreferredPacketSize
+	PyMac_PRECHECK(VDSetPreferredPacketSize);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&l",
+	                      CmpObj_Convert, &ci,
+	                      &preferredPacketSizeInBytes))
+		return NULL;
+	_rv = VDSetPreferredPacketSize(ci,
+	                               preferredPacketSizeInBytes);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_VDSetPreferredImageDimensions(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	VideoDigitizerComponent ci;
+	long width;
+	long height;
+#ifndef VDSetPreferredImageDimensions
+	PyMac_PRECHECK(VDSetPreferredImageDimensions);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&ll",
+	                      CmpObj_Convert, &ci,
+	                      &width,
+	                      &height))
+		return NULL;
+	_rv = VDSetPreferredImageDimensions(ci,
+	                                    width,
+	                                    height);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_VDGetPreferredImageDimensions(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	VideoDigitizerComponent ci;
+	long width;
+	long height;
+#ifndef VDGetPreferredImageDimensions
+	PyMac_PRECHECK(VDGetPreferredImageDimensions);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpObj_Convert, &ci))
+		return NULL;
+	_rv = VDGetPreferredImageDimensions(ci,
+	                                    &width,
+	                                    &height);
+	_res = Py_BuildValue("lll",
+	                     _rv,
+	                     width,
+	                     height);
+	return _res;
+}
+
+static PyObject *Qt_VDGetInputName(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	VideoDigitizerComponent ci;
+	long videoInput;
+	Str255 name;
+#ifndef VDGetInputName
+	PyMac_PRECHECK(VDGetInputName);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&lO&",
+	                      CmpObj_Convert, &ci,
+	                      &videoInput,
+	                      PyMac_GetStr255, name))
+		return NULL;
+	_rv = VDGetInputName(ci,
+	                     videoInput,
+	                     name);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_VDSetDestinationPort(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	VideoDigitizerComponent ci;
+	CGrafPtr destPort;
+#ifndef VDSetDestinationPort
+	PyMac_PRECHECK(VDSetDestinationPort);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&O&",
+	                      CmpObj_Convert, &ci,
+	                      GrafObj_Convert, &destPort))
+		return NULL;
+	_rv = VDSetDestinationPort(ci,
+	                           destPort);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_VDGetDeviceNameAndFlags(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	VideoDigitizerComponent ci;
+	Str255 outName;
+	UInt32 outNameFlags;
+#ifndef VDGetDeviceNameAndFlags
+	PyMac_PRECHECK(VDGetDeviceNameAndFlags);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&O&",
+	                      CmpObj_Convert, &ci,
+	                      PyMac_GetStr255, outName))
+		return NULL;
+	_rv = VDGetDeviceNameAndFlags(ci,
+	                              outName,
+	                              &outNameFlags);
+	_res = Py_BuildValue("ll",
+	                     _rv,
+	                     outNameFlags);
+	return _res;
+}
+
+static PyObject *Qt_VDCaptureStateChanging(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	VideoDigitizerComponent ci;
+	UInt32 inStateFlags;
+#ifndef VDCaptureStateChanging
+	PyMac_PRECHECK(VDCaptureStateChanging);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&l",
+	                      CmpObj_Convert, &ci,
+	                      &inStateFlags))
+		return NULL;
+	_rv = VDCaptureStateChanging(ci,
+	                             inStateFlags);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_XMLParseGetDetailedParseError(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	ComponentInstance aParser;
+	long errorLine;
+	StringPtr errDesc;
+#ifndef XMLParseGetDetailedParseError
+	PyMac_PRECHECK(XMLParseGetDetailedParseError);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&s",
+	                      CmpInstObj_Convert, &aParser,
+	                      &errDesc))
+		return NULL;
+	_rv = XMLParseGetDetailedParseError(aParser,
+	                                    &errorLine,
+	                                    errDesc);
+	_res = Py_BuildValue("ll",
+	                     _rv,
+	                     errorLine);
+	return _res;
+}
+
+static PyObject *Qt_XMLParseAddElement(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	ComponentInstance aParser;
+	char elementName;
+	UInt32 nameSpaceID;
+	UInt32 elementID;
+	long elementFlags;
+#ifndef XMLParseAddElement
+	PyMac_PRECHECK(XMLParseAddElement);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&ll",
+	                      CmpInstObj_Convert, &aParser,
+	                      &nameSpaceID,
+	                      &elementFlags))
+		return NULL;
+	_rv = XMLParseAddElement(aParser,
+	                         &elementName,
+	                         nameSpaceID,
+	                         &elementID,
+	                         elementFlags);
+	_res = Py_BuildValue("lcl",
+	                     _rv,
+	                     elementName,
+	                     elementID);
+	return _res;
+}
+
+static PyObject *Qt_XMLParseAddAttribute(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	ComponentInstance aParser;
+	UInt32 elementID;
+	UInt32 nameSpaceID;
+	char attributeName;
+	UInt32 attributeID;
+#ifndef XMLParseAddAttribute
+	PyMac_PRECHECK(XMLParseAddAttribute);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&ll",
+	                      CmpInstObj_Convert, &aParser,
+	                      &elementID,
+	                      &nameSpaceID))
+		return NULL;
+	_rv = XMLParseAddAttribute(aParser,
+	                           elementID,
+	                           nameSpaceID,
+	                           &attributeName,
+	                           &attributeID);
+	_res = Py_BuildValue("lcl",
+	                     _rv,
+	                     attributeName,
+	                     attributeID);
+	return _res;
+}
+
+static PyObject *Qt_XMLParseAddMultipleAttributes(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	ComponentInstance aParser;
+	UInt32 elementID;
+	UInt32 nameSpaceIDs;
+	char attributeNames;
+	UInt32 attributeIDs;
+#ifndef XMLParseAddMultipleAttributes
+	PyMac_PRECHECK(XMLParseAddMultipleAttributes);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&l",
+	                      CmpInstObj_Convert, &aParser,
+	                      &elementID))
+		return NULL;
+	_rv = XMLParseAddMultipleAttributes(aParser,
+	                                    elementID,
+	                                    &nameSpaceIDs,
+	                                    &attributeNames,
+	                                    &attributeIDs);
+	_res = Py_BuildValue("llcl",
+	                     _rv,
+	                     nameSpaceIDs,
+	                     attributeNames,
+	                     attributeIDs);
+	return _res;
+}
+
+static PyObject *Qt_XMLParseAddAttributeAndValue(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	ComponentInstance aParser;
+	UInt32 elementID;
+	UInt32 nameSpaceID;
+	char attributeName;
+	UInt32 attributeID;
+	UInt32 attributeValueKind;
+	void * attributeValueKindInfo;
+#ifndef XMLParseAddAttributeAndValue
+	PyMac_PRECHECK(XMLParseAddAttributeAndValue);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&llls",
+	                      CmpInstObj_Convert, &aParser,
+	                      &elementID,
+	                      &nameSpaceID,
+	                      &attributeValueKind,
+	                      &attributeValueKindInfo))
+		return NULL;
+	_rv = XMLParseAddAttributeAndValue(aParser,
+	                                   elementID,
+	                                   nameSpaceID,
+	                                   &attributeName,
+	                                   &attributeID,
+	                                   attributeValueKind,
+	                                   attributeValueKindInfo);
+	_res = Py_BuildValue("lcl",
+	                     _rv,
+	                     attributeName,
+	                     attributeID);
+	return _res;
+}
+
+static PyObject *Qt_XMLParseAddAttributeValueKind(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	ComponentInstance aParser;
+	UInt32 elementID;
+	UInt32 attributeID;
+	UInt32 attributeValueKind;
+	void * attributeValueKindInfo;
+#ifndef XMLParseAddAttributeValueKind
+	PyMac_PRECHECK(XMLParseAddAttributeValueKind);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&llls",
+	                      CmpInstObj_Convert, &aParser,
+	                      &elementID,
+	                      &attributeID,
+	                      &attributeValueKind,
+	                      &attributeValueKindInfo))
+		return NULL;
+	_rv = XMLParseAddAttributeValueKind(aParser,
+	                                    elementID,
+	                                    attributeID,
+	                                    attributeValueKind,
+	                                    attributeValueKindInfo);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_XMLParseAddNameSpace(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	ComponentInstance aParser;
+	char nameSpaceURL;
+	UInt32 nameSpaceID;
+#ifndef XMLParseAddNameSpace
+	PyMac_PRECHECK(XMLParseAddNameSpace);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpInstObj_Convert, &aParser))
+		return NULL;
+	_rv = XMLParseAddNameSpace(aParser,
+	                           &nameSpaceURL,
+	                           &nameSpaceID);
+	_res = Py_BuildValue("lcl",
+	                     _rv,
+	                     nameSpaceURL,
+	                     nameSpaceID);
+	return _res;
+}
+
+static PyObject *Qt_XMLParseSetOffsetAndLimit(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	ComponentInstance aParser;
+	UInt32 offset;
+	UInt32 limit;
+#ifndef XMLParseSetOffsetAndLimit
+	PyMac_PRECHECK(XMLParseSetOffsetAndLimit);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&ll",
+	                      CmpInstObj_Convert, &aParser,
+	                      &offset,
+	                      &limit))
+		return NULL;
+	_rv = XMLParseSetOffsetAndLimit(aParser,
+	                                offset,
+	                                limit);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_XMLParseSetEventParseRefCon(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	ComponentInstance aParser;
+	long refcon;
+#ifndef XMLParseSetEventParseRefCon
+	PyMac_PRECHECK(XMLParseSetEventParseRefCon);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&l",
+	                      CmpInstObj_Convert, &aParser,
+	                      &refcon))
+		return NULL;
+	_rv = XMLParseSetEventParseRefCon(aParser,
+	                                  refcon);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_SGInitialize(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	SeqGrabComponent s;
+#ifndef SGInitialize
+	PyMac_PRECHECK(SGInitialize);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpObj_Convert, &s))
+		return NULL;
+	_rv = SGInitialize(s);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_SGSetDataOutput(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	SeqGrabComponent s;
+	FSSpec movieFile;
+	long whereFlags;
+#ifndef SGSetDataOutput
+	PyMac_PRECHECK(SGSetDataOutput);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&O&l",
+	                      CmpObj_Convert, &s,
+	                      PyMac_GetFSSpec, &movieFile,
+	                      &whereFlags))
+		return NULL;
+	_rv = SGSetDataOutput(s,
+	                      &movieFile,
+	                      whereFlags);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_SGGetDataOutput(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	SeqGrabComponent s;
+	FSSpec movieFile;
+	long whereFlags;
+#ifndef SGGetDataOutput
+	PyMac_PRECHECK(SGGetDataOutput);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&O&",
+	                      CmpObj_Convert, &s,
+	                      PyMac_GetFSSpec, &movieFile))
+		return NULL;
+	_rv = SGGetDataOutput(s,
+	                      &movieFile,
+	                      &whereFlags);
+	_res = Py_BuildValue("ll",
+	                     _rv,
+	                     whereFlags);
+	return _res;
+}
+
+static PyObject *Qt_SGSetGWorld(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	SeqGrabComponent s;
+	CGrafPtr gp;
+	GDHandle gd;
+#ifndef SGSetGWorld
+	PyMac_PRECHECK(SGSetGWorld);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&O&O&",
+	                      CmpObj_Convert, &s,
+	                      GrafObj_Convert, &gp,
+	                      OptResObj_Convert, &gd))
+		return NULL;
+	_rv = SGSetGWorld(s,
+	                  gp,
+	                  gd);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_SGGetGWorld(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	SeqGrabComponent s;
+	CGrafPtr gp;
+	GDHandle gd;
+#ifndef SGGetGWorld
+	PyMac_PRECHECK(SGGetGWorld);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpObj_Convert, &s))
+		return NULL;
+	_rv = SGGetGWorld(s,
+	                  &gp,
+	                  &gd);
+	_res = Py_BuildValue("lO&O&",
+	                     _rv,
+	                     GrafObj_New, gp,
+	                     OptResObj_New, gd);
+	return _res;
+}
+
+static PyObject *Qt_SGNewChannel(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	SeqGrabComponent s;
+	OSType channelType;
+	SGChannel ref;
+#ifndef SGNewChannel
+	PyMac_PRECHECK(SGNewChannel);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&O&",
+	                      CmpObj_Convert, &s,
+	                      PyMac_GetOSType, &channelType))
+		return NULL;
+	_rv = SGNewChannel(s,
+	                   channelType,
+	                   &ref);
+	_res = Py_BuildValue("lO&",
+	                     _rv,
+	                     CmpInstObj_New, ref);
+	return _res;
+}
+
+static PyObject *Qt_SGDisposeChannel(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	SeqGrabComponent s;
+	SGChannel c;
+#ifndef SGDisposeChannel
+	PyMac_PRECHECK(SGDisposeChannel);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&O&",
+	                      CmpObj_Convert, &s,
+	                      CmpInstObj_Convert, &c))
+		return NULL;
+	_rv = SGDisposeChannel(s,
+	                       c);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_SGStartPreview(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	SeqGrabComponent s;
+#ifndef SGStartPreview
+	PyMac_PRECHECK(SGStartPreview);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpObj_Convert, &s))
+		return NULL;
+	_rv = SGStartPreview(s);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_SGStartRecord(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	SeqGrabComponent s;
+#ifndef SGStartRecord
+	PyMac_PRECHECK(SGStartRecord);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpObj_Convert, &s))
+		return NULL;
+	_rv = SGStartRecord(s);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_SGIdle(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	SeqGrabComponent s;
+#ifndef SGIdle
+	PyMac_PRECHECK(SGIdle);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpObj_Convert, &s))
+		return NULL;
+	_rv = SGIdle(s);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_SGStop(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	SeqGrabComponent s;
+#ifndef SGStop
+	PyMac_PRECHECK(SGStop);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpObj_Convert, &s))
+		return NULL;
+	_rv = SGStop(s);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_SGPause(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	SeqGrabComponent s;
+	Boolean pause;
+#ifndef SGPause
+	PyMac_PRECHECK(SGPause);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&b",
+	                      CmpObj_Convert, &s,
+	                      &pause))
+		return NULL;
+	_rv = SGPause(s,
+	              pause);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_SGPrepare(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	SeqGrabComponent s;
+	Boolean prepareForPreview;
+	Boolean prepareForRecord;
+#ifndef SGPrepare
+	PyMac_PRECHECK(SGPrepare);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&bb",
+	                      CmpObj_Convert, &s,
+	                      &prepareForPreview,
+	                      &prepareForRecord))
+		return NULL;
+	_rv = SGPrepare(s,
+	                prepareForPreview,
+	                prepareForRecord);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_SGRelease(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	SeqGrabComponent s;
+#ifndef SGRelease
+	PyMac_PRECHECK(SGRelease);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpObj_Convert, &s))
+		return NULL;
+	_rv = SGRelease(s);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_SGGetMovie(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	Movie _rv;
+	SeqGrabComponent s;
+#ifndef SGGetMovie
+	PyMac_PRECHECK(SGGetMovie);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpObj_Convert, &s))
+		return NULL;
+	_rv = SGGetMovie(s);
+	_res = Py_BuildValue("O&",
+	                     MovieObj_New, _rv);
+	return _res;
+}
+
+static PyObject *Qt_SGSetMaximumRecordTime(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	SeqGrabComponent s;
+	unsigned long ticks;
+#ifndef SGSetMaximumRecordTime
+	PyMac_PRECHECK(SGSetMaximumRecordTime);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&l",
+	                      CmpObj_Convert, &s,
+	                      &ticks))
+		return NULL;
+	_rv = SGSetMaximumRecordTime(s,
+	                             ticks);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_SGGetMaximumRecordTime(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	SeqGrabComponent s;
+	unsigned long ticks;
+#ifndef SGGetMaximumRecordTime
+	PyMac_PRECHECK(SGGetMaximumRecordTime);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpObj_Convert, &s))
+		return NULL;
+	_rv = SGGetMaximumRecordTime(s,
+	                             &ticks);
+	_res = Py_BuildValue("ll",
+	                     _rv,
+	                     ticks);
+	return _res;
+}
+
+static PyObject *Qt_SGGetStorageSpaceRemaining(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	SeqGrabComponent s;
+	unsigned long bytes;
+#ifndef SGGetStorageSpaceRemaining
+	PyMac_PRECHECK(SGGetStorageSpaceRemaining);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpObj_Convert, &s))
+		return NULL;
+	_rv = SGGetStorageSpaceRemaining(s,
+	                                 &bytes);
+	_res = Py_BuildValue("ll",
+	                     _rv,
+	                     bytes);
+	return _res;
+}
+
+static PyObject *Qt_SGGetTimeRemaining(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	SeqGrabComponent s;
+	long ticksLeft;
+#ifndef SGGetTimeRemaining
+	PyMac_PRECHECK(SGGetTimeRemaining);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpObj_Convert, &s))
+		return NULL;
+	_rv = SGGetTimeRemaining(s,
+	                         &ticksLeft);
+	_res = Py_BuildValue("ll",
+	                     _rv,
+	                     ticksLeft);
+	return _res;
+}
+
+static PyObject *Qt_SGGrabPict(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	SeqGrabComponent s;
+	PicHandle p;
+	Rect bounds;
+	short offscreenDepth;
+	long grabPictFlags;
+#ifndef SGGrabPict
+	PyMac_PRECHECK(SGGrabPict);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&O&hl",
+	                      CmpObj_Convert, &s,
+	                      PyMac_GetRect, &bounds,
+	                      &offscreenDepth,
+	                      &grabPictFlags))
+		return NULL;
+	_rv = SGGrabPict(s,
+	                 &p,
+	                 &bounds,
+	                 offscreenDepth,
+	                 grabPictFlags);
+	_res = Py_BuildValue("lO&",
+	                     _rv,
+	                     ResObj_New, p);
+	return _res;
+}
+
+static PyObject *Qt_SGGetLastMovieResID(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	SeqGrabComponent s;
+	short resID;
+#ifndef SGGetLastMovieResID
+	PyMac_PRECHECK(SGGetLastMovieResID);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpObj_Convert, &s))
+		return NULL;
+	_rv = SGGetLastMovieResID(s,
+	                          &resID);
+	_res = Py_BuildValue("lh",
+	                     _rv,
+	                     resID);
+	return _res;
+}
+
+static PyObject *Qt_SGSetFlags(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	SeqGrabComponent s;
+	long sgFlags;
+#ifndef SGSetFlags
+	PyMac_PRECHECK(SGSetFlags);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&l",
+	                      CmpObj_Convert, &s,
+	                      &sgFlags))
+		return NULL;
+	_rv = SGSetFlags(s,
+	                 sgFlags);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_SGGetFlags(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	SeqGrabComponent s;
+	long sgFlags;
+#ifndef SGGetFlags
+	PyMac_PRECHECK(SGGetFlags);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpObj_Convert, &s))
+		return NULL;
+	_rv = SGGetFlags(s,
+	                 &sgFlags);
+	_res = Py_BuildValue("ll",
+	                     _rv,
+	                     sgFlags);
+	return _res;
+}
+
+static PyObject *Qt_SGNewChannelFromComponent(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	SeqGrabComponent s;
+	SGChannel newChannel;
+	Component sgChannelComponent;
+#ifndef SGNewChannelFromComponent
+	PyMac_PRECHECK(SGNewChannelFromComponent);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&O&",
+	                      CmpObj_Convert, &s,
+	                      CmpObj_Convert, &sgChannelComponent))
+		return NULL;
+	_rv = SGNewChannelFromComponent(s,
+	                                &newChannel,
+	                                sgChannelComponent);
+	_res = Py_BuildValue("lO&",
+	                     _rv,
+	                     CmpInstObj_New, newChannel);
+	return _res;
+}
+
+static PyObject *Qt_SGSetSettings(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	SeqGrabComponent s;
+	UserData ud;
+	long flags;
+#ifndef SGSetSettings
+	PyMac_PRECHECK(SGSetSettings);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&O&l",
+	                      CmpObj_Convert, &s,
+	                      UserDataObj_Convert, &ud,
+	                      &flags))
+		return NULL;
+	_rv = SGSetSettings(s,
+	                    ud,
+	                    flags);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_SGGetSettings(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	SeqGrabComponent s;
+	UserData ud;
+	long flags;
+#ifndef SGGetSettings
+	PyMac_PRECHECK(SGGetSettings);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&l",
+	                      CmpObj_Convert, &s,
+	                      &flags))
+		return NULL;
+	_rv = SGGetSettings(s,
+	                    &ud,
+	                    flags);
+	_res = Py_BuildValue("lO&",
+	                     _rv,
+	                     UserDataObj_New, ud);
+	return _res;
+}
+
+static PyObject *Qt_SGGetIndChannel(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	SeqGrabComponent s;
+	short index;
+	SGChannel ref;
+	OSType chanType;
+#ifndef SGGetIndChannel
+	PyMac_PRECHECK(SGGetIndChannel);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&h",
+	                      CmpObj_Convert, &s,
+	                      &index))
+		return NULL;
+	_rv = SGGetIndChannel(s,
+	                      index,
+	                      &ref,
+	                      &chanType);
+	_res = Py_BuildValue("lO&O&",
+	                     _rv,
+	                     CmpInstObj_New, ref,
+	                     PyMac_BuildOSType, chanType);
+	return _res;
+}
+
+static PyObject *Qt_SGUpdate(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	SeqGrabComponent s;
+	RgnHandle updateRgn;
+#ifndef SGUpdate
+	PyMac_PRECHECK(SGUpdate);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&O&",
+	                      CmpObj_Convert, &s,
+	                      ResObj_Convert, &updateRgn))
+		return NULL;
+	_rv = SGUpdate(s,
+	               updateRgn);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_SGGetPause(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	SeqGrabComponent s;
+	Boolean paused;
+#ifndef SGGetPause
+	PyMac_PRECHECK(SGGetPause);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpObj_Convert, &s))
+		return NULL;
+	_rv = SGGetPause(s,
+	                 &paused);
+	_res = Py_BuildValue("lb",
+	                     _rv,
+	                     paused);
+	return _res;
+}
+
+static PyObject *Qt_SGSetChannelSettings(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	SeqGrabComponent s;
+	SGChannel c;
+	UserData ud;
+	long flags;
+#ifndef SGSetChannelSettings
+	PyMac_PRECHECK(SGSetChannelSettings);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&O&O&l",
+	                      CmpObj_Convert, &s,
+	                      CmpInstObj_Convert, &c,
+	                      UserDataObj_Convert, &ud,
+	                      &flags))
+		return NULL;
+	_rv = SGSetChannelSettings(s,
+	                           c,
+	                           ud,
+	                           flags);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_SGGetChannelSettings(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	SeqGrabComponent s;
+	SGChannel c;
+	UserData ud;
+	long flags;
+#ifndef SGGetChannelSettings
+	PyMac_PRECHECK(SGGetChannelSettings);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&O&l",
+	                      CmpObj_Convert, &s,
+	                      CmpInstObj_Convert, &c,
+	                      &flags))
+		return NULL;
+	_rv = SGGetChannelSettings(s,
+	                           c,
+	                           &ud,
+	                           flags);
+	_res = Py_BuildValue("lO&",
+	                     _rv,
+	                     UserDataObj_New, ud);
+	return _res;
+}
+
+static PyObject *Qt_SGGetMode(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	SeqGrabComponent s;
+	Boolean previewMode;
+	Boolean recordMode;
+#ifndef SGGetMode
+	PyMac_PRECHECK(SGGetMode);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpObj_Convert, &s))
+		return NULL;
+	_rv = SGGetMode(s,
+	                &previewMode,
+	                &recordMode);
+	_res = Py_BuildValue("lbb",
+	                     _rv,
+	                     previewMode,
+	                     recordMode);
+	return _res;
+}
+
+static PyObject *Qt_SGSetDataRef(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	SeqGrabComponent s;
+	Handle dataRef;
+	OSType dataRefType;
+	long whereFlags;
+#ifndef SGSetDataRef
+	PyMac_PRECHECK(SGSetDataRef);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&O&O&l",
+	                      CmpObj_Convert, &s,
+	                      ResObj_Convert, &dataRef,
+	                      PyMac_GetOSType, &dataRefType,
+	                      &whereFlags))
+		return NULL;
+	_rv = SGSetDataRef(s,
+	                   dataRef,
+	                   dataRefType,
+	                   whereFlags);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_SGGetDataRef(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	SeqGrabComponent s;
+	Handle dataRef;
+	OSType dataRefType;
+	long whereFlags;
+#ifndef SGGetDataRef
+	PyMac_PRECHECK(SGGetDataRef);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpObj_Convert, &s))
+		return NULL;
+	_rv = SGGetDataRef(s,
+	                   &dataRef,
+	                   &dataRefType,
+	                   &whereFlags);
+	_res = Py_BuildValue("lO&O&l",
+	                     _rv,
+	                     ResObj_New, dataRef,
+	                     PyMac_BuildOSType, dataRefType,
+	                     whereFlags);
+	return _res;
+}
+
+static PyObject *Qt_SGNewOutput(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	SeqGrabComponent s;
+	Handle dataRef;
+	OSType dataRefType;
+	long whereFlags;
+	SGOutput sgOut;
+#ifndef SGNewOutput
+	PyMac_PRECHECK(SGNewOutput);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&O&O&l",
+	                      CmpObj_Convert, &s,
+	                      ResObj_Convert, &dataRef,
+	                      PyMac_GetOSType, &dataRefType,
+	                      &whereFlags))
+		return NULL;
+	_rv = SGNewOutput(s,
+	                  dataRef,
+	                  dataRefType,
+	                  whereFlags,
+	                  &sgOut);
+	_res = Py_BuildValue("lO&",
+	                     _rv,
+	                     SGOutputObj_New, sgOut);
+	return _res;
+}
+
+static PyObject *Qt_SGDisposeOutput(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	SeqGrabComponent s;
+	SGOutput sgOut;
+#ifndef SGDisposeOutput
+	PyMac_PRECHECK(SGDisposeOutput);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&O&",
+	                      CmpObj_Convert, &s,
+	                      SGOutputObj_Convert, &sgOut))
+		return NULL;
+	_rv = SGDisposeOutput(s,
+	                      sgOut);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_SGSetOutputFlags(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	SeqGrabComponent s;
+	SGOutput sgOut;
+	long whereFlags;
+#ifndef SGSetOutputFlags
+	PyMac_PRECHECK(SGSetOutputFlags);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&O&l",
+	                      CmpObj_Convert, &s,
+	                      SGOutputObj_Convert, &sgOut,
+	                      &whereFlags))
+		return NULL;
+	_rv = SGSetOutputFlags(s,
+	                       sgOut,
+	                       whereFlags);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_SGSetChannelOutput(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	SeqGrabComponent s;
+	SGChannel c;
+	SGOutput sgOut;
+#ifndef SGSetChannelOutput
+	PyMac_PRECHECK(SGSetChannelOutput);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&O&O&",
+	                      CmpObj_Convert, &s,
+	                      CmpInstObj_Convert, &c,
+	                      SGOutputObj_Convert, &sgOut))
+		return NULL;
+	_rv = SGSetChannelOutput(s,
+	                         c,
+	                         sgOut);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_SGGetDataOutputStorageSpaceRemaining(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	SeqGrabComponent s;
+	SGOutput sgOut;
+	unsigned long space;
+#ifndef SGGetDataOutputStorageSpaceRemaining
+	PyMac_PRECHECK(SGGetDataOutputStorageSpaceRemaining);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&O&",
+	                      CmpObj_Convert, &s,
+	                      SGOutputObj_Convert, &sgOut))
+		return NULL;
+	_rv = SGGetDataOutputStorageSpaceRemaining(s,
+	                                           sgOut,
+	                                           &space);
+	_res = Py_BuildValue("ll",
+	                     _rv,
+	                     space);
+	return _res;
+}
+
+static PyObject *Qt_SGHandleUpdateEvent(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	SeqGrabComponent s;
+	EventRecord event;
+	Boolean handled;
+#ifndef SGHandleUpdateEvent
+	PyMac_PRECHECK(SGHandleUpdateEvent);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&O&",
+	                      CmpObj_Convert, &s,
+	                      PyMac_GetEventRecord, &event))
+		return NULL;
+	_rv = SGHandleUpdateEvent(s,
+	                          &event,
+	                          &handled);
+	_res = Py_BuildValue("lb",
+	                     _rv,
+	                     handled);
+	return _res;
+}
+
+static PyObject *Qt_SGSetOutputNextOutput(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	SeqGrabComponent s;
+	SGOutput sgOut;
+	SGOutput nextOut;
+#ifndef SGSetOutputNextOutput
+	PyMac_PRECHECK(SGSetOutputNextOutput);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&O&O&",
+	                      CmpObj_Convert, &s,
+	                      SGOutputObj_Convert, &sgOut,
+	                      SGOutputObj_Convert, &nextOut))
+		return NULL;
+	_rv = SGSetOutputNextOutput(s,
+	                            sgOut,
+	                            nextOut);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_SGGetOutputNextOutput(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	SeqGrabComponent s;
+	SGOutput sgOut;
+	SGOutput nextOut;
+#ifndef SGGetOutputNextOutput
+	PyMac_PRECHECK(SGGetOutputNextOutput);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&O&",
+	                      CmpObj_Convert, &s,
+	                      SGOutputObj_Convert, &sgOut))
+		return NULL;
+	_rv = SGGetOutputNextOutput(s,
+	                            sgOut,
+	                            &nextOut);
+	_res = Py_BuildValue("lO&",
+	                     _rv,
+	                     SGOutputObj_New, nextOut);
+	return _res;
+}
+
+static PyObject *Qt_SGSetOutputMaximumOffset(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	SeqGrabComponent s;
+	SGOutput sgOut;
+	wide maxOffset;
+#ifndef SGSetOutputMaximumOffset
+	PyMac_PRECHECK(SGSetOutputMaximumOffset);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&O&O&",
+	                      CmpObj_Convert, &s,
+	                      SGOutputObj_Convert, &sgOut,
+	                      PyMac_Getwide, &maxOffset))
+		return NULL;
+	_rv = SGSetOutputMaximumOffset(s,
+	                               sgOut,
+	                               &maxOffset);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_SGGetOutputMaximumOffset(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	SeqGrabComponent s;
+	SGOutput sgOut;
+	wide maxOffset;
+#ifndef SGGetOutputMaximumOffset
+	PyMac_PRECHECK(SGGetOutputMaximumOffset);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&O&",
+	                      CmpObj_Convert, &s,
+	                      SGOutputObj_Convert, &sgOut))
+		return NULL;
+	_rv = SGGetOutputMaximumOffset(s,
+	                               sgOut,
+	                               &maxOffset);
+	_res = Py_BuildValue("lO&",
+	                     _rv,
+	                     PyMac_Buildwide, maxOffset);
+	return _res;
+}
+
+static PyObject *Qt_SGGetOutputDataReference(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	SeqGrabComponent s;
+	SGOutput sgOut;
+	Handle dataRef;
+	OSType dataRefType;
+#ifndef SGGetOutputDataReference
+	PyMac_PRECHECK(SGGetOutputDataReference);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&O&",
+	                      CmpObj_Convert, &s,
+	                      SGOutputObj_Convert, &sgOut))
+		return NULL;
+	_rv = SGGetOutputDataReference(s,
+	                               sgOut,
+	                               &dataRef,
+	                               &dataRefType);
+	_res = Py_BuildValue("lO&O&",
+	                     _rv,
+	                     ResObj_New, dataRef,
+	                     PyMac_BuildOSType, dataRefType);
+	return _res;
+}
+
+static PyObject *Qt_SGWriteExtendedMovieData(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	SeqGrabComponent s;
+	SGChannel c;
+	Ptr p;
+	long len;
+	wide offset;
+	SGOutput sgOut;
+#ifndef SGWriteExtendedMovieData
+	PyMac_PRECHECK(SGWriteExtendedMovieData);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&O&sl",
+	                      CmpObj_Convert, &s,
+	                      CmpInstObj_Convert, &c,
+	                      &p,
+	                      &len))
+		return NULL;
+	_rv = SGWriteExtendedMovieData(s,
+	                               c,
+	                               p,
+	                               len,
+	                               &offset,
+	                               &sgOut);
+	_res = Py_BuildValue("lO&O&",
+	                     _rv,
+	                     PyMac_Buildwide, offset,
+	                     SGOutputObj_New, sgOut);
+	return _res;
+}
+
+static PyObject *Qt_SGGetStorageSpaceRemaining64(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	SeqGrabComponent s;
+	wide bytes;
+#ifndef SGGetStorageSpaceRemaining64
+	PyMac_PRECHECK(SGGetStorageSpaceRemaining64);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpObj_Convert, &s))
+		return NULL;
+	_rv = SGGetStorageSpaceRemaining64(s,
+	                                   &bytes);
+	_res = Py_BuildValue("lO&",
+	                     _rv,
+	                     PyMac_Buildwide, bytes);
+	return _res;
+}
+
+static PyObject *Qt_SGGetDataOutputStorageSpaceRemaining64(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	SeqGrabComponent s;
+	SGOutput sgOut;
+	wide space;
+#ifndef SGGetDataOutputStorageSpaceRemaining64
+	PyMac_PRECHECK(SGGetDataOutputStorageSpaceRemaining64);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&O&",
+	                      CmpObj_Convert, &s,
+	                      SGOutputObj_Convert, &sgOut))
+		return NULL;
+	_rv = SGGetDataOutputStorageSpaceRemaining64(s,
+	                                             sgOut,
+	                                             &space);
+	_res = Py_BuildValue("lO&",
+	                     _rv,
+	                     PyMac_Buildwide, space);
+	return _res;
+}
+
+static PyObject *Qt_SGWriteMovieData(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	SeqGrabComponent s;
+	SGChannel c;
+	Ptr p;
+	long len;
+	long offset;
+#ifndef SGWriteMovieData
+	PyMac_PRECHECK(SGWriteMovieData);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&O&sl",
+	                      CmpObj_Convert, &s,
+	                      CmpInstObj_Convert, &c,
+	                      &p,
+	                      &len))
+		return NULL;
+	_rv = SGWriteMovieData(s,
+	                       c,
+	                       p,
+	                       len,
+	                       &offset);
+	_res = Py_BuildValue("ll",
+	                     _rv,
+	                     offset);
+	return _res;
+}
+
+static PyObject *Qt_SGGetTimeBase(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	SeqGrabComponent s;
+	TimeBase tb;
+#ifndef SGGetTimeBase
+	PyMac_PRECHECK(SGGetTimeBase);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpObj_Convert, &s))
+		return NULL;
+	_rv = SGGetTimeBase(s,
+	                    &tb);
+	_res = Py_BuildValue("lO&",
+	                     _rv,
+	                     TimeBaseObj_New, tb);
+	return _res;
+}
+
+static PyObject *Qt_SGAddMovieData(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	SeqGrabComponent s;
+	SGChannel c;
+	Ptr p;
+	long len;
+	long offset;
+	long chRefCon;
+	TimeValue time;
+	short writeType;
+#ifndef SGAddMovieData
+	PyMac_PRECHECK(SGAddMovieData);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&O&slllh",
+	                      CmpObj_Convert, &s,
+	                      CmpInstObj_Convert, &c,
+	                      &p,
+	                      &len,
+	                      &chRefCon,
+	                      &time,
+	                      &writeType))
+		return NULL;
+	_rv = SGAddMovieData(s,
+	                     c,
+	                     p,
+	                     len,
+	                     &offset,
+	                     chRefCon,
+	                     time,
+	                     writeType);
+	_res = Py_BuildValue("ll",
+	                     _rv,
+	                     offset);
+	return _res;
+}
+
+static PyObject *Qt_SGChangedSource(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	SeqGrabComponent s;
+	SGChannel c;
+#ifndef SGChangedSource
+	PyMac_PRECHECK(SGChangedSource);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&O&",
+	                      CmpObj_Convert, &s,
+	                      CmpInstObj_Convert, &c))
+		return NULL;
+	_rv = SGChangedSource(s,
+	                      c);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_SGAddExtendedMovieData(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	SeqGrabComponent s;
+	SGChannel c;
+	Ptr p;
+	long len;
+	wide offset;
+	long chRefCon;
+	TimeValue time;
+	short writeType;
+	SGOutput whichOutput;
+#ifndef SGAddExtendedMovieData
+	PyMac_PRECHECK(SGAddExtendedMovieData);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&O&slllh",
+	                      CmpObj_Convert, &s,
+	                      CmpInstObj_Convert, &c,
+	                      &p,
+	                      &len,
+	                      &chRefCon,
+	                      &time,
+	                      &writeType))
+		return NULL;
+	_rv = SGAddExtendedMovieData(s,
+	                             c,
+	                             p,
+	                             len,
+	                             &offset,
+	                             chRefCon,
+	                             time,
+	                             writeType,
+	                             &whichOutput);
+	_res = Py_BuildValue("lO&O&",
+	                     _rv,
+	                     PyMac_Buildwide, offset,
+	                     SGOutputObj_New, whichOutput);
+	return _res;
+}
+
+static PyObject *Qt_SGAddOutputDataRefToMedia(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	SeqGrabComponent s;
+	SGOutput sgOut;
+	Media theMedia;
+	SampleDescriptionHandle desc;
+#ifndef SGAddOutputDataRefToMedia
+	PyMac_PRECHECK(SGAddOutputDataRefToMedia);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&O&O&O&",
+	                      CmpObj_Convert, &s,
+	                      SGOutputObj_Convert, &sgOut,
+	                      MediaObj_Convert, &theMedia,
+	                      ResObj_Convert, &desc))
+		return NULL;
+	_rv = SGAddOutputDataRefToMedia(s,
+	                                sgOut,
+	                                theMedia,
+	                                desc);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_SGSetSettingsSummary(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	SeqGrabComponent s;
+	Handle summaryText;
+#ifndef SGSetSettingsSummary
+	PyMac_PRECHECK(SGSetSettingsSummary);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&O&",
+	                      CmpObj_Convert, &s,
+	                      ResObj_Convert, &summaryText))
+		return NULL;
+	_rv = SGSetSettingsSummary(s,
+	                           summaryText);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_SGSetChannelUsage(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	SGChannel c;
+	long usage;
+#ifndef SGSetChannelUsage
+	PyMac_PRECHECK(SGSetChannelUsage);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&l",
+	                      CmpInstObj_Convert, &c,
+	                      &usage))
+		return NULL;
+	_rv = SGSetChannelUsage(c,
+	                        usage);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_SGGetChannelUsage(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	SGChannel c;
+	long usage;
+#ifndef SGGetChannelUsage
+	PyMac_PRECHECK(SGGetChannelUsage);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpInstObj_Convert, &c))
+		return NULL;
+	_rv = SGGetChannelUsage(c,
+	                        &usage);
+	_res = Py_BuildValue("ll",
+	                     _rv,
+	                     usage);
+	return _res;
+}
+
+static PyObject *Qt_SGSetChannelBounds(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	SGChannel c;
+	Rect bounds;
+#ifndef SGSetChannelBounds
+	PyMac_PRECHECK(SGSetChannelBounds);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&O&",
+	                      CmpInstObj_Convert, &c,
+	                      PyMac_GetRect, &bounds))
+		return NULL;
+	_rv = SGSetChannelBounds(c,
+	                         &bounds);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_SGGetChannelBounds(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	SGChannel c;
+	Rect bounds;
+#ifndef SGGetChannelBounds
+	PyMac_PRECHECK(SGGetChannelBounds);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpInstObj_Convert, &c))
+		return NULL;
+	_rv = SGGetChannelBounds(c,
+	                         &bounds);
+	_res = Py_BuildValue("lO&",
+	                     _rv,
+	                     PyMac_BuildRect, &bounds);
+	return _res;
+}
+
+static PyObject *Qt_SGSetChannelVolume(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	SGChannel c;
+	short volume;
+#ifndef SGSetChannelVolume
+	PyMac_PRECHECK(SGSetChannelVolume);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&h",
+	                      CmpInstObj_Convert, &c,
+	                      &volume))
+		return NULL;
+	_rv = SGSetChannelVolume(c,
+	                         volume);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_SGGetChannelVolume(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	SGChannel c;
+	short volume;
+#ifndef SGGetChannelVolume
+	PyMac_PRECHECK(SGGetChannelVolume);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpInstObj_Convert, &c))
+		return NULL;
+	_rv = SGGetChannelVolume(c,
+	                         &volume);
+	_res = Py_BuildValue("lh",
+	                     _rv,
+	                     volume);
+	return _res;
+}
+
+static PyObject *Qt_SGGetChannelInfo(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	SGChannel c;
+	long channelInfo;
+#ifndef SGGetChannelInfo
+	PyMac_PRECHECK(SGGetChannelInfo);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpInstObj_Convert, &c))
+		return NULL;
+	_rv = SGGetChannelInfo(c,
+	                       &channelInfo);
+	_res = Py_BuildValue("ll",
+	                     _rv,
+	                     channelInfo);
+	return _res;
+}
+
+static PyObject *Qt_SGSetChannelPlayFlags(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	SGChannel c;
+	long playFlags;
+#ifndef SGSetChannelPlayFlags
+	PyMac_PRECHECK(SGSetChannelPlayFlags);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&l",
+	                      CmpInstObj_Convert, &c,
+	                      &playFlags))
+		return NULL;
+	_rv = SGSetChannelPlayFlags(c,
+	                            playFlags);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_SGGetChannelPlayFlags(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	SGChannel c;
+	long playFlags;
+#ifndef SGGetChannelPlayFlags
+	PyMac_PRECHECK(SGGetChannelPlayFlags);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpInstObj_Convert, &c))
+		return NULL;
+	_rv = SGGetChannelPlayFlags(c,
+	                            &playFlags);
+	_res = Py_BuildValue("ll",
+	                     _rv,
+	                     playFlags);
+	return _res;
+}
+
+static PyObject *Qt_SGSetChannelMaxFrames(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	SGChannel c;
+	long frameCount;
+#ifndef SGSetChannelMaxFrames
+	PyMac_PRECHECK(SGSetChannelMaxFrames);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&l",
+	                      CmpInstObj_Convert, &c,
+	                      &frameCount))
+		return NULL;
+	_rv = SGSetChannelMaxFrames(c,
+	                            frameCount);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_SGGetChannelMaxFrames(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	SGChannel c;
+	long frameCount;
+#ifndef SGGetChannelMaxFrames
+	PyMac_PRECHECK(SGGetChannelMaxFrames);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpInstObj_Convert, &c))
+		return NULL;
+	_rv = SGGetChannelMaxFrames(c,
+	                            &frameCount);
+	_res = Py_BuildValue("ll",
+	                     _rv,
+	                     frameCount);
+	return _res;
+}
+
+static PyObject *Qt_SGSetChannelRefCon(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	SGChannel c;
+	long refCon;
+#ifndef SGSetChannelRefCon
+	PyMac_PRECHECK(SGSetChannelRefCon);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&l",
+	                      CmpInstObj_Convert, &c,
+	                      &refCon))
+		return NULL;
+	_rv = SGSetChannelRefCon(c,
+	                         refCon);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_SGSetChannelClip(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	SGChannel c;
+	RgnHandle theClip;
+#ifndef SGSetChannelClip
+	PyMac_PRECHECK(SGSetChannelClip);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&O&",
+	                      CmpInstObj_Convert, &c,
+	                      ResObj_Convert, &theClip))
+		return NULL;
+	_rv = SGSetChannelClip(c,
+	                       theClip);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_SGGetChannelClip(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	SGChannel c;
+	RgnHandle theClip;
+#ifndef SGGetChannelClip
+	PyMac_PRECHECK(SGGetChannelClip);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpInstObj_Convert, &c))
+		return NULL;
+	_rv = SGGetChannelClip(c,
+	                       &theClip);
+	_res = Py_BuildValue("lO&",
+	                     _rv,
+	                     ResObj_New, theClip);
+	return _res;
+}
+
+static PyObject *Qt_SGGetChannelSampleDescription(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	SGChannel c;
+	Handle sampleDesc;
+#ifndef SGGetChannelSampleDescription
+	PyMac_PRECHECK(SGGetChannelSampleDescription);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&O&",
+	                      CmpInstObj_Convert, &c,
+	                      ResObj_Convert, &sampleDesc))
+		return NULL;
+	_rv = SGGetChannelSampleDescription(c,
+	                                    sampleDesc);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_SGSetChannelDevice(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	SGChannel c;
+	StringPtr name;
+#ifndef SGSetChannelDevice
+	PyMac_PRECHECK(SGSetChannelDevice);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&s",
+	                      CmpInstObj_Convert, &c,
+	                      &name))
+		return NULL;
+	_rv = SGSetChannelDevice(c,
+	                         name);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_SGGetChannelTimeScale(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	SGChannel c;
+	TimeScale scale;
+#ifndef SGGetChannelTimeScale
+	PyMac_PRECHECK(SGGetChannelTimeScale);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpInstObj_Convert, &c))
+		return NULL;
+	_rv = SGGetChannelTimeScale(c,
+	                            &scale);
+	_res = Py_BuildValue("ll",
+	                     _rv,
+	                     scale);
+	return _res;
+}
+
+static PyObject *Qt_SGChannelPutPicture(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	SGChannel c;
+#ifndef SGChannelPutPicture
+	PyMac_PRECHECK(SGChannelPutPicture);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpInstObj_Convert, &c))
+		return NULL;
+	_rv = SGChannelPutPicture(c);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_SGChannelSetRequestedDataRate(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	SGChannel c;
+	long bytesPerSecond;
+#ifndef SGChannelSetRequestedDataRate
+	PyMac_PRECHECK(SGChannelSetRequestedDataRate);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&l",
+	                      CmpInstObj_Convert, &c,
+	                      &bytesPerSecond))
+		return NULL;
+	_rv = SGChannelSetRequestedDataRate(c,
+	                                    bytesPerSecond);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_SGChannelGetRequestedDataRate(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	SGChannel c;
+	long bytesPerSecond;
+#ifndef SGChannelGetRequestedDataRate
+	PyMac_PRECHECK(SGChannelGetRequestedDataRate);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpInstObj_Convert, &c))
+		return NULL;
+	_rv = SGChannelGetRequestedDataRate(c,
+	                                    &bytesPerSecond);
+	_res = Py_BuildValue("ll",
+	                     _rv,
+	                     bytesPerSecond);
+	return _res;
+}
+
+static PyObject *Qt_SGChannelSetDataSourceName(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	SGChannel c;
+	Str255 name;
+	ScriptCode scriptTag;
+#ifndef SGChannelSetDataSourceName
+	PyMac_PRECHECK(SGChannelSetDataSourceName);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&O&h",
+	                      CmpInstObj_Convert, &c,
+	                      PyMac_GetStr255, name,
+	                      &scriptTag))
+		return NULL;
+	_rv = SGChannelSetDataSourceName(c,
+	                                 name,
+	                                 scriptTag);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_SGChannelGetDataSourceName(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	SGChannel c;
+	Str255 name;
+	ScriptCode scriptTag;
+#ifndef SGChannelGetDataSourceName
+	PyMac_PRECHECK(SGChannelGetDataSourceName);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&O&",
+	                      CmpInstObj_Convert, &c,
+	                      PyMac_GetStr255, name))
+		return NULL;
+	_rv = SGChannelGetDataSourceName(c,
+	                                 name,
+	                                 &scriptTag);
+	_res = Py_BuildValue("lh",
+	                     _rv,
+	                     scriptTag);
+	return _res;
+}
+
+static PyObject *Qt_SGChannelSetCodecSettings(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	SGChannel c;
+	Handle settings;
+#ifndef SGChannelSetCodecSettings
+	PyMac_PRECHECK(SGChannelSetCodecSettings);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&O&",
+	                      CmpInstObj_Convert, &c,
+	                      ResObj_Convert, &settings))
+		return NULL;
+	_rv = SGChannelSetCodecSettings(c,
+	                                settings);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_SGChannelGetCodecSettings(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	SGChannel c;
+	Handle settings;
+#ifndef SGChannelGetCodecSettings
+	PyMac_PRECHECK(SGChannelGetCodecSettings);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpInstObj_Convert, &c))
+		return NULL;
+	_rv = SGChannelGetCodecSettings(c,
+	                                &settings);
+	_res = Py_BuildValue("lO&",
+	                     _rv,
+	                     ResObj_New, settings);
+	return _res;
+}
+
+static PyObject *Qt_SGGetChannelTimeBase(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	SGChannel c;
+	TimeBase tb;
+#ifndef SGGetChannelTimeBase
+	PyMac_PRECHECK(SGGetChannelTimeBase);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpInstObj_Convert, &c))
+		return NULL;
+	_rv = SGGetChannelTimeBase(c,
+	                           &tb);
+	_res = Py_BuildValue("lO&",
+	                     _rv,
+	                     TimeBaseObj_New, tb);
+	return _res;
+}
+
+static PyObject *Qt_SGGetChannelRefCon(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	SGChannel c;
+	long refCon;
+#ifndef SGGetChannelRefCon
+	PyMac_PRECHECK(SGGetChannelRefCon);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpInstObj_Convert, &c))
+		return NULL;
+	_rv = SGGetChannelRefCon(c,
+	                         &refCon);
+	_res = Py_BuildValue("ll",
+	                     _rv,
+	                     refCon);
+	return _res;
+}
+
+static PyObject *Qt_SGGetChannelDeviceAndInputNames(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	SGChannel c;
+	Str255 outDeviceName;
+	Str255 outInputName;
+	short outInputNumber;
+#ifndef SGGetChannelDeviceAndInputNames
+	PyMac_PRECHECK(SGGetChannelDeviceAndInputNames);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&O&O&",
+	                      CmpInstObj_Convert, &c,
+	                      PyMac_GetStr255, outDeviceName,
+	                      PyMac_GetStr255, outInputName))
+		return NULL;
+	_rv = SGGetChannelDeviceAndInputNames(c,
+	                                      outDeviceName,
+	                                      outInputName,
+	                                      &outInputNumber);
+	_res = Py_BuildValue("lh",
+	                     _rv,
+	                     outInputNumber);
+	return _res;
+}
+
+static PyObject *Qt_SGSetChannelDeviceInput(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	SGChannel c;
+	short inInputNumber;
+#ifndef SGSetChannelDeviceInput
+	PyMac_PRECHECK(SGSetChannelDeviceInput);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&h",
+	                      CmpInstObj_Convert, &c,
+	                      &inInputNumber))
+		return NULL;
+	_rv = SGSetChannelDeviceInput(c,
+	                              inInputNumber);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_SGSetChannelSettingsStateChanging(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	SGChannel c;
+	UInt32 inFlags;
+#ifndef SGSetChannelSettingsStateChanging
+	PyMac_PRECHECK(SGSetChannelSettingsStateChanging);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&l",
+	                      CmpInstObj_Convert, &c,
+	                      &inFlags))
+		return NULL;
+	_rv = SGSetChannelSettingsStateChanging(c,
+	                                        inFlags);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_SGInitChannel(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	SGChannel c;
+	SeqGrabComponent owner;
+#ifndef SGInitChannel
+	PyMac_PRECHECK(SGInitChannel);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&O&",
+	                      CmpInstObj_Convert, &c,
+	                      CmpObj_Convert, &owner))
+		return NULL;
+	_rv = SGInitChannel(c,
+	                    owner);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_SGWriteSamples(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	SGChannel c;
+	Movie m;
+	AliasHandle theFile;
+#ifndef SGWriteSamples
+	PyMac_PRECHECK(SGWriteSamples);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&O&O&",
+	                      CmpInstObj_Convert, &c,
+	                      MovieObj_Convert, &m,
+	                      ResObj_Convert, &theFile))
+		return NULL;
+	_rv = SGWriteSamples(c,
+	                     m,
+	                     theFile);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_SGGetDataRate(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	SGChannel c;
+	long bytesPerSecond;
+#ifndef SGGetDataRate
+	PyMac_PRECHECK(SGGetDataRate);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpInstObj_Convert, &c))
+		return NULL;
+	_rv = SGGetDataRate(c,
+	                    &bytesPerSecond);
+	_res = Py_BuildValue("ll",
+	                     _rv,
+	                     bytesPerSecond);
+	return _res;
+}
+
+static PyObject *Qt_SGAlignChannelRect(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	SGChannel c;
+	Rect r;
+#ifndef SGAlignChannelRect
+	PyMac_PRECHECK(SGAlignChannelRect);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpInstObj_Convert, &c))
+		return NULL;
+	_rv = SGAlignChannelRect(c,
+	                         &r);
+	_res = Py_BuildValue("lO&",
+	                     _rv,
+	                     PyMac_BuildRect, &r);
+	return _res;
+}
+
+static PyObject *Qt_SGPanelGetDitl(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	SeqGrabComponent s;
+	Handle ditl;
+#ifndef SGPanelGetDitl
+	PyMac_PRECHECK(SGPanelGetDitl);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpObj_Convert, &s))
+		return NULL;
+	_rv = SGPanelGetDitl(s,
+	                     &ditl);
+	_res = Py_BuildValue("lO&",
+	                     _rv,
+	                     ResObj_New, ditl);
+	return _res;
+}
+
+static PyObject *Qt_SGPanelGetTitle(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	SeqGrabComponent s;
+	Str255 title;
+#ifndef SGPanelGetTitle
+	PyMac_PRECHECK(SGPanelGetTitle);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&O&",
+	                      CmpObj_Convert, &s,
+	                      PyMac_GetStr255, title))
+		return NULL;
+	_rv = SGPanelGetTitle(s,
+	                      title);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_SGPanelCanRun(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	SeqGrabComponent s;
+	SGChannel c;
+#ifndef SGPanelCanRun
+	PyMac_PRECHECK(SGPanelCanRun);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&O&",
+	                      CmpObj_Convert, &s,
+	                      CmpInstObj_Convert, &c))
+		return NULL;
+	_rv = SGPanelCanRun(s,
+	                    c);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_SGPanelInstall(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	SeqGrabComponent s;
+	SGChannel c;
+	DialogPtr d;
+	short itemOffset;
+#ifndef SGPanelInstall
+	PyMac_PRECHECK(SGPanelInstall);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&O&O&h",
+	                      CmpObj_Convert, &s,
+	                      CmpInstObj_Convert, &c,
+	                      DlgObj_Convert, &d,
+	                      &itemOffset))
+		return NULL;
+	_rv = SGPanelInstall(s,
+	                     c,
+	                     d,
+	                     itemOffset);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_SGPanelEvent(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	SeqGrabComponent s;
+	SGChannel c;
+	DialogPtr d;
+	short itemOffset;
+	EventRecord theEvent;
+	short itemHit;
+	Boolean handled;
+#ifndef SGPanelEvent
+	PyMac_PRECHECK(SGPanelEvent);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&O&O&hO&",
+	                      CmpObj_Convert, &s,
+	                      CmpInstObj_Convert, &c,
+	                      DlgObj_Convert, &d,
+	                      &itemOffset,
+	                      PyMac_GetEventRecord, &theEvent))
+		return NULL;
+	_rv = SGPanelEvent(s,
+	                   c,
+	                   d,
+	                   itemOffset,
+	                   &theEvent,
+	                   &itemHit,
+	                   &handled);
+	_res = Py_BuildValue("lhb",
+	                     _rv,
+	                     itemHit,
+	                     handled);
+	return _res;
+}
+
+static PyObject *Qt_SGPanelItem(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	SeqGrabComponent s;
+	SGChannel c;
+	DialogPtr d;
+	short itemOffset;
+	short itemNum;
+#ifndef SGPanelItem
+	PyMac_PRECHECK(SGPanelItem);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&O&O&hh",
+	                      CmpObj_Convert, &s,
+	                      CmpInstObj_Convert, &c,
+	                      DlgObj_Convert, &d,
+	                      &itemOffset,
+	                      &itemNum))
+		return NULL;
+	_rv = SGPanelItem(s,
+	                  c,
+	                  d,
+	                  itemOffset,
+	                  itemNum);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_SGPanelRemove(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	SeqGrabComponent s;
+	SGChannel c;
+	DialogPtr d;
+	short itemOffset;
+#ifndef SGPanelRemove
+	PyMac_PRECHECK(SGPanelRemove);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&O&O&h",
+	                      CmpObj_Convert, &s,
+	                      CmpInstObj_Convert, &c,
+	                      DlgObj_Convert, &d,
+	                      &itemOffset))
+		return NULL;
+	_rv = SGPanelRemove(s,
+	                    c,
+	                    d,
+	                    itemOffset);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_SGPanelSetGrabber(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	SeqGrabComponent s;
+	SeqGrabComponent sg;
+#ifndef SGPanelSetGrabber
+	PyMac_PRECHECK(SGPanelSetGrabber);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&O&",
+	                      CmpObj_Convert, &s,
+	                      CmpObj_Convert, &sg))
+		return NULL;
+	_rv = SGPanelSetGrabber(s,
+	                        sg);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_SGPanelSetResFile(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	SeqGrabComponent s;
+	short resRef;
+#ifndef SGPanelSetResFile
+	PyMac_PRECHECK(SGPanelSetResFile);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&h",
+	                      CmpObj_Convert, &s,
+	                      &resRef))
+		return NULL;
+	_rv = SGPanelSetResFile(s,
+	                        resRef);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_SGPanelGetSettings(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	SeqGrabComponent s;
+	SGChannel c;
+	UserData ud;
+	long flags;
+#ifndef SGPanelGetSettings
+	PyMac_PRECHECK(SGPanelGetSettings);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&O&l",
+	                      CmpObj_Convert, &s,
+	                      CmpInstObj_Convert, &c,
+	                      &flags))
+		return NULL;
+	_rv = SGPanelGetSettings(s,
+	                         c,
+	                         &ud,
+	                         flags);
+	_res = Py_BuildValue("lO&",
+	                     _rv,
+	                     UserDataObj_New, ud);
+	return _res;
+}
+
+static PyObject *Qt_SGPanelSetSettings(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	SeqGrabComponent s;
+	SGChannel c;
+	UserData ud;
+	long flags;
+#ifndef SGPanelSetSettings
+	PyMac_PRECHECK(SGPanelSetSettings);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&O&O&l",
+	                      CmpObj_Convert, &s,
+	                      CmpInstObj_Convert, &c,
+	                      UserDataObj_Convert, &ud,
+	                      &flags))
+		return NULL;
+	_rv = SGPanelSetSettings(s,
+	                         c,
+	                         ud,
+	                         flags);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_SGPanelValidateInput(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	SeqGrabComponent s;
+	Boolean ok;
+#ifndef SGPanelValidateInput
+	PyMac_PRECHECK(SGPanelValidateInput);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpObj_Convert, &s))
+		return NULL;
+	_rv = SGPanelValidateInput(s,
+	                           &ok);
+	_res = Py_BuildValue("lb",
+	                     _rv,
+	                     ok);
+	return _res;
+}
+
+static PyObject *Qt_SGPanelGetDITLForSize(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	SeqGrabComponent s;
+	Handle ditl;
+	Point requestedSize;
+#ifndef SGPanelGetDITLForSize
+	PyMac_PRECHECK(SGPanelGetDITLForSize);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpObj_Convert, &s))
+		return NULL;
+	_rv = SGPanelGetDITLForSize(s,
+	                            &ditl,
+	                            &requestedSize);
+	_res = Py_BuildValue("lO&O&",
+	                     _rv,
+	                     ResObj_New, ditl,
+	                     PyMac_BuildPoint, requestedSize);
+	return _res;
+}
+
+static PyObject *Qt_SGGetSrcVideoBounds(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	SGChannel c;
+	Rect r;
+#ifndef SGGetSrcVideoBounds
+	PyMac_PRECHECK(SGGetSrcVideoBounds);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpInstObj_Convert, &c))
+		return NULL;
+	_rv = SGGetSrcVideoBounds(c,
+	                          &r);
+	_res = Py_BuildValue("lO&",
+	                     _rv,
+	                     PyMac_BuildRect, &r);
+	return _res;
+}
+
+static PyObject *Qt_SGSetVideoRect(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	SGChannel c;
+	Rect r;
+#ifndef SGSetVideoRect
+	PyMac_PRECHECK(SGSetVideoRect);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&O&",
+	                      CmpInstObj_Convert, &c,
+	                      PyMac_GetRect, &r))
+		return NULL;
+	_rv = SGSetVideoRect(c,
+	                     &r);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_SGGetVideoRect(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	SGChannel c;
+	Rect r;
+#ifndef SGGetVideoRect
+	PyMac_PRECHECK(SGGetVideoRect);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpInstObj_Convert, &c))
+		return NULL;
+	_rv = SGGetVideoRect(c,
+	                     &r);
+	_res = Py_BuildValue("lO&",
+	                     _rv,
+	                     PyMac_BuildRect, &r);
+	return _res;
+}
+
+static PyObject *Qt_SGGetVideoCompressorType(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	SGChannel c;
+	OSType compressorType;
+#ifndef SGGetVideoCompressorType
+	PyMac_PRECHECK(SGGetVideoCompressorType);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpInstObj_Convert, &c))
+		return NULL;
+	_rv = SGGetVideoCompressorType(c,
+	                               &compressorType);
+	_res = Py_BuildValue("lO&",
+	                     _rv,
+	                     PyMac_BuildOSType, compressorType);
+	return _res;
+}
+
+static PyObject *Qt_SGSetVideoCompressorType(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	SGChannel c;
+	OSType compressorType;
+#ifndef SGSetVideoCompressorType
+	PyMac_PRECHECK(SGSetVideoCompressorType);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&O&",
+	                      CmpInstObj_Convert, &c,
+	                      PyMac_GetOSType, &compressorType))
+		return NULL;
+	_rv = SGSetVideoCompressorType(c,
+	                               compressorType);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_SGSetVideoCompressor(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	SGChannel c;
+	short depth;
+	CompressorComponent compressor;
+	CodecQ spatialQuality;
+	CodecQ temporalQuality;
+	long keyFrameRate;
+#ifndef SGSetVideoCompressor
+	PyMac_PRECHECK(SGSetVideoCompressor);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&hO&lll",
+	                      CmpInstObj_Convert, &c,
+	                      &depth,
+	                      CmpObj_Convert, &compressor,
+	                      &spatialQuality,
+	                      &temporalQuality,
+	                      &keyFrameRate))
+		return NULL;
+	_rv = SGSetVideoCompressor(c,
+	                           depth,
+	                           compressor,
+	                           spatialQuality,
+	                           temporalQuality,
+	                           keyFrameRate);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_SGGetVideoCompressor(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	SGChannel c;
+	short depth;
+	CompressorComponent compressor;
+	CodecQ spatialQuality;
+	CodecQ temporalQuality;
+	long keyFrameRate;
+#ifndef SGGetVideoCompressor
+	PyMac_PRECHECK(SGGetVideoCompressor);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpInstObj_Convert, &c))
+		return NULL;
+	_rv = SGGetVideoCompressor(c,
+	                           &depth,
+	                           &compressor,
+	                           &spatialQuality,
+	                           &temporalQuality,
+	                           &keyFrameRate);
+	_res = Py_BuildValue("lhO&lll",
+	                     _rv,
+	                     depth,
+	                     CmpObj_New, compressor,
+	                     spatialQuality,
+	                     temporalQuality,
+	                     keyFrameRate);
+	return _res;
+}
+
+static PyObject *Qt_SGGetVideoDigitizerComponent(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentInstance _rv;
+	SGChannel c;
+#ifndef SGGetVideoDigitizerComponent
+	PyMac_PRECHECK(SGGetVideoDigitizerComponent);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpInstObj_Convert, &c))
+		return NULL;
+	_rv = SGGetVideoDigitizerComponent(c);
+	_res = Py_BuildValue("O&",
+	                     CmpInstObj_New, _rv);
+	return _res;
+}
+
+static PyObject *Qt_SGSetVideoDigitizerComponent(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	SGChannel c;
+	ComponentInstance vdig;
+#ifndef SGSetVideoDigitizerComponent
+	PyMac_PRECHECK(SGSetVideoDigitizerComponent);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&O&",
+	                      CmpInstObj_Convert, &c,
+	                      CmpInstObj_Convert, &vdig))
+		return NULL;
+	_rv = SGSetVideoDigitizerComponent(c,
+	                                   vdig);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_SGVideoDigitizerChanged(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	SGChannel c;
+#ifndef SGVideoDigitizerChanged
+	PyMac_PRECHECK(SGVideoDigitizerChanged);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpInstObj_Convert, &c))
+		return NULL;
+	_rv = SGVideoDigitizerChanged(c);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_SGGrabFrame(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	SGChannel c;
+	short bufferNum;
+#ifndef SGGrabFrame
+	PyMac_PRECHECK(SGGrabFrame);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&h",
+	                      CmpInstObj_Convert, &c,
+	                      &bufferNum))
+		return NULL;
+	_rv = SGGrabFrame(c,
+	                  bufferNum);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_SGGrabFrameComplete(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	SGChannel c;
+	short bufferNum;
+	Boolean done;
+#ifndef SGGrabFrameComplete
+	PyMac_PRECHECK(SGGrabFrameComplete);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&h",
+	                      CmpInstObj_Convert, &c,
+	                      &bufferNum))
+		return NULL;
+	_rv = SGGrabFrameComplete(c,
+	                          bufferNum,
+	                          &done);
+	_res = Py_BuildValue("lb",
+	                     _rv,
+	                     done);
+	return _res;
+}
+
+static PyObject *Qt_SGCompressFrame(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	SGChannel c;
+	short bufferNum;
+#ifndef SGCompressFrame
+	PyMac_PRECHECK(SGCompressFrame);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&h",
+	                      CmpInstObj_Convert, &c,
+	                      &bufferNum))
+		return NULL;
+	_rv = SGCompressFrame(c,
+	                      bufferNum);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_SGSetCompressBuffer(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	SGChannel c;
+	short depth;
+	Rect compressSize;
+#ifndef SGSetCompressBuffer
+	PyMac_PRECHECK(SGSetCompressBuffer);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&hO&",
+	                      CmpInstObj_Convert, &c,
+	                      &depth,
+	                      PyMac_GetRect, &compressSize))
+		return NULL;
+	_rv = SGSetCompressBuffer(c,
+	                          depth,
+	                          &compressSize);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_SGGetCompressBuffer(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	SGChannel c;
+	short depth;
+	Rect compressSize;
+#ifndef SGGetCompressBuffer
+	PyMac_PRECHECK(SGGetCompressBuffer);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpInstObj_Convert, &c))
+		return NULL;
+	_rv = SGGetCompressBuffer(c,
+	                          &depth,
+	                          &compressSize);
+	_res = Py_BuildValue("lhO&",
+	                     _rv,
+	                     depth,
+	                     PyMac_BuildRect, &compressSize);
+	return _res;
+}
+
+static PyObject *Qt_SGGetBufferInfo(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	SGChannel c;
+	short bufferNum;
+	PixMapHandle bufferPM;
+	Rect bufferRect;
+	GWorldPtr compressBuffer;
+	Rect compressBufferRect;
+#ifndef SGGetBufferInfo
+	PyMac_PRECHECK(SGGetBufferInfo);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&h",
+	                      CmpInstObj_Convert, &c,
+	                      &bufferNum))
+		return NULL;
+	_rv = SGGetBufferInfo(c,
+	                      bufferNum,
+	                      &bufferPM,
+	                      &bufferRect,
+	                      &compressBuffer,
+	                      &compressBufferRect);
+	_res = Py_BuildValue("lO&O&O&O&",
+	                     _rv,
+	                     ResObj_New, bufferPM,
+	                     PyMac_BuildRect, &bufferRect,
+	                     GWorldObj_New, compressBuffer,
+	                     PyMac_BuildRect, &compressBufferRect);
+	return _res;
+}
+
+static PyObject *Qt_SGSetUseScreenBuffer(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	SGChannel c;
+	Boolean useScreenBuffer;
+#ifndef SGSetUseScreenBuffer
+	PyMac_PRECHECK(SGSetUseScreenBuffer);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&b",
+	                      CmpInstObj_Convert, &c,
+	                      &useScreenBuffer))
+		return NULL;
+	_rv = SGSetUseScreenBuffer(c,
+	                           useScreenBuffer);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_SGGetUseScreenBuffer(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	SGChannel c;
+	Boolean useScreenBuffer;
+#ifndef SGGetUseScreenBuffer
+	PyMac_PRECHECK(SGGetUseScreenBuffer);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpInstObj_Convert, &c))
+		return NULL;
+	_rv = SGGetUseScreenBuffer(c,
+	                           &useScreenBuffer);
+	_res = Py_BuildValue("lb",
+	                     _rv,
+	                     useScreenBuffer);
+	return _res;
+}
+
+static PyObject *Qt_SGSetFrameRate(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	SGChannel c;
+	Fixed frameRate;
+#ifndef SGSetFrameRate
+	PyMac_PRECHECK(SGSetFrameRate);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&O&",
+	                      CmpInstObj_Convert, &c,
+	                      PyMac_GetFixed, &frameRate))
+		return NULL;
+	_rv = SGSetFrameRate(c,
+	                     frameRate);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_SGGetFrameRate(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	SGChannel c;
+	Fixed frameRate;
+#ifndef SGGetFrameRate
+	PyMac_PRECHECK(SGGetFrameRate);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpInstObj_Convert, &c))
+		return NULL;
+	_rv = SGGetFrameRate(c,
+	                     &frameRate);
+	_res = Py_BuildValue("lO&",
+	                     _rv,
+	                     PyMac_BuildFixed, frameRate);
+	return _res;
+}
+
+static PyObject *Qt_SGSetPreferredPacketSize(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	SGChannel c;
+	long preferredPacketSizeInBytes;
+#ifndef SGSetPreferredPacketSize
+	PyMac_PRECHECK(SGSetPreferredPacketSize);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&l",
+	                      CmpInstObj_Convert, &c,
+	                      &preferredPacketSizeInBytes))
+		return NULL;
+	_rv = SGSetPreferredPacketSize(c,
+	                               preferredPacketSizeInBytes);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_SGGetPreferredPacketSize(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	SGChannel c;
+	long preferredPacketSizeInBytes;
+#ifndef SGGetPreferredPacketSize
+	PyMac_PRECHECK(SGGetPreferredPacketSize);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpInstObj_Convert, &c))
+		return NULL;
+	_rv = SGGetPreferredPacketSize(c,
+	                               &preferredPacketSizeInBytes);
+	_res = Py_BuildValue("ll",
+	                     _rv,
+	                     preferredPacketSizeInBytes);
+	return _res;
+}
+
+static PyObject *Qt_SGSetUserVideoCompressorList(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	SGChannel c;
+	Handle compressorTypes;
+#ifndef SGSetUserVideoCompressorList
+	PyMac_PRECHECK(SGSetUserVideoCompressorList);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&O&",
+	                      CmpInstObj_Convert, &c,
+	                      ResObj_Convert, &compressorTypes))
+		return NULL;
+	_rv = SGSetUserVideoCompressorList(c,
+	                                   compressorTypes);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_SGGetUserVideoCompressorList(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	SGChannel c;
+	Handle compressorTypes;
+#ifndef SGGetUserVideoCompressorList
+	PyMac_PRECHECK(SGGetUserVideoCompressorList);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpInstObj_Convert, &c))
+		return NULL;
+	_rv = SGGetUserVideoCompressorList(c,
+	                                   &compressorTypes);
+	_res = Py_BuildValue("lO&",
+	                     _rv,
+	                     ResObj_New, compressorTypes);
+	return _res;
+}
+
+static PyObject *Qt_SGSetSoundInputDriver(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	SGChannel c;
+	Str255 driverName;
+#ifndef SGSetSoundInputDriver
+	PyMac_PRECHECK(SGSetSoundInputDriver);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&O&",
+	                      CmpInstObj_Convert, &c,
+	                      PyMac_GetStr255, driverName))
+		return NULL;
+	_rv = SGSetSoundInputDriver(c,
+	                            driverName);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_SGGetSoundInputDriver(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	long _rv;
+	SGChannel c;
+#ifndef SGGetSoundInputDriver
+	PyMac_PRECHECK(SGGetSoundInputDriver);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpInstObj_Convert, &c))
+		return NULL;
+	_rv = SGGetSoundInputDriver(c);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_SGSoundInputDriverChanged(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	SGChannel c;
+#ifndef SGSoundInputDriverChanged
+	PyMac_PRECHECK(SGSoundInputDriverChanged);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpInstObj_Convert, &c))
+		return NULL;
+	_rv = SGSoundInputDriverChanged(c);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_SGSetSoundRecordChunkSize(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	SGChannel c;
+	long seconds;
+#ifndef SGSetSoundRecordChunkSize
+	PyMac_PRECHECK(SGSetSoundRecordChunkSize);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&l",
+	                      CmpInstObj_Convert, &c,
+	                      &seconds))
+		return NULL;
+	_rv = SGSetSoundRecordChunkSize(c,
+	                                seconds);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_SGGetSoundRecordChunkSize(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	long _rv;
+	SGChannel c;
+#ifndef SGGetSoundRecordChunkSize
+	PyMac_PRECHECK(SGGetSoundRecordChunkSize);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpInstObj_Convert, &c))
+		return NULL;
+	_rv = SGGetSoundRecordChunkSize(c);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_SGSetSoundInputRate(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	SGChannel c;
+	Fixed rate;
+#ifndef SGSetSoundInputRate
+	PyMac_PRECHECK(SGSetSoundInputRate);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&O&",
+	                      CmpInstObj_Convert, &c,
+	                      PyMac_GetFixed, &rate))
+		return NULL;
+	_rv = SGSetSoundInputRate(c,
+	                          rate);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_SGGetSoundInputRate(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	Fixed _rv;
+	SGChannel c;
+#ifndef SGGetSoundInputRate
+	PyMac_PRECHECK(SGGetSoundInputRate);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpInstObj_Convert, &c))
+		return NULL;
+	_rv = SGGetSoundInputRate(c);
+	_res = Py_BuildValue("O&",
+	                     PyMac_BuildFixed, _rv);
+	return _res;
+}
+
+static PyObject *Qt_SGSetSoundInputParameters(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	SGChannel c;
+	short sampleSize;
+	short numChannels;
+	OSType compressionType;
+#ifndef SGSetSoundInputParameters
+	PyMac_PRECHECK(SGSetSoundInputParameters);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&hhO&",
+	                      CmpInstObj_Convert, &c,
+	                      &sampleSize,
+	                      &numChannels,
+	                      PyMac_GetOSType, &compressionType))
+		return NULL;
+	_rv = SGSetSoundInputParameters(c,
+	                                sampleSize,
+	                                numChannels,
+	                                compressionType);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_SGGetSoundInputParameters(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	SGChannel c;
+	short sampleSize;
+	short numChannels;
+	OSType compressionType;
+#ifndef SGGetSoundInputParameters
+	PyMac_PRECHECK(SGGetSoundInputParameters);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpInstObj_Convert, &c))
+		return NULL;
+	_rv = SGGetSoundInputParameters(c,
+	                                &sampleSize,
+	                                &numChannels,
+	                                &compressionType);
+	_res = Py_BuildValue("lhhO&",
+	                     _rv,
+	                     sampleSize,
+	                     numChannels,
+	                     PyMac_BuildOSType, compressionType);
+	return _res;
+}
+
+static PyObject *Qt_SGSetAdditionalSoundRates(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	SGChannel c;
+	Handle rates;
+#ifndef SGSetAdditionalSoundRates
+	PyMac_PRECHECK(SGSetAdditionalSoundRates);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&O&",
+	                      CmpInstObj_Convert, &c,
+	                      ResObj_Convert, &rates))
+		return NULL;
+	_rv = SGSetAdditionalSoundRates(c,
+	                                rates);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_SGGetAdditionalSoundRates(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	SGChannel c;
+	Handle rates;
+#ifndef SGGetAdditionalSoundRates
+	PyMac_PRECHECK(SGGetAdditionalSoundRates);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpInstObj_Convert, &c))
+		return NULL;
+	_rv = SGGetAdditionalSoundRates(c,
+	                                &rates);
+	_res = Py_BuildValue("lO&",
+	                     _rv,
+	                     ResObj_New, rates);
+	return _res;
+}
+
+static PyObject *Qt_SGSetFontName(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	SGChannel c;
+	StringPtr pstr;
+#ifndef SGSetFontName
+	PyMac_PRECHECK(SGSetFontName);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&s",
+	                      CmpInstObj_Convert, &c,
+	                      &pstr))
+		return NULL;
+	_rv = SGSetFontName(c,
+	                    pstr);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_SGSetFontSize(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	SGChannel c;
+	short fontSize;
+#ifndef SGSetFontSize
+	PyMac_PRECHECK(SGSetFontSize);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&h",
+	                      CmpInstObj_Convert, &c,
+	                      &fontSize))
+		return NULL;
+	_rv = SGSetFontSize(c,
+	                    fontSize);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_SGSetTextForeColor(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	SGChannel c;
+	RGBColor theColor;
+#ifndef SGSetTextForeColor
+	PyMac_PRECHECK(SGSetTextForeColor);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpInstObj_Convert, &c))
+		return NULL;
+	_rv = SGSetTextForeColor(c,
+	                         &theColor);
+	_res = Py_BuildValue("lO&",
+	                     _rv,
+	                     QdRGB_New, &theColor);
+	return _res;
+}
+
+static PyObject *Qt_SGSetTextBackColor(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	SGChannel c;
+	RGBColor theColor;
+#ifndef SGSetTextBackColor
+	PyMac_PRECHECK(SGSetTextBackColor);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpInstObj_Convert, &c))
+		return NULL;
+	_rv = SGSetTextBackColor(c,
+	                         &theColor);
+	_res = Py_BuildValue("lO&",
+	                     _rv,
+	                     QdRGB_New, &theColor);
+	return _res;
+}
+
+static PyObject *Qt_SGSetJustification(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	SGChannel c;
+	short just;
+#ifndef SGSetJustification
+	PyMac_PRECHECK(SGSetJustification);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&h",
+	                      CmpInstObj_Convert, &c,
+	                      &just))
+		return NULL;
+	_rv = SGSetJustification(c,
+	                         just);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_SGGetTextReturnToSpaceValue(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	SGChannel c;
+	short rettospace;
+#ifndef SGGetTextReturnToSpaceValue
+	PyMac_PRECHECK(SGGetTextReturnToSpaceValue);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpInstObj_Convert, &c))
+		return NULL;
+	_rv = SGGetTextReturnToSpaceValue(c,
+	                                  &rettospace);
+	_res = Py_BuildValue("lh",
+	                     _rv,
+	                     rettospace);
+	return _res;
+}
+
+static PyObject *Qt_SGSetTextReturnToSpaceValue(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	SGChannel c;
+	short rettospace;
+#ifndef SGSetTextReturnToSpaceValue
+	PyMac_PRECHECK(SGSetTextReturnToSpaceValue);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&h",
+	                      CmpInstObj_Convert, &c,
+	                      &rettospace))
+		return NULL;
+	_rv = SGSetTextReturnToSpaceValue(c,
+	                                  rettospace);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_QTVideoOutputGetCurrentClientName(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	QTVideoOutputComponent vo;
+	Str255 str;
+#ifndef QTVideoOutputGetCurrentClientName
+	PyMac_PRECHECK(QTVideoOutputGetCurrentClientName);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&O&",
+	                      CmpObj_Convert, &vo,
+	                      PyMac_GetStr255, str))
+		return NULL;
+	_rv = QTVideoOutputGetCurrentClientName(vo,
+	                                        str);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_QTVideoOutputSetClientName(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	QTVideoOutputComponent vo;
+	Str255 str;
+#ifndef QTVideoOutputSetClientName
+	PyMac_PRECHECK(QTVideoOutputSetClientName);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&O&",
+	                      CmpObj_Convert, &vo,
+	                      PyMac_GetStr255, str))
+		return NULL;
+	_rv = QTVideoOutputSetClientName(vo,
+	                                 str);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_QTVideoOutputGetClientName(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	QTVideoOutputComponent vo;
+	Str255 str;
+#ifndef QTVideoOutputGetClientName
+	PyMac_PRECHECK(QTVideoOutputGetClientName);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&O&",
+	                      CmpObj_Convert, &vo,
+	                      PyMac_GetStr255, str))
+		return NULL;
+	_rv = QTVideoOutputGetClientName(vo,
+	                                 str);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_QTVideoOutputBegin(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	QTVideoOutputComponent vo;
+#ifndef QTVideoOutputBegin
+	PyMac_PRECHECK(QTVideoOutputBegin);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpObj_Convert, &vo))
+		return NULL;
+	_rv = QTVideoOutputBegin(vo);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_QTVideoOutputEnd(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	QTVideoOutputComponent vo;
+#ifndef QTVideoOutputEnd
+	PyMac_PRECHECK(QTVideoOutputEnd);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpObj_Convert, &vo))
+		return NULL;
+	_rv = QTVideoOutputEnd(vo);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_QTVideoOutputSetDisplayMode(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	QTVideoOutputComponent vo;
+	long displayModeID;
+#ifndef QTVideoOutputSetDisplayMode
+	PyMac_PRECHECK(QTVideoOutputSetDisplayMode);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&l",
+	                      CmpObj_Convert, &vo,
+	                      &displayModeID))
+		return NULL;
+	_rv = QTVideoOutputSetDisplayMode(vo,
+	                                  displayModeID);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_QTVideoOutputGetDisplayMode(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	QTVideoOutputComponent vo;
+	long displayModeID;
+#ifndef QTVideoOutputGetDisplayMode
+	PyMac_PRECHECK(QTVideoOutputGetDisplayMode);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpObj_Convert, &vo))
+		return NULL;
+	_rv = QTVideoOutputGetDisplayMode(vo,
+	                                  &displayModeID);
+	_res = Py_BuildValue("ll",
+	                     _rv,
+	                     displayModeID);
+	return _res;
+}
+
+static PyObject *Qt_QTVideoOutputGetGWorld(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	QTVideoOutputComponent vo;
+	GWorldPtr gw;
+#ifndef QTVideoOutputGetGWorld
+	PyMac_PRECHECK(QTVideoOutputGetGWorld);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpObj_Convert, &vo))
+		return NULL;
+	_rv = QTVideoOutputGetGWorld(vo,
+	                             &gw);
+	_res = Py_BuildValue("lO&",
+	                     _rv,
+	                     GWorldObj_New, gw);
+	return _res;
+}
+
+static PyObject *Qt_QTVideoOutputGetIndSoundOutput(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	QTVideoOutputComponent vo;
+	long index;
+	Component outputComponent;
+#ifndef QTVideoOutputGetIndSoundOutput
+	PyMac_PRECHECK(QTVideoOutputGetIndSoundOutput);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&l",
+	                      CmpObj_Convert, &vo,
+	                      &index))
+		return NULL;
+	_rv = QTVideoOutputGetIndSoundOutput(vo,
+	                                     index,
+	                                     &outputComponent);
+	_res = Py_BuildValue("lO&",
+	                     _rv,
+	                     CmpObj_New, outputComponent);
+	return _res;
+}
+
+static PyObject *Qt_QTVideoOutputGetClock(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	QTVideoOutputComponent vo;
+	ComponentInstance clock;
+#ifndef QTVideoOutputGetClock
+	PyMac_PRECHECK(QTVideoOutputGetClock);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpObj_Convert, &vo))
+		return NULL;
+	_rv = QTVideoOutputGetClock(vo,
+	                            &clock);
+	_res = Py_BuildValue("lO&",
+	                     _rv,
+	                     CmpInstObj_New, clock);
+	return _res;
+}
+
+static PyObject *Qt_QTVideoOutputSetEchoPort(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	QTVideoOutputComponent vo;
+	CGrafPtr echoPort;
+#ifndef QTVideoOutputSetEchoPort
+	PyMac_PRECHECK(QTVideoOutputSetEchoPort);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&O&",
+	                      CmpObj_Convert, &vo,
+	                      GrafObj_Convert, &echoPort))
+		return NULL;
+	_rv = QTVideoOutputSetEchoPort(vo,
+	                               echoPort);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_QTVideoOutputGetIndImageDecompressor(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	QTVideoOutputComponent vo;
+	long index;
+	Component codec;
+#ifndef QTVideoOutputGetIndImageDecompressor
+	PyMac_PRECHECK(QTVideoOutputGetIndImageDecompressor);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&l",
+	                      CmpObj_Convert, &vo,
+	                      &index))
+		return NULL;
+	_rv = QTVideoOutputGetIndImageDecompressor(vo,
+	                                           index,
+	                                           &codec);
+	_res = Py_BuildValue("lO&",
+	                     _rv,
+	                     CmpObj_New, codec);
+	return _res;
+}
+
+static PyObject *Qt_QTVideoOutputBaseSetEchoPort(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	QTVideoOutputComponent vo;
+	CGrafPtr echoPort;
+#ifndef QTVideoOutputBaseSetEchoPort
+	PyMac_PRECHECK(QTVideoOutputBaseSetEchoPort);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&O&",
+	                      CmpObj_Convert, &vo,
+	                      GrafObj_Convert, &echoPort))
+		return NULL;
+	_rv = QTVideoOutputBaseSetEchoPort(vo,
+	                                   echoPort);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qt_AlignWindow(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	WindowPtr wp;
+	Boolean front;
+#ifndef AlignWindow
+	PyMac_PRECHECK(AlignWindow);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&b",
+	                      WinObj_Convert, &wp,
+	                      &front))
+		return NULL;
+	AlignWindow(wp,
+	            front,
+	            (Rect *)0,
+	            (ICMAlignmentProcRecordPtr)0);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *Qt_DragAlignedWindow(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	WindowPtr wp;
+	Point startPt;
+	Rect boundsRect;
+#ifndef DragAlignedWindow
+	PyMac_PRECHECK(DragAlignedWindow);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&O&O&",
+	                      WinObj_Convert, &wp,
+	                      PyMac_GetPoint, &startPt,
+	                      PyMac_GetRect, &boundsRect))
+		return NULL;
+	DragAlignedWindow(wp,
+	                  startPt,
+	                  &boundsRect,
+	                  (Rect *)0,
+	                  (ICMAlignmentProcRecordPtr)0);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *Qt_MoviesTask(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	long maxMilliSecToUse;
+#ifndef MoviesTask
+	PyMac_PRECHECK(MoviesTask);
+#endif
+	if (!PyArg_ParseTuple(_args, "l",
+	                      &maxMilliSecToUse))
+		return NULL;
+	MoviesTask((Movie)0,
+	           maxMilliSecToUse);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyMethodDef Qt_methods[] = {
+	{"EnterMovies", (PyCFunction)Qt_EnterMovies, 1,
+	 PyDoc_STR("() -> None")},
+	{"ExitMovies", (PyCFunction)Qt_ExitMovies, 1,
+	 PyDoc_STR("() -> None")},
+	{"GetMoviesError", (PyCFunction)Qt_GetMoviesError, 1,
+	 PyDoc_STR("() -> None")},
+	{"ClearMoviesStickyError", (PyCFunction)Qt_ClearMoviesStickyError, 1,
+	 PyDoc_STR("() -> None")},
+	{"GetMoviesStickyError", (PyCFunction)Qt_GetMoviesStickyError, 1,
+	 PyDoc_STR("() -> None")},
+	{"QTGetWallClockTimeBase", (PyCFunction)Qt_QTGetWallClockTimeBase, 1,
+	 PyDoc_STR("() -> (TimeBase wallClockTimeBase)")},
+	{"QTIdleManagerOpen", (PyCFunction)Qt_QTIdleManagerOpen, 1,
+	 PyDoc_STR("() -> (IdleManager _rv)")},
+	{"CreateMovieControl", (PyCFunction)Qt_CreateMovieControl, 1,
+	 PyDoc_STR("(WindowPtr theWindow, Movie theMovie, UInt32 options) -> (Rect localRect, ControlHandle returnedControl)")},
+	{"DisposeMatte", (PyCFunction)Qt_DisposeMatte, 1,
 	 PyDoc_STR("(PixMapHandle theMatte) -> None")},
 	{"NewMovie", (PyCFunction)Qt_NewMovie, 1,
 	 PyDoc_STR("(long flags) -> (Movie _rv)")},
@@ -14749,6 +23658,802 @@ static PyMethodDef Qt_methods[] = {
 	 PyDoc_STR("(ImageTranscoderComponent itc, void * dstData) -> (ComponentResult _rv)")},
 	{"ImageTranscoderEndSequence", (PyCFunction)Qt_ImageTranscoderEndSequence, 1,
 	 PyDoc_STR("(ImageTranscoderComponent itc) -> (ComponentResult _rv)")},
+	{"ClockGetTime", (PyCFunction)Qt_ClockGetTime, 1,
+	 PyDoc_STR("(ComponentInstance aClock) -> (ComponentResult _rv, TimeRecord out)")},
+	{"ClockSetTimeBase", (PyCFunction)Qt_ClockSetTimeBase, 1,
+	 PyDoc_STR("(ComponentInstance aClock, TimeBase tb) -> (ComponentResult _rv)")},
+	{"ClockGetRate", (PyCFunction)Qt_ClockGetRate, 1,
+	 PyDoc_STR("(ComponentInstance aClock) -> (ComponentResult _rv, Fixed rate)")},
+	{"SCPositionRect", (PyCFunction)Qt_SCPositionRect, 1,
+	 PyDoc_STR("(ComponentInstance ci) -> (ComponentResult _rv, Rect rp, Point where)")},
+	{"SCPositionDialog", (PyCFunction)Qt_SCPositionDialog, 1,
+	 PyDoc_STR("(ComponentInstance ci, short id) -> (ComponentResult _rv, Point where)")},
+	{"SCSetTestImagePictHandle", (PyCFunction)Qt_SCSetTestImagePictHandle, 1,
+	 PyDoc_STR("(ComponentInstance ci, PicHandle testPict, short testFlags) -> (ComponentResult _rv, Rect testRect)")},
+	{"SCSetTestImagePictFile", (PyCFunction)Qt_SCSetTestImagePictFile, 1,
+	 PyDoc_STR("(ComponentInstance ci, short testFileRef, short testFlags) -> (ComponentResult _rv, Rect testRect)")},
+	{"SCSetTestImagePixMap", (PyCFunction)Qt_SCSetTestImagePixMap, 1,
+	 PyDoc_STR("(ComponentInstance ci, PixMapHandle testPixMap, short testFlags) -> (ComponentResult _rv, Rect testRect)")},
+	{"SCGetBestDeviceRect", (PyCFunction)Qt_SCGetBestDeviceRect, 1,
+	 PyDoc_STR("(ComponentInstance ci) -> (ComponentResult _rv, Rect r)")},
+	{"SCRequestImageSettings", (PyCFunction)Qt_SCRequestImageSettings, 1,
+	 PyDoc_STR("(ComponentInstance ci) -> (ComponentResult _rv)")},
+	{"SCCompressImage", (PyCFunction)Qt_SCCompressImage, 1,
+	 PyDoc_STR("(ComponentInstance ci, PixMapHandle src, Rect srcRect) -> (ComponentResult _rv, ImageDescriptionHandle desc, Handle data)")},
+	{"SCCompressPicture", (PyCFunction)Qt_SCCompressPicture, 1,
+	 PyDoc_STR("(ComponentInstance ci, PicHandle srcPicture, PicHandle dstPicture) -> (ComponentResult _rv)")},
+	{"SCCompressPictureFile", (PyCFunction)Qt_SCCompressPictureFile, 1,
+	 PyDoc_STR("(ComponentInstance ci, short srcRefNum, short dstRefNum) -> (ComponentResult _rv)")},
+	{"SCRequestSequenceSettings", (PyCFunction)Qt_SCRequestSequenceSettings, 1,
+	 PyDoc_STR("(ComponentInstance ci) -> (ComponentResult _rv)")},
+	{"SCCompressSequenceBegin", (PyCFunction)Qt_SCCompressSequenceBegin, 1,
+	 PyDoc_STR("(ComponentInstance ci, PixMapHandle src, Rect srcRect) -> (ComponentResult _rv, ImageDescriptionHandle desc)")},
+	{"SCCompressSequenceFrame", (PyCFunction)Qt_SCCompressSequenceFrame, 1,
+	 PyDoc_STR("(ComponentInstance ci, PixMapHandle src, Rect srcRect) -> (ComponentResult _rv, Handle data, long dataSize, short notSyncFlag)")},
+	{"SCCompressSequenceEnd", (PyCFunction)Qt_SCCompressSequenceEnd, 1,
+	 PyDoc_STR("(ComponentInstance ci) -> (ComponentResult _rv)")},
+	{"SCDefaultPictHandleSettings", (PyCFunction)Qt_SCDefaultPictHandleSettings, 1,
+	 PyDoc_STR("(ComponentInstance ci, PicHandle srcPicture, short motion) -> (ComponentResult _rv)")},
+	{"SCDefaultPictFileSettings", (PyCFunction)Qt_SCDefaultPictFileSettings, 1,
+	 PyDoc_STR("(ComponentInstance ci, short srcRef, short motion) -> (ComponentResult _rv)")},
+	{"SCDefaultPixMapSettings", (PyCFunction)Qt_SCDefaultPixMapSettings, 1,
+	 PyDoc_STR("(ComponentInstance ci, PixMapHandle src, short motion) -> (ComponentResult _rv)")},
+	{"SCGetInfo", (PyCFunction)Qt_SCGetInfo, 1,
+	 PyDoc_STR("(ComponentInstance ci, OSType infoType, void * info) -> (ComponentResult _rv)")},
+	{"SCSetInfo", (PyCFunction)Qt_SCSetInfo, 1,
+	 PyDoc_STR("(ComponentInstance ci, OSType infoType, void * info) -> (ComponentResult _rv)")},
+	{"SCSetCompressFlags", (PyCFunction)Qt_SCSetCompressFlags, 1,
+	 PyDoc_STR("(ComponentInstance ci, long flags) -> (ComponentResult _rv)")},
+	{"SCGetCompressFlags", (PyCFunction)Qt_SCGetCompressFlags, 1,
+	 PyDoc_STR("(ComponentInstance ci) -> (ComponentResult _rv, long flags)")},
+	{"SCGetSettingsAsText", (PyCFunction)Qt_SCGetSettingsAsText, 1,
+	 PyDoc_STR("(ComponentInstance ci) -> (ComponentResult _rv, Handle text)")},
+	{"SCAsyncIdle", (PyCFunction)Qt_SCAsyncIdle, 1,
+	 PyDoc_STR("(ComponentInstance ci) -> (ComponentResult _rv)")},
+	{"TweenerReset", (PyCFunction)Qt_TweenerReset, 1,
+	 PyDoc_STR("(TweenerComponent tc) -> (ComponentResult _rv)")},
+	{"TCGetSourceRef", (PyCFunction)Qt_TCGetSourceRef, 1,
+	 PyDoc_STR("(MediaHandler mh, TimeCodeDescriptionHandle tcdH) -> (HandlerError _rv, UserData srefH)")},
+	{"TCSetSourceRef", (PyCFunction)Qt_TCSetSourceRef, 1,
+	 PyDoc_STR("(MediaHandler mh, TimeCodeDescriptionHandle tcdH, UserData srefH) -> (HandlerError _rv)")},
+	{"TCSetTimeCodeFlags", (PyCFunction)Qt_TCSetTimeCodeFlags, 1,
+	 PyDoc_STR("(MediaHandler mh, long flags, long flagsMask) -> (HandlerError _rv)")},
+	{"TCGetTimeCodeFlags", (PyCFunction)Qt_TCGetTimeCodeFlags, 1,
+	 PyDoc_STR("(MediaHandler mh) -> (HandlerError _rv, long flags)")},
+	{"MovieImportHandle", (PyCFunction)Qt_MovieImportHandle, 1,
+	 PyDoc_STR("(MovieImportComponent ci, Handle dataH, Movie theMovie, Track targetTrack, TimeValue atTime, long inFlags) -> (ComponentResult _rv, Track usedTrack, TimeValue addedDuration, long outFlags)")},
+	{"MovieImportFile", (PyCFunction)Qt_MovieImportFile, 1,
+	 PyDoc_STR("(MovieImportComponent ci, FSSpec theFile, Movie theMovie, Track targetTrack, TimeValue atTime, long inFlags) -> (ComponentResult _rv, Track usedTrack, TimeValue addedDuration, long outFlags)")},
+	{"MovieImportSetSampleDuration", (PyCFunction)Qt_MovieImportSetSampleDuration, 1,
+	 PyDoc_STR("(MovieImportComponent ci, TimeValue duration, TimeScale scale) -> (ComponentResult _rv)")},
+	{"MovieImportSetSampleDescription", (PyCFunction)Qt_MovieImportSetSampleDescription, 1,
+	 PyDoc_STR("(MovieImportComponent ci, SampleDescriptionHandle desc, OSType mediaType) -> (ComponentResult _rv)")},
+	{"MovieImportSetMediaFile", (PyCFunction)Qt_MovieImportSetMediaFile, 1,
+	 PyDoc_STR("(MovieImportComponent ci, AliasHandle alias) -> (ComponentResult _rv)")},
+	{"MovieImportSetDimensions", (PyCFunction)Qt_MovieImportSetDimensions, 1,
+	 PyDoc_STR("(MovieImportComponent ci, Fixed width, Fixed height) -> (ComponentResult _rv)")},
+	{"MovieImportSetChunkSize", (PyCFunction)Qt_MovieImportSetChunkSize, 1,
+	 PyDoc_STR("(MovieImportComponent ci, long chunkSize) -> (ComponentResult _rv)")},
+	{"MovieImportSetAuxiliaryData", (PyCFunction)Qt_MovieImportSetAuxiliaryData, 1,
+	 PyDoc_STR("(MovieImportComponent ci, Handle data, OSType handleType) -> (ComponentResult _rv)")},
+	{"MovieImportSetFromScrap", (PyCFunction)Qt_MovieImportSetFromScrap, 1,
+	 PyDoc_STR("(MovieImportComponent ci, Boolean fromScrap) -> (ComponentResult _rv)")},
+	{"MovieImportDoUserDialog", (PyCFunction)Qt_MovieImportDoUserDialog, 1,
+	 PyDoc_STR("(MovieImportComponent ci, FSSpec theFile, Handle theData) -> (ComponentResult _rv, Boolean canceled)")},
+	{"MovieImportSetDuration", (PyCFunction)Qt_MovieImportSetDuration, 1,
+	 PyDoc_STR("(MovieImportComponent ci, TimeValue duration) -> (ComponentResult _rv)")},
+	{"MovieImportGetAuxiliaryDataType", (PyCFunction)Qt_MovieImportGetAuxiliaryDataType, 1,
+	 PyDoc_STR("(MovieImportComponent ci) -> (ComponentResult _rv, OSType auxType)")},
+	{"MovieImportValidate", (PyCFunction)Qt_MovieImportValidate, 1,
+	 PyDoc_STR("(MovieImportComponent ci, FSSpec theFile, Handle theData) -> (ComponentResult _rv, Boolean valid)")},
+	{"MovieImportGetFileType", (PyCFunction)Qt_MovieImportGetFileType, 1,
+	 PyDoc_STR("(MovieImportComponent ci) -> (ComponentResult _rv, OSType fileType)")},
+	{"MovieImportDataRef", (PyCFunction)Qt_MovieImportDataRef, 1,
+	 PyDoc_STR("(MovieImportComponent ci, Handle dataRef, OSType dataRefType, Movie theMovie, Track targetTrack, TimeValue atTime, long inFlags) -> (ComponentResult _rv, Track usedTrack, TimeValue addedDuration, long outFlags)")},
+	{"MovieImportGetSampleDescription", (PyCFunction)Qt_MovieImportGetSampleDescription, 1,
+	 PyDoc_STR("(MovieImportComponent ci) -> (ComponentResult _rv, SampleDescriptionHandle desc, OSType mediaType)")},
+	{"MovieImportSetOffsetAndLimit", (PyCFunction)Qt_MovieImportSetOffsetAndLimit, 1,
+	 PyDoc_STR("(MovieImportComponent ci, unsigned long offset, unsigned long limit) -> (ComponentResult _rv)")},
+	{"MovieImportSetOffsetAndLimit64", (PyCFunction)Qt_MovieImportSetOffsetAndLimit64, 1,
+	 PyDoc_STR("(MovieImportComponent ci, wide offset, wide limit) -> (ComponentResult _rv)")},
+	{"MovieImportIdle", (PyCFunction)Qt_MovieImportIdle, 1,
+	 PyDoc_STR("(MovieImportComponent ci, long inFlags) -> (ComponentResult _rv, long outFlags)")},
+	{"MovieImportValidateDataRef", (PyCFunction)Qt_MovieImportValidateDataRef, 1,
+	 PyDoc_STR("(MovieImportComponent ci, Handle dataRef, OSType dataRefType) -> (ComponentResult _rv, UInt8 valid)")},
+	{"MovieImportGetLoadState", (PyCFunction)Qt_MovieImportGetLoadState, 1,
+	 PyDoc_STR("(MovieImportComponent ci) -> (ComponentResult _rv, long importerLoadState)")},
+	{"MovieImportGetMaxLoadedTime", (PyCFunction)Qt_MovieImportGetMaxLoadedTime, 1,
+	 PyDoc_STR("(MovieImportComponent ci) -> (ComponentResult _rv, TimeValue time)")},
+	{"MovieImportEstimateCompletionTime", (PyCFunction)Qt_MovieImportEstimateCompletionTime, 1,
+	 PyDoc_STR("(MovieImportComponent ci) -> (ComponentResult _rv, TimeRecord time)")},
+	{"MovieImportSetDontBlock", (PyCFunction)Qt_MovieImportSetDontBlock, 1,
+	 PyDoc_STR("(MovieImportComponent ci, Boolean dontBlock) -> (ComponentResult _rv)")},
+	{"MovieImportGetDontBlock", (PyCFunction)Qt_MovieImportGetDontBlock, 1,
+	 PyDoc_STR("(MovieImportComponent ci) -> (ComponentResult _rv, Boolean willBlock)")},
+	{"MovieImportSetIdleManager", (PyCFunction)Qt_MovieImportSetIdleManager, 1,
+	 PyDoc_STR("(MovieImportComponent ci, IdleManager im) -> (ComponentResult _rv)")},
+	{"MovieImportSetNewMovieFlags", (PyCFunction)Qt_MovieImportSetNewMovieFlags, 1,
+	 PyDoc_STR("(MovieImportComponent ci, long newMovieFlags) -> (ComponentResult _rv)")},
+	{"MovieImportGetDestinationMediaType", (PyCFunction)Qt_MovieImportGetDestinationMediaType, 1,
+	 PyDoc_STR("(MovieImportComponent ci) -> (ComponentResult _rv, OSType mediaType)")},
+	{"MovieExportToHandle", (PyCFunction)Qt_MovieExportToHandle, 1,
+	 PyDoc_STR("(MovieExportComponent ci, Handle dataH, Movie theMovie, Track onlyThisTrack, TimeValue startTime, TimeValue duration) -> (ComponentResult _rv)")},
+	{"MovieExportToFile", (PyCFunction)Qt_MovieExportToFile, 1,
+	 PyDoc_STR("(MovieExportComponent ci, FSSpec theFile, Movie theMovie, Track onlyThisTrack, TimeValue startTime, TimeValue duration) -> (ComponentResult _rv)")},
+	{"MovieExportGetAuxiliaryData", (PyCFunction)Qt_MovieExportGetAuxiliaryData, 1,
+	 PyDoc_STR("(MovieExportComponent ci, Handle dataH) -> (ComponentResult _rv, OSType handleType)")},
+	{"MovieExportSetSampleDescription", (PyCFunction)Qt_MovieExportSetSampleDescription, 1,
+	 PyDoc_STR("(MovieExportComponent ci, SampleDescriptionHandle desc, OSType mediaType) -> (ComponentResult _rv)")},
+	{"MovieExportDoUserDialog", (PyCFunction)Qt_MovieExportDoUserDialog, 1,
+	 PyDoc_STR("(MovieExportComponent ci, Movie theMovie, Track onlyThisTrack, TimeValue startTime, TimeValue duration) -> (ComponentResult _rv, Boolean canceled)")},
+	{"MovieExportGetCreatorType", (PyCFunction)Qt_MovieExportGetCreatorType, 1,
+	 PyDoc_STR("(MovieExportComponent ci) -> (ComponentResult _rv, OSType creator)")},
+	{"MovieExportToDataRef", (PyCFunction)Qt_MovieExportToDataRef, 1,
+	 PyDoc_STR("(MovieExportComponent ci, Handle dataRef, OSType dataRefType, Movie theMovie, Track onlyThisTrack, TimeValue startTime, TimeValue duration) -> (ComponentResult _rv)")},
+	{"MovieExportFromProceduresToDataRef", (PyCFunction)Qt_MovieExportFromProceduresToDataRef, 1,
+	 PyDoc_STR("(MovieExportComponent ci, Handle dataRef, OSType dataRefType) -> (ComponentResult _rv)")},
+	{"MovieExportValidate", (PyCFunction)Qt_MovieExportValidate, 1,
+	 PyDoc_STR("(MovieExportComponent ci, Movie theMovie, Track onlyThisTrack) -> (ComponentResult _rv, Boolean valid)")},
+	{"MovieExportGetFileNameExtension", (PyCFunction)Qt_MovieExportGetFileNameExtension, 1,
+	 PyDoc_STR("(MovieExportComponent ci) -> (ComponentResult _rv, OSType extension)")},
+	{"MovieExportGetShortFileTypeString", (PyCFunction)Qt_MovieExportGetShortFileTypeString, 1,
+	 PyDoc_STR("(MovieExportComponent ci, Str255 typeString) -> (ComponentResult _rv)")},
+	{"MovieExportGetSourceMediaType", (PyCFunction)Qt_MovieExportGetSourceMediaType, 1,
+	 PyDoc_STR("(MovieExportComponent ci) -> (ComponentResult _rv, OSType mediaType)")},
+	{"TextExportGetTimeFraction", (PyCFunction)Qt_TextExportGetTimeFraction, 1,
+	 PyDoc_STR("(TextExportComponent ci) -> (ComponentResult _rv, long movieTimeFraction)")},
+	{"TextExportSetTimeFraction", (PyCFunction)Qt_TextExportSetTimeFraction, 1,
+	 PyDoc_STR("(TextExportComponent ci, long movieTimeFraction) -> (ComponentResult _rv)")},
+	{"TextExportGetSettings", (PyCFunction)Qt_TextExportGetSettings, 1,
+	 PyDoc_STR("(TextExportComponent ci) -> (ComponentResult _rv, long setting)")},
+	{"TextExportSetSettings", (PyCFunction)Qt_TextExportSetSettings, 1,
+	 PyDoc_STR("(TextExportComponent ci, long setting) -> (ComponentResult _rv)")},
+	{"MIDIImportGetSettings", (PyCFunction)Qt_MIDIImportGetSettings, 1,
+	 PyDoc_STR("(TextExportComponent ci) -> (ComponentResult _rv, long setting)")},
+	{"MIDIImportSetSettings", (PyCFunction)Qt_MIDIImportSetSettings, 1,
+	 PyDoc_STR("(TextExportComponent ci, long setting) -> (ComponentResult _rv)")},
+	{"GraphicsImageImportSetSequenceEnabled", (PyCFunction)Qt_GraphicsImageImportSetSequenceEnabled, 1,
+	 PyDoc_STR("(GraphicImageMovieImportComponent ci, Boolean enable) -> (ComponentResult _rv)")},
+	{"GraphicsImageImportGetSequenceEnabled", (PyCFunction)Qt_GraphicsImageImportGetSequenceEnabled, 1,
+	 PyDoc_STR("(GraphicImageMovieImportComponent ci) -> (ComponentResult _rv, Boolean enable)")},
+	{"PreviewShowData", (PyCFunction)Qt_PreviewShowData, 1,
+	 PyDoc_STR("(pnotComponent p, OSType dataType, Handle data, Rect inHere) -> (ComponentResult _rv)")},
+	{"PreviewMakePreviewReference", (PyCFunction)Qt_PreviewMakePreviewReference, 1,
+	 PyDoc_STR("(pnotComponent p, FSSpec sourceFile) -> (ComponentResult _rv, OSType previewType, short resID)")},
+	{"PreviewEvent", (PyCFunction)Qt_PreviewEvent, 1,
+	 PyDoc_STR("(pnotComponent p) -> (ComponentResult _rv, EventRecord e, Boolean handledEvent)")},
+	{"DataCodecDecompress", (PyCFunction)Qt_DataCodecDecompress, 1,
+	 PyDoc_STR("(DataCodecComponent dc, void * srcData, UInt32 srcSize, void * dstData, UInt32 dstBufferSize) -> (ComponentResult _rv)")},
+	{"DataCodecGetCompressBufferSize", (PyCFunction)Qt_DataCodecGetCompressBufferSize, 1,
+	 PyDoc_STR("(DataCodecComponent dc, UInt32 srcSize) -> (ComponentResult _rv, UInt32 dstSize)")},
+	{"DataCodecCompress", (PyCFunction)Qt_DataCodecCompress, 1,
+	 PyDoc_STR("(DataCodecComponent dc, void * srcData, UInt32 srcSize, void * dstData, UInt32 dstBufferSize) -> (ComponentResult _rv, UInt32 actualDstSize, UInt32 decompressSlop)")},
+	{"DataCodecBeginInterruptSafe", (PyCFunction)Qt_DataCodecBeginInterruptSafe, 1,
+	 PyDoc_STR("(DataCodecComponent dc, unsigned long maxSrcSize) -> (ComponentResult _rv)")},
+	{"DataCodecEndInterruptSafe", (PyCFunction)Qt_DataCodecEndInterruptSafe, 1,
+	 PyDoc_STR("(DataCodecComponent dc) -> (ComponentResult _rv)")},
+	{"DataHGetData", (PyCFunction)Qt_DataHGetData, 1,
+	 PyDoc_STR("(DataHandler dh, Handle h, long hOffset, long offset, long size) -> (ComponentResult _rv)")},
+	{"DataHPutData", (PyCFunction)Qt_DataHPutData, 1,
+	 PyDoc_STR("(DataHandler dh, Handle h, long hOffset, long size) -> (ComponentResult _rv, long offset)")},
+	{"DataHFlushData", (PyCFunction)Qt_DataHFlushData, 1,
+	 PyDoc_STR("(DataHandler dh) -> (ComponentResult _rv)")},
+	{"DataHOpenForWrite", (PyCFunction)Qt_DataHOpenForWrite, 1,
+	 PyDoc_STR("(DataHandler dh) -> (ComponentResult _rv)")},
+	{"DataHCloseForWrite", (PyCFunction)Qt_DataHCloseForWrite, 1,
+	 PyDoc_STR("(DataHandler dh) -> (ComponentResult _rv)")},
+	{"DataHOpenForRead", (PyCFunction)Qt_DataHOpenForRead, 1,
+	 PyDoc_STR("(DataHandler dh) -> (ComponentResult _rv)")},
+	{"DataHCloseForRead", (PyCFunction)Qt_DataHCloseForRead, 1,
+	 PyDoc_STR("(DataHandler dh) -> (ComponentResult _rv)")},
+	{"DataHSetDataRef", (PyCFunction)Qt_DataHSetDataRef, 1,
+	 PyDoc_STR("(DataHandler dh, Handle dataRef) -> (ComponentResult _rv)")},
+	{"DataHGetDataRef", (PyCFunction)Qt_DataHGetDataRef, 1,
+	 PyDoc_STR("(DataHandler dh) -> (ComponentResult _rv, Handle dataRef)")},
+	{"DataHCompareDataRef", (PyCFunction)Qt_DataHCompareDataRef, 1,
+	 PyDoc_STR("(DataHandler dh, Handle dataRef) -> (ComponentResult _rv, Boolean equal)")},
+	{"DataHTask", (PyCFunction)Qt_DataHTask, 1,
+	 PyDoc_STR("(DataHandler dh) -> (ComponentResult _rv)")},
+	{"DataHFinishData", (PyCFunction)Qt_DataHFinishData, 1,
+	 PyDoc_STR("(DataHandler dh, Ptr PlaceToPutDataPtr, Boolean Cancel) -> (ComponentResult _rv)")},
+	{"DataHFlushCache", (PyCFunction)Qt_DataHFlushCache, 1,
+	 PyDoc_STR("(DataHandler dh) -> (ComponentResult _rv)")},
+	{"DataHResolveDataRef", (PyCFunction)Qt_DataHResolveDataRef, 1,
+	 PyDoc_STR("(DataHandler dh, Handle theDataRef, Boolean userInterfaceAllowed) -> (ComponentResult _rv, Boolean wasChanged)")},
+	{"DataHGetFileSize", (PyCFunction)Qt_DataHGetFileSize, 1,
+	 PyDoc_STR("(DataHandler dh) -> (ComponentResult _rv, long fileSize)")},
+	{"DataHCanUseDataRef", (PyCFunction)Qt_DataHCanUseDataRef, 1,
+	 PyDoc_STR("(DataHandler dh, Handle dataRef) -> (ComponentResult _rv, long useFlags)")},
+	{"DataHPreextend", (PyCFunction)Qt_DataHPreextend, 1,
+	 PyDoc_STR("(DataHandler dh, unsigned long maxToAdd) -> (ComponentResult _rv, unsigned long spaceAdded)")},
+	{"DataHSetFileSize", (PyCFunction)Qt_DataHSetFileSize, 1,
+	 PyDoc_STR("(DataHandler dh, long fileSize) -> (ComponentResult _rv)")},
+	{"DataHGetFreeSpace", (PyCFunction)Qt_DataHGetFreeSpace, 1,
+	 PyDoc_STR("(DataHandler dh) -> (ComponentResult _rv, unsigned long freeSize)")},
+	{"DataHCreateFile", (PyCFunction)Qt_DataHCreateFile, 1,
+	 PyDoc_STR("(DataHandler dh, OSType creator, Boolean deleteExisting) -> (ComponentResult _rv)")},
+	{"DataHGetPreferredBlockSize", (PyCFunction)Qt_DataHGetPreferredBlockSize, 1,
+	 PyDoc_STR("(DataHandler dh) -> (ComponentResult _rv, long blockSize)")},
+	{"DataHGetDeviceIndex", (PyCFunction)Qt_DataHGetDeviceIndex, 1,
+	 PyDoc_STR("(DataHandler dh) -> (ComponentResult _rv, long deviceIndex)")},
+	{"DataHIsStreamingDataHandler", (PyCFunction)Qt_DataHIsStreamingDataHandler, 1,
+	 PyDoc_STR("(DataHandler dh) -> (ComponentResult _rv, Boolean yes)")},
+	{"DataHGetDataInBuffer", (PyCFunction)Qt_DataHGetDataInBuffer, 1,
+	 PyDoc_STR("(DataHandler dh, long startOffset) -> (ComponentResult _rv, long size)")},
+	{"DataHGetScheduleAheadTime", (PyCFunction)Qt_DataHGetScheduleAheadTime, 1,
+	 PyDoc_STR("(DataHandler dh) -> (ComponentResult _rv, long millisecs)")},
+	{"DataHSetCacheSizeLimit", (PyCFunction)Qt_DataHSetCacheSizeLimit, 1,
+	 PyDoc_STR("(DataHandler dh, Size cacheSizeLimit) -> (ComponentResult _rv)")},
+	{"DataHGetCacheSizeLimit", (PyCFunction)Qt_DataHGetCacheSizeLimit, 1,
+	 PyDoc_STR("(DataHandler dh) -> (ComponentResult _rv, Size cacheSizeLimit)")},
+	{"DataHGetMovie", (PyCFunction)Qt_DataHGetMovie, 1,
+	 PyDoc_STR("(DataHandler dh) -> (ComponentResult _rv, Movie theMovie, short id)")},
+	{"DataHAddMovie", (PyCFunction)Qt_DataHAddMovie, 1,
+	 PyDoc_STR("(DataHandler dh, Movie theMovie) -> (ComponentResult _rv, short id)")},
+	{"DataHUpdateMovie", (PyCFunction)Qt_DataHUpdateMovie, 1,
+	 PyDoc_STR("(DataHandler dh, Movie theMovie, short id) -> (ComponentResult _rv)")},
+	{"DataHDoesBuffer", (PyCFunction)Qt_DataHDoesBuffer, 1,
+	 PyDoc_STR("(DataHandler dh) -> (ComponentResult _rv, Boolean buffersReads, Boolean buffersWrites)")},
+	{"DataHGetFileName", (PyCFunction)Qt_DataHGetFileName, 1,
+	 PyDoc_STR("(DataHandler dh, Str255 str) -> (ComponentResult _rv)")},
+	{"DataHGetAvailableFileSize", (PyCFunction)Qt_DataHGetAvailableFileSize, 1,
+	 PyDoc_STR("(DataHandler dh) -> (ComponentResult _rv, long fileSize)")},
+	{"DataHGetMacOSFileType", (PyCFunction)Qt_DataHGetMacOSFileType, 1,
+	 PyDoc_STR("(DataHandler dh) -> (ComponentResult _rv, OSType fileType)")},
+	{"DataHGetMIMEType", (PyCFunction)Qt_DataHGetMIMEType, 1,
+	 PyDoc_STR("(DataHandler dh, Str255 mimeType) -> (ComponentResult _rv)")},
+	{"DataHSetDataRefWithAnchor", (PyCFunction)Qt_DataHSetDataRefWithAnchor, 1,
+	 PyDoc_STR("(DataHandler dh, Handle anchorDataRef, OSType dataRefType, Handle dataRef) -> (ComponentResult _rv)")},
+	{"DataHGetDataRefWithAnchor", (PyCFunction)Qt_DataHGetDataRefWithAnchor, 1,
+	 PyDoc_STR("(DataHandler dh, Handle anchorDataRef, OSType dataRefType) -> (ComponentResult _rv, Handle dataRef)")},
+	{"DataHSetMacOSFileType", (PyCFunction)Qt_DataHSetMacOSFileType, 1,
+	 PyDoc_STR("(DataHandler dh, OSType fileType) -> (ComponentResult _rv)")},
+	{"DataHSetTimeBase", (PyCFunction)Qt_DataHSetTimeBase, 1,
+	 PyDoc_STR("(DataHandler dh, TimeBase tb) -> (ComponentResult _rv)")},
+	{"DataHGetInfoFlags", (PyCFunction)Qt_DataHGetInfoFlags, 1,
+	 PyDoc_STR("(DataHandler dh) -> (ComponentResult _rv, UInt32 flags)")},
+	{"DataHGetFileSize64", (PyCFunction)Qt_DataHGetFileSize64, 1,
+	 PyDoc_STR("(DataHandler dh) -> (ComponentResult _rv, wide fileSize)")},
+	{"DataHPreextend64", (PyCFunction)Qt_DataHPreextend64, 1,
+	 PyDoc_STR("(DataHandler dh, wide maxToAdd) -> (ComponentResult _rv, wide spaceAdded)")},
+	{"DataHSetFileSize64", (PyCFunction)Qt_DataHSetFileSize64, 1,
+	 PyDoc_STR("(DataHandler dh, wide fileSize) -> (ComponentResult _rv)")},
+	{"DataHGetFreeSpace64", (PyCFunction)Qt_DataHGetFreeSpace64, 1,
+	 PyDoc_STR("(DataHandler dh) -> (ComponentResult _rv, wide freeSize)")},
+	{"DataHAppend64", (PyCFunction)Qt_DataHAppend64, 1,
+	 PyDoc_STR("(DataHandler dh, void * data, unsigned long size) -> (ComponentResult _rv, wide fileOffset)")},
+	{"DataHPollRead", (PyCFunction)Qt_DataHPollRead, 1,
+	 PyDoc_STR("(DataHandler dh, void * dataPtr) -> (ComponentResult _rv, UInt32 dataSizeSoFar)")},
+	{"DataHGetDataAvailability", (PyCFunction)Qt_DataHGetDataAvailability, 1,
+	 PyDoc_STR("(DataHandler dh, long offset, long len) -> (ComponentResult _rv, long missing_offset, long missing_len)")},
+	{"DataHGetDataRefAsType", (PyCFunction)Qt_DataHGetDataRefAsType, 1,
+	 PyDoc_STR("(DataHandler dh, OSType requestedType) -> (ComponentResult _rv, Handle dataRef)")},
+	{"DataHSetDataRefExtension", (PyCFunction)Qt_DataHSetDataRefExtension, 1,
+	 PyDoc_STR("(DataHandler dh, Handle extension, OSType idType) -> (ComponentResult _rv)")},
+	{"DataHGetDataRefExtension", (PyCFunction)Qt_DataHGetDataRefExtension, 1,
+	 PyDoc_STR("(DataHandler dh, OSType idType) -> (ComponentResult _rv, Handle extension)")},
+	{"DataHGetMovieWithFlags", (PyCFunction)Qt_DataHGetMovieWithFlags, 1,
+	 PyDoc_STR("(DataHandler dh, short flags) -> (ComponentResult _rv, Movie theMovie, short id)")},
+	{"DataHGetFileTypeOrdering", (PyCFunction)Qt_DataHGetFileTypeOrdering, 1,
+	 PyDoc_STR("(DataHandler dh) -> (ComponentResult _rv, DataHFileTypeOrderingHandle orderingListHandle)")},
+	{"DataHCreateFileWithFlags", (PyCFunction)Qt_DataHCreateFileWithFlags, 1,
+	 PyDoc_STR("(DataHandler dh, OSType creator, Boolean deleteExisting, UInt32 flags) -> (ComponentResult _rv)")},
+	{"DataHGetInfo", (PyCFunction)Qt_DataHGetInfo, 1,
+	 PyDoc_STR("(DataHandler dh, OSType what, void * info) -> (ComponentResult _rv)")},
+	{"DataHSetIdleManager", (PyCFunction)Qt_DataHSetIdleManager, 1,
+	 PyDoc_STR("(DataHandler dh, IdleManager im) -> (ComponentResult _rv)")},
+	{"DataHDeleteFile", (PyCFunction)Qt_DataHDeleteFile, 1,
+	 PyDoc_STR("(DataHandler dh) -> (ComponentResult _rv)")},
+	{"DataHSetMovieUsageFlags", (PyCFunction)Qt_DataHSetMovieUsageFlags, 1,
+	 PyDoc_STR("(DataHandler dh, long flags) -> (ComponentResult _rv)")},
+	{"DataHUseTemporaryDataRef", (PyCFunction)Qt_DataHUseTemporaryDataRef, 1,
+	 PyDoc_STR("(DataHandler dh, long inFlags) -> (ComponentResult _rv)")},
+	{"DataHGetTemporaryDataRefCapabilities", (PyCFunction)Qt_DataHGetTemporaryDataRefCapabilities, 1,
+	 PyDoc_STR("(DataHandler dh) -> (ComponentResult _rv, long outUnderstoodFlags)")},
+	{"DataHRenameFile", (PyCFunction)Qt_DataHRenameFile, 1,
+	 PyDoc_STR("(DataHandler dh, Handle newDataRef) -> (ComponentResult _rv)")},
+	{"DataHPlaybackHints", (PyCFunction)Qt_DataHPlaybackHints, 1,
+	 PyDoc_STR("(DataHandler dh, long flags, unsigned long minFileOffset, unsigned long maxFileOffset, long bytesPerSecond) -> (ComponentResult _rv)")},
+	{"DataHPlaybackHints64", (PyCFunction)Qt_DataHPlaybackHints64, 1,
+	 PyDoc_STR("(DataHandler dh, long flags, wide minFileOffset, wide maxFileOffset, long bytesPerSecond) -> (ComponentResult _rv)")},
+	{"DataHGetDataRate", (PyCFunction)Qt_DataHGetDataRate, 1,
+	 PyDoc_STR("(DataHandler dh, long flags) -> (ComponentResult _rv, long bytesPerSecond)")},
+	{"DataHSetTimeHints", (PyCFunction)Qt_DataHSetTimeHints, 1,
+	 PyDoc_STR("(DataHandler dh, long flags, long bandwidthPriority, TimeScale scale, TimeValue minTime, TimeValue maxTime) -> (ComponentResult _rv)")},
+	{"VDGetMaxSrcRect", (PyCFunction)Qt_VDGetMaxSrcRect, 1,
+	 PyDoc_STR("(VideoDigitizerComponent ci, short inputStd) -> (ComponentResult _rv, Rect maxSrcRect)")},
+	{"VDGetActiveSrcRect", (PyCFunction)Qt_VDGetActiveSrcRect, 1,
+	 PyDoc_STR("(VideoDigitizerComponent ci, short inputStd) -> (ComponentResult _rv, Rect activeSrcRect)")},
+	{"VDSetDigitizerRect", (PyCFunction)Qt_VDSetDigitizerRect, 1,
+	 PyDoc_STR("(VideoDigitizerComponent ci) -> (ComponentResult _rv, Rect digitizerRect)")},
+	{"VDGetDigitizerRect", (PyCFunction)Qt_VDGetDigitizerRect, 1,
+	 PyDoc_STR("(VideoDigitizerComponent ci) -> (ComponentResult _rv, Rect digitizerRect)")},
+	{"VDGetVBlankRect", (PyCFunction)Qt_VDGetVBlankRect, 1,
+	 PyDoc_STR("(VideoDigitizerComponent ci, short inputStd) -> (ComponentResult _rv, Rect vBlankRect)")},
+	{"VDGetMaskPixMap", (PyCFunction)Qt_VDGetMaskPixMap, 1,
+	 PyDoc_STR("(VideoDigitizerComponent ci, PixMapHandle maskPixMap) -> (ComponentResult _rv)")},
+	{"VDUseThisCLUT", (PyCFunction)Qt_VDUseThisCLUT, 1,
+	 PyDoc_STR("(VideoDigitizerComponent ci, CTabHandle colorTableHandle) -> (ComponentResult _rv)")},
+	{"VDSetInputGammaValue", (PyCFunction)Qt_VDSetInputGammaValue, 1,
+	 PyDoc_STR("(VideoDigitizerComponent ci, Fixed channel1, Fixed channel2, Fixed channel3) -> (ComponentResult _rv)")},
+	{"VDGetInputGammaValue", (PyCFunction)Qt_VDGetInputGammaValue, 1,
+	 PyDoc_STR("(VideoDigitizerComponent ci) -> (ComponentResult _rv, Fixed channel1, Fixed channel2, Fixed channel3)")},
+	{"VDSetBrightness", (PyCFunction)Qt_VDSetBrightness, 1,
+	 PyDoc_STR("(VideoDigitizerComponent ci) -> (ComponentResult _rv, unsigned short brightness)")},
+	{"VDGetBrightness", (PyCFunction)Qt_VDGetBrightness, 1,
+	 PyDoc_STR("(VideoDigitizerComponent ci) -> (ComponentResult _rv, unsigned short brightness)")},
+	{"VDSetContrast", (PyCFunction)Qt_VDSetContrast, 1,
+	 PyDoc_STR("(VideoDigitizerComponent ci) -> (ComponentResult _rv, unsigned short contrast)")},
+	{"VDSetHue", (PyCFunction)Qt_VDSetHue, 1,
+	 PyDoc_STR("(VideoDigitizerComponent ci) -> (ComponentResult _rv, unsigned short hue)")},
+	{"VDSetSharpness", (PyCFunction)Qt_VDSetSharpness, 1,
+	 PyDoc_STR("(VideoDigitizerComponent ci) -> (ComponentResult _rv, unsigned short sharpness)")},
+	{"VDSetSaturation", (PyCFunction)Qt_VDSetSaturation, 1,
+	 PyDoc_STR("(VideoDigitizerComponent ci) -> (ComponentResult _rv, unsigned short saturation)")},
+	{"VDGetContrast", (PyCFunction)Qt_VDGetContrast, 1,
+	 PyDoc_STR("(VideoDigitizerComponent ci) -> (ComponentResult _rv, unsigned short contrast)")},
+	{"VDGetHue", (PyCFunction)Qt_VDGetHue, 1,
+	 PyDoc_STR("(VideoDigitizerComponent ci) -> (ComponentResult _rv, unsigned short hue)")},
+	{"VDGetSharpness", (PyCFunction)Qt_VDGetSharpness, 1,
+	 PyDoc_STR("(VideoDigitizerComponent ci) -> (ComponentResult _rv, unsigned short sharpness)")},
+	{"VDGetSaturation", (PyCFunction)Qt_VDGetSaturation, 1,
+	 PyDoc_STR("(VideoDigitizerComponent ci) -> (ComponentResult _rv, unsigned short saturation)")},
+	{"VDGrabOneFrame", (PyCFunction)Qt_VDGrabOneFrame, 1,
+	 PyDoc_STR("(VideoDigitizerComponent ci) -> (ComponentResult _rv)")},
+	{"VDGetMaxAuxBuffer", (PyCFunction)Qt_VDGetMaxAuxBuffer, 1,
+	 PyDoc_STR("(VideoDigitizerComponent ci) -> (ComponentResult _rv, PixMapHandle pm, Rect r)")},
+	{"VDGetCurrentFlags", (PyCFunction)Qt_VDGetCurrentFlags, 1,
+	 PyDoc_STR("(VideoDigitizerComponent ci) -> (ComponentResult _rv, long inputCurrentFlag, long outputCurrentFlag)")},
+	{"VDSetKeyColor", (PyCFunction)Qt_VDSetKeyColor, 1,
+	 PyDoc_STR("(VideoDigitizerComponent ci, long index) -> (ComponentResult _rv)")},
+	{"VDGetKeyColor", (PyCFunction)Qt_VDGetKeyColor, 1,
+	 PyDoc_STR("(VideoDigitizerComponent ci) -> (ComponentResult _rv, long index)")},
+	{"VDAddKeyColor", (PyCFunction)Qt_VDAddKeyColor, 1,
+	 PyDoc_STR("(VideoDigitizerComponent ci) -> (ComponentResult _rv, long index)")},
+	{"VDGetNextKeyColor", (PyCFunction)Qt_VDGetNextKeyColor, 1,
+	 PyDoc_STR("(VideoDigitizerComponent ci, long index) -> (ComponentResult _rv)")},
+	{"VDSetKeyColorRange", (PyCFunction)Qt_VDSetKeyColorRange, 1,
+	 PyDoc_STR("(VideoDigitizerComponent ci) -> (ComponentResult _rv, RGBColor minRGB, RGBColor maxRGB)")},
+	{"VDGetKeyColorRange", (PyCFunction)Qt_VDGetKeyColorRange, 1,
+	 PyDoc_STR("(VideoDigitizerComponent ci) -> (ComponentResult _rv, RGBColor minRGB, RGBColor maxRGB)")},
+	{"VDSetInputColorSpaceMode", (PyCFunction)Qt_VDSetInputColorSpaceMode, 1,
+	 PyDoc_STR("(VideoDigitizerComponent ci, short colorSpaceMode) -> (ComponentResult _rv)")},
+	{"VDGetInputColorSpaceMode", (PyCFunction)Qt_VDGetInputColorSpaceMode, 1,
+	 PyDoc_STR("(VideoDigitizerComponent ci) -> (ComponentResult _rv, short colorSpaceMode)")},
+	{"VDSetClipState", (PyCFunction)Qt_VDSetClipState, 1,
+	 PyDoc_STR("(VideoDigitizerComponent ci, short clipEnable) -> (ComponentResult _rv)")},
+	{"VDGetClipState", (PyCFunction)Qt_VDGetClipState, 1,
+	 PyDoc_STR("(VideoDigitizerComponent ci) -> (ComponentResult _rv, short clipEnable)")},
+	{"VDSetClipRgn", (PyCFunction)Qt_VDSetClipRgn, 1,
+	 PyDoc_STR("(VideoDigitizerComponent ci, RgnHandle clipRegion) -> (ComponentResult _rv)")},
+	{"VDClearClipRgn", (PyCFunction)Qt_VDClearClipRgn, 1,
+	 PyDoc_STR("(VideoDigitizerComponent ci, RgnHandle clipRegion) -> (ComponentResult _rv)")},
+	{"VDGetCLUTInUse", (PyCFunction)Qt_VDGetCLUTInUse, 1,
+	 PyDoc_STR("(VideoDigitizerComponent ci) -> (ComponentResult _rv, CTabHandle colorTableHandle)")},
+	{"VDSetPLLFilterType", (PyCFunction)Qt_VDSetPLLFilterType, 1,
+	 PyDoc_STR("(VideoDigitizerComponent ci, short pllType) -> (ComponentResult _rv)")},
+	{"VDGetPLLFilterType", (PyCFunction)Qt_VDGetPLLFilterType, 1,
+	 PyDoc_STR("(VideoDigitizerComponent ci) -> (ComponentResult _rv, short pllType)")},
+	{"VDGetMaskandValue", (PyCFunction)Qt_VDGetMaskandValue, 1,
+	 PyDoc_STR("(VideoDigitizerComponent ci, unsigned short blendLevel) -> (ComponentResult _rv, long mask, long value)")},
+	{"VDSetMasterBlendLevel", (PyCFunction)Qt_VDSetMasterBlendLevel, 1,
+	 PyDoc_STR("(VideoDigitizerComponent ci) -> (ComponentResult _rv, unsigned short blendLevel)")},
+	{"VDSetPlayThruOnOff", (PyCFunction)Qt_VDSetPlayThruOnOff, 1,
+	 PyDoc_STR("(VideoDigitizerComponent ci, short state) -> (ComponentResult _rv)")},
+	{"VDSetFieldPreference", (PyCFunction)Qt_VDSetFieldPreference, 1,
+	 PyDoc_STR("(VideoDigitizerComponent ci, short fieldFlag) -> (ComponentResult _rv)")},
+	{"VDGetFieldPreference", (PyCFunction)Qt_VDGetFieldPreference, 1,
+	 PyDoc_STR("(VideoDigitizerComponent ci) -> (ComponentResult _rv, short fieldFlag)")},
+	{"VDPreflightGlobalRect", (PyCFunction)Qt_VDPreflightGlobalRect, 1,
+	 PyDoc_STR("(VideoDigitizerComponent ci, GrafPtr theWindow) -> (ComponentResult _rv, Rect globalRect)")},
+	{"VDSetPlayThruGlobalRect", (PyCFunction)Qt_VDSetPlayThruGlobalRect, 1,
+	 PyDoc_STR("(VideoDigitizerComponent ci, GrafPtr theWindow) -> (ComponentResult _rv, Rect globalRect)")},
+	{"VDSetBlackLevelValue", (PyCFunction)Qt_VDSetBlackLevelValue, 1,
+	 PyDoc_STR("(VideoDigitizerComponent ci) -> (ComponentResult _rv, unsigned short blackLevel)")},
+	{"VDGetBlackLevelValue", (PyCFunction)Qt_VDGetBlackLevelValue, 1,
+	 PyDoc_STR("(VideoDigitizerComponent ci) -> (ComponentResult _rv, unsigned short blackLevel)")},
+	{"VDSetWhiteLevelValue", (PyCFunction)Qt_VDSetWhiteLevelValue, 1,
+	 PyDoc_STR("(VideoDigitizerComponent ci) -> (ComponentResult _rv, unsigned short whiteLevel)")},
+	{"VDGetWhiteLevelValue", (PyCFunction)Qt_VDGetWhiteLevelValue, 1,
+	 PyDoc_STR("(VideoDigitizerComponent ci) -> (ComponentResult _rv, unsigned short whiteLevel)")},
+	{"VDGetVideoDefaults", (PyCFunction)Qt_VDGetVideoDefaults, 1,
+	 PyDoc_STR("(VideoDigitizerComponent ci) -> (ComponentResult _rv, unsigned short blackLevel, unsigned short whiteLevel, unsigned short brightness, unsigned short hue, unsigned short saturation, unsigned short contrast, unsigned short sharpness)")},
+	{"VDGetNumberOfInputs", (PyCFunction)Qt_VDGetNumberOfInputs, 1,
+	 PyDoc_STR("(VideoDigitizerComponent ci) -> (ComponentResult _rv, short inputs)")},
+	{"VDGetInputFormat", (PyCFunction)Qt_VDGetInputFormat, 1,
+	 PyDoc_STR("(VideoDigitizerComponent ci, short input) -> (ComponentResult _rv, short format)")},
+	{"VDSetInput", (PyCFunction)Qt_VDSetInput, 1,
+	 PyDoc_STR("(VideoDigitizerComponent ci, short input) -> (ComponentResult _rv)")},
+	{"VDGetInput", (PyCFunction)Qt_VDGetInput, 1,
+	 PyDoc_STR("(VideoDigitizerComponent ci) -> (ComponentResult _rv, short input)")},
+	{"VDSetInputStandard", (PyCFunction)Qt_VDSetInputStandard, 1,
+	 PyDoc_STR("(VideoDigitizerComponent ci, short inputStandard) -> (ComponentResult _rv)")},
+	{"VDSetupBuffers", (PyCFunction)Qt_VDSetupBuffers, 1,
+	 PyDoc_STR("(VideoDigitizerComponent ci, VdigBufferRecListHandle bufferList) -> (ComponentResult _rv)")},
+	{"VDGrabOneFrameAsync", (PyCFunction)Qt_VDGrabOneFrameAsync, 1,
+	 PyDoc_STR("(VideoDigitizerComponent ci, short buffer) -> (ComponentResult _rv)")},
+	{"VDDone", (PyCFunction)Qt_VDDone, 1,
+	 PyDoc_STR("(VideoDigitizerComponent ci, short buffer) -> (ComponentResult _rv)")},
+	{"VDSetCompression", (PyCFunction)Qt_VDSetCompression, 1,
+	 PyDoc_STR("(VideoDigitizerComponent ci, OSType compressType, short depth, CodecQ spatialQuality, CodecQ temporalQuality, long keyFrameRate) -> (ComponentResult _rv, Rect bounds)")},
+	{"VDCompressOneFrameAsync", (PyCFunction)Qt_VDCompressOneFrameAsync, 1,
+	 PyDoc_STR("(VideoDigitizerComponent ci) -> (ComponentResult _rv)")},
+	{"VDGetImageDescription", (PyCFunction)Qt_VDGetImageDescription, 1,
+	 PyDoc_STR("(VideoDigitizerComponent ci, ImageDescriptionHandle desc) -> (ComponentResult _rv)")},
+	{"VDResetCompressSequence", (PyCFunction)Qt_VDResetCompressSequence, 1,
+	 PyDoc_STR("(VideoDigitizerComponent ci) -> (ComponentResult _rv)")},
+	{"VDSetCompressionOnOff", (PyCFunction)Qt_VDSetCompressionOnOff, 1,
+	 PyDoc_STR("(VideoDigitizerComponent ci, Boolean state) -> (ComponentResult _rv)")},
+	{"VDGetCompressionTypes", (PyCFunction)Qt_VDGetCompressionTypes, 1,
+	 PyDoc_STR("(VideoDigitizerComponent ci, VDCompressionListHandle h) -> (ComponentResult _rv)")},
+	{"VDSetTimeBase", (PyCFunction)Qt_VDSetTimeBase, 1,
+	 PyDoc_STR("(VideoDigitizerComponent ci, TimeBase t) -> (ComponentResult _rv)")},
+	{"VDSetFrameRate", (PyCFunction)Qt_VDSetFrameRate, 1,
+	 PyDoc_STR("(VideoDigitizerComponent ci, Fixed framesPerSecond) -> (ComponentResult _rv)")},
+	{"VDGetDataRate", (PyCFunction)Qt_VDGetDataRate, 1,
+	 PyDoc_STR("(VideoDigitizerComponent ci) -> (ComponentResult _rv, long milliSecPerFrame, Fixed framesPerSecond, long bytesPerSecond)")},
+	{"VDGetSoundInputDriver", (PyCFunction)Qt_VDGetSoundInputDriver, 1,
+	 PyDoc_STR("(VideoDigitizerComponent ci, Str255 soundDriverName) -> (ComponentResult _rv)")},
+	{"VDGetDMADepths", (PyCFunction)Qt_VDGetDMADepths, 1,
+	 PyDoc_STR("(VideoDigitizerComponent ci) -> (ComponentResult _rv, long depthArray, long preferredDepth)")},
+	{"VDGetPreferredTimeScale", (PyCFunction)Qt_VDGetPreferredTimeScale, 1,
+	 PyDoc_STR("(VideoDigitizerComponent ci) -> (ComponentResult _rv, TimeScale preferred)")},
+	{"VDReleaseAsyncBuffers", (PyCFunction)Qt_VDReleaseAsyncBuffers, 1,
+	 PyDoc_STR("(VideoDigitizerComponent ci) -> (ComponentResult _rv)")},
+	{"VDSetDataRate", (PyCFunction)Qt_VDSetDataRate, 1,
+	 PyDoc_STR("(VideoDigitizerComponent ci, long bytesPerSecond) -> (ComponentResult _rv)")},
+	{"VDGetTimeCode", (PyCFunction)Qt_VDGetTimeCode, 1,
+	 PyDoc_STR("(VideoDigitizerComponent ci, void * timeCodeFormat, void * timeCodeTime) -> (ComponentResult _rv, TimeRecord atTime)")},
+	{"VDUseSafeBuffers", (PyCFunction)Qt_VDUseSafeBuffers, 1,
+	 PyDoc_STR("(VideoDigitizerComponent ci, Boolean useSafeBuffers) -> (ComponentResult _rv)")},
+	{"VDGetSoundInputSource", (PyCFunction)Qt_VDGetSoundInputSource, 1,
+	 PyDoc_STR("(VideoDigitizerComponent ci, long videoInput) -> (ComponentResult _rv, long soundInput)")},
+	{"VDGetCompressionTime", (PyCFunction)Qt_VDGetCompressionTime, 1,
+	 PyDoc_STR("(VideoDigitizerComponent ci, OSType compressionType, short depth) -> (ComponentResult _rv, Rect srcRect, CodecQ spatialQuality, CodecQ temporalQuality, unsigned long compressTime)")},
+	{"VDSetPreferredPacketSize", (PyCFunction)Qt_VDSetPreferredPacketSize, 1,
+	 PyDoc_STR("(VideoDigitizerComponent ci, long preferredPacketSizeInBytes) -> (ComponentResult _rv)")},
+	{"VDSetPreferredImageDimensions", (PyCFunction)Qt_VDSetPreferredImageDimensions, 1,
+	 PyDoc_STR("(VideoDigitizerComponent ci, long width, long height) -> (ComponentResult _rv)")},
+	{"VDGetPreferredImageDimensions", (PyCFunction)Qt_VDGetPreferredImageDimensions, 1,
+	 PyDoc_STR("(VideoDigitizerComponent ci) -> (ComponentResult _rv, long width, long height)")},
+	{"VDGetInputName", (PyCFunction)Qt_VDGetInputName, 1,
+	 PyDoc_STR("(VideoDigitizerComponent ci, long videoInput, Str255 name) -> (ComponentResult _rv)")},
+	{"VDSetDestinationPort", (PyCFunction)Qt_VDSetDestinationPort, 1,
+	 PyDoc_STR("(VideoDigitizerComponent ci, CGrafPtr destPort) -> (ComponentResult _rv)")},
+	{"VDGetDeviceNameAndFlags", (PyCFunction)Qt_VDGetDeviceNameAndFlags, 1,
+	 PyDoc_STR("(VideoDigitizerComponent ci, Str255 outName) -> (ComponentResult _rv, UInt32 outNameFlags)")},
+	{"VDCaptureStateChanging", (PyCFunction)Qt_VDCaptureStateChanging, 1,
+	 PyDoc_STR("(VideoDigitizerComponent ci, UInt32 inStateFlags) -> (ComponentResult _rv)")},
+	{"XMLParseGetDetailedParseError", (PyCFunction)Qt_XMLParseGetDetailedParseError, 1,
+	 PyDoc_STR("(ComponentInstance aParser, StringPtr errDesc) -> (ComponentResult _rv, long errorLine)")},
+	{"XMLParseAddElement", (PyCFunction)Qt_XMLParseAddElement, 1,
+	 PyDoc_STR("(ComponentInstance aParser, UInt32 nameSpaceID, long elementFlags) -> (ComponentResult _rv, char elementName, UInt32 elementID)")},
+	{"XMLParseAddAttribute", (PyCFunction)Qt_XMLParseAddAttribute, 1,
+	 PyDoc_STR("(ComponentInstance aParser, UInt32 elementID, UInt32 nameSpaceID) -> (ComponentResult _rv, char attributeName, UInt32 attributeID)")},
+	{"XMLParseAddMultipleAttributes", (PyCFunction)Qt_XMLParseAddMultipleAttributes, 1,
+	 PyDoc_STR("(ComponentInstance aParser, UInt32 elementID) -> (ComponentResult _rv, UInt32 nameSpaceIDs, char attributeNames, UInt32 attributeIDs)")},
+	{"XMLParseAddAttributeAndValue", (PyCFunction)Qt_XMLParseAddAttributeAndValue, 1,
+	 PyDoc_STR("(ComponentInstance aParser, UInt32 elementID, UInt32 nameSpaceID, UInt32 attributeValueKind, void * attributeValueKindInfo) -> (ComponentResult _rv, char attributeName, UInt32 attributeID)")},
+	{"XMLParseAddAttributeValueKind", (PyCFunction)Qt_XMLParseAddAttributeValueKind, 1,
+	 PyDoc_STR("(ComponentInstance aParser, UInt32 elementID, UInt32 attributeID, UInt32 attributeValueKind, void * attributeValueKindInfo) -> (ComponentResult _rv)")},
+	{"XMLParseAddNameSpace", (PyCFunction)Qt_XMLParseAddNameSpace, 1,
+	 PyDoc_STR("(ComponentInstance aParser) -> (ComponentResult _rv, char nameSpaceURL, UInt32 nameSpaceID)")},
+	{"XMLParseSetOffsetAndLimit", (PyCFunction)Qt_XMLParseSetOffsetAndLimit, 1,
+	 PyDoc_STR("(ComponentInstance aParser, UInt32 offset, UInt32 limit) -> (ComponentResult _rv)")},
+	{"XMLParseSetEventParseRefCon", (PyCFunction)Qt_XMLParseSetEventParseRefCon, 1,
+	 PyDoc_STR("(ComponentInstance aParser, long refcon) -> (ComponentResult _rv)")},
+	{"SGInitialize", (PyCFunction)Qt_SGInitialize, 1,
+	 PyDoc_STR("(SeqGrabComponent s) -> (ComponentResult _rv)")},
+	{"SGSetDataOutput", (PyCFunction)Qt_SGSetDataOutput, 1,
+	 PyDoc_STR("(SeqGrabComponent s, FSSpec movieFile, long whereFlags) -> (ComponentResult _rv)")},
+	{"SGGetDataOutput", (PyCFunction)Qt_SGGetDataOutput, 1,
+	 PyDoc_STR("(SeqGrabComponent s, FSSpec movieFile) -> (ComponentResult _rv, long whereFlags)")},
+	{"SGSetGWorld", (PyCFunction)Qt_SGSetGWorld, 1,
+	 PyDoc_STR("(SeqGrabComponent s, CGrafPtr gp, GDHandle gd) -> (ComponentResult _rv)")},
+	{"SGGetGWorld", (PyCFunction)Qt_SGGetGWorld, 1,
+	 PyDoc_STR("(SeqGrabComponent s) -> (ComponentResult _rv, CGrafPtr gp, GDHandle gd)")},
+	{"SGNewChannel", (PyCFunction)Qt_SGNewChannel, 1,
+	 PyDoc_STR("(SeqGrabComponent s, OSType channelType) -> (ComponentResult _rv, SGChannel ref)")},
+	{"SGDisposeChannel", (PyCFunction)Qt_SGDisposeChannel, 1,
+	 PyDoc_STR("(SeqGrabComponent s, SGChannel c) -> (ComponentResult _rv)")},
+	{"SGStartPreview", (PyCFunction)Qt_SGStartPreview, 1,
+	 PyDoc_STR("(SeqGrabComponent s) -> (ComponentResult _rv)")},
+	{"SGStartRecord", (PyCFunction)Qt_SGStartRecord, 1,
+	 PyDoc_STR("(SeqGrabComponent s) -> (ComponentResult _rv)")},
+	{"SGIdle", (PyCFunction)Qt_SGIdle, 1,
+	 PyDoc_STR("(SeqGrabComponent s) -> (ComponentResult _rv)")},
+	{"SGStop", (PyCFunction)Qt_SGStop, 1,
+	 PyDoc_STR("(SeqGrabComponent s) -> (ComponentResult _rv)")},
+	{"SGPause", (PyCFunction)Qt_SGPause, 1,
+	 PyDoc_STR("(SeqGrabComponent s, Boolean pause) -> (ComponentResult _rv)")},
+	{"SGPrepare", (PyCFunction)Qt_SGPrepare, 1,
+	 PyDoc_STR("(SeqGrabComponent s, Boolean prepareForPreview, Boolean prepareForRecord) -> (ComponentResult _rv)")},
+	{"SGRelease", (PyCFunction)Qt_SGRelease, 1,
+	 PyDoc_STR("(SeqGrabComponent s) -> (ComponentResult _rv)")},
+	{"SGGetMovie", (PyCFunction)Qt_SGGetMovie, 1,
+	 PyDoc_STR("(SeqGrabComponent s) -> (Movie _rv)")},
+	{"SGSetMaximumRecordTime", (PyCFunction)Qt_SGSetMaximumRecordTime, 1,
+	 PyDoc_STR("(SeqGrabComponent s, unsigned long ticks) -> (ComponentResult _rv)")},
+	{"SGGetMaximumRecordTime", (PyCFunction)Qt_SGGetMaximumRecordTime, 1,
+	 PyDoc_STR("(SeqGrabComponent s) -> (ComponentResult _rv, unsigned long ticks)")},
+	{"SGGetStorageSpaceRemaining", (PyCFunction)Qt_SGGetStorageSpaceRemaining, 1,
+	 PyDoc_STR("(SeqGrabComponent s) -> (ComponentResult _rv, unsigned long bytes)")},
+	{"SGGetTimeRemaining", (PyCFunction)Qt_SGGetTimeRemaining, 1,
+	 PyDoc_STR("(SeqGrabComponent s) -> (ComponentResult _rv, long ticksLeft)")},
+	{"SGGrabPict", (PyCFunction)Qt_SGGrabPict, 1,
+	 PyDoc_STR("(SeqGrabComponent s, Rect bounds, short offscreenDepth, long grabPictFlags) -> (ComponentResult _rv, PicHandle p)")},
+	{"SGGetLastMovieResID", (PyCFunction)Qt_SGGetLastMovieResID, 1,
+	 PyDoc_STR("(SeqGrabComponent s) -> (ComponentResult _rv, short resID)")},
+	{"SGSetFlags", (PyCFunction)Qt_SGSetFlags, 1,
+	 PyDoc_STR("(SeqGrabComponent s, long sgFlags) -> (ComponentResult _rv)")},
+	{"SGGetFlags", (PyCFunction)Qt_SGGetFlags, 1,
+	 PyDoc_STR("(SeqGrabComponent s) -> (ComponentResult _rv, long sgFlags)")},
+	{"SGNewChannelFromComponent", (PyCFunction)Qt_SGNewChannelFromComponent, 1,
+	 PyDoc_STR("(SeqGrabComponent s, Component sgChannelComponent) -> (ComponentResult _rv, SGChannel newChannel)")},
+	{"SGSetSettings", (PyCFunction)Qt_SGSetSettings, 1,
+	 PyDoc_STR("(SeqGrabComponent s, UserData ud, long flags) -> (ComponentResult _rv)")},
+	{"SGGetSettings", (PyCFunction)Qt_SGGetSettings, 1,
+	 PyDoc_STR("(SeqGrabComponent s, long flags) -> (ComponentResult _rv, UserData ud)")},
+	{"SGGetIndChannel", (PyCFunction)Qt_SGGetIndChannel, 1,
+	 PyDoc_STR("(SeqGrabComponent s, short index) -> (ComponentResult _rv, SGChannel ref, OSType chanType)")},
+	{"SGUpdate", (PyCFunction)Qt_SGUpdate, 1,
+	 PyDoc_STR("(SeqGrabComponent s, RgnHandle updateRgn) -> (ComponentResult _rv)")},
+	{"SGGetPause", (PyCFunction)Qt_SGGetPause, 1,
+	 PyDoc_STR("(SeqGrabComponent s) -> (ComponentResult _rv, Boolean paused)")},
+	{"SGSetChannelSettings", (PyCFunction)Qt_SGSetChannelSettings, 1,
+	 PyDoc_STR("(SeqGrabComponent s, SGChannel c, UserData ud, long flags) -> (ComponentResult _rv)")},
+	{"SGGetChannelSettings", (PyCFunction)Qt_SGGetChannelSettings, 1,
+	 PyDoc_STR("(SeqGrabComponent s, SGChannel c, long flags) -> (ComponentResult _rv, UserData ud)")},
+	{"SGGetMode", (PyCFunction)Qt_SGGetMode, 1,
+	 PyDoc_STR("(SeqGrabComponent s) -> (ComponentResult _rv, Boolean previewMode, Boolean recordMode)")},
+	{"SGSetDataRef", (PyCFunction)Qt_SGSetDataRef, 1,
+	 PyDoc_STR("(SeqGrabComponent s, Handle dataRef, OSType dataRefType, long whereFlags) -> (ComponentResult _rv)")},
+	{"SGGetDataRef", (PyCFunction)Qt_SGGetDataRef, 1,
+	 PyDoc_STR("(SeqGrabComponent s) -> (ComponentResult _rv, Handle dataRef, OSType dataRefType, long whereFlags)")},
+	{"SGNewOutput", (PyCFunction)Qt_SGNewOutput, 1,
+	 PyDoc_STR("(SeqGrabComponent s, Handle dataRef, OSType dataRefType, long whereFlags) -> (ComponentResult _rv, SGOutput sgOut)")},
+	{"SGDisposeOutput", (PyCFunction)Qt_SGDisposeOutput, 1,
+	 PyDoc_STR("(SeqGrabComponent s, SGOutput sgOut) -> (ComponentResult _rv)")},
+	{"SGSetOutputFlags", (PyCFunction)Qt_SGSetOutputFlags, 1,
+	 PyDoc_STR("(SeqGrabComponent s, SGOutput sgOut, long whereFlags) -> (ComponentResult _rv)")},
+	{"SGSetChannelOutput", (PyCFunction)Qt_SGSetChannelOutput, 1,
+	 PyDoc_STR("(SeqGrabComponent s, SGChannel c, SGOutput sgOut) -> (ComponentResult _rv)")},
+	{"SGGetDataOutputStorageSpaceRemaining", (PyCFunction)Qt_SGGetDataOutputStorageSpaceRemaining, 1,
+	 PyDoc_STR("(SeqGrabComponent s, SGOutput sgOut) -> (ComponentResult _rv, unsigned long space)")},
+	{"SGHandleUpdateEvent", (PyCFunction)Qt_SGHandleUpdateEvent, 1,
+	 PyDoc_STR("(SeqGrabComponent s, EventRecord event) -> (ComponentResult _rv, Boolean handled)")},
+	{"SGSetOutputNextOutput", (PyCFunction)Qt_SGSetOutputNextOutput, 1,
+	 PyDoc_STR("(SeqGrabComponent s, SGOutput sgOut, SGOutput nextOut) -> (ComponentResult _rv)")},
+	{"SGGetOutputNextOutput", (PyCFunction)Qt_SGGetOutputNextOutput, 1,
+	 PyDoc_STR("(SeqGrabComponent s, SGOutput sgOut) -> (ComponentResult _rv, SGOutput nextOut)")},
+	{"SGSetOutputMaximumOffset", (PyCFunction)Qt_SGSetOutputMaximumOffset, 1,
+	 PyDoc_STR("(SeqGrabComponent s, SGOutput sgOut, wide maxOffset) -> (ComponentResult _rv)")},
+	{"SGGetOutputMaximumOffset", (PyCFunction)Qt_SGGetOutputMaximumOffset, 1,
+	 PyDoc_STR("(SeqGrabComponent s, SGOutput sgOut) -> (ComponentResult _rv, wide maxOffset)")},
+	{"SGGetOutputDataReference", (PyCFunction)Qt_SGGetOutputDataReference, 1,
+	 PyDoc_STR("(SeqGrabComponent s, SGOutput sgOut) -> (ComponentResult _rv, Handle dataRef, OSType dataRefType)")},
+	{"SGWriteExtendedMovieData", (PyCFunction)Qt_SGWriteExtendedMovieData, 1,
+	 PyDoc_STR("(SeqGrabComponent s, SGChannel c, Ptr p, long len) -> (ComponentResult _rv, wide offset, SGOutput sgOut)")},
+	{"SGGetStorageSpaceRemaining64", (PyCFunction)Qt_SGGetStorageSpaceRemaining64, 1,
+	 PyDoc_STR("(SeqGrabComponent s) -> (ComponentResult _rv, wide bytes)")},
+	{"SGGetDataOutputStorageSpaceRemaining64", (PyCFunction)Qt_SGGetDataOutputStorageSpaceRemaining64, 1,
+	 PyDoc_STR("(SeqGrabComponent s, SGOutput sgOut) -> (ComponentResult _rv, wide space)")},
+	{"SGWriteMovieData", (PyCFunction)Qt_SGWriteMovieData, 1,
+	 PyDoc_STR("(SeqGrabComponent s, SGChannel c, Ptr p, long len) -> (ComponentResult _rv, long offset)")},
+	{"SGGetTimeBase", (PyCFunction)Qt_SGGetTimeBase, 1,
+	 PyDoc_STR("(SeqGrabComponent s) -> (ComponentResult _rv, TimeBase tb)")},
+	{"SGAddMovieData", (PyCFunction)Qt_SGAddMovieData, 1,
+	 PyDoc_STR("(SeqGrabComponent s, SGChannel c, Ptr p, long len, long chRefCon, TimeValue time, short writeType) -> (ComponentResult _rv, long offset)")},
+	{"SGChangedSource", (PyCFunction)Qt_SGChangedSource, 1,
+	 PyDoc_STR("(SeqGrabComponent s, SGChannel c) -> (ComponentResult _rv)")},
+	{"SGAddExtendedMovieData", (PyCFunction)Qt_SGAddExtendedMovieData, 1,
+	 PyDoc_STR("(SeqGrabComponent s, SGChannel c, Ptr p, long len, long chRefCon, TimeValue time, short writeType) -> (ComponentResult _rv, wide offset, SGOutput whichOutput)")},
+	{"SGAddOutputDataRefToMedia", (PyCFunction)Qt_SGAddOutputDataRefToMedia, 1,
+	 PyDoc_STR("(SeqGrabComponent s, SGOutput sgOut, Media theMedia, SampleDescriptionHandle desc) -> (ComponentResult _rv)")},
+	{"SGSetSettingsSummary", (PyCFunction)Qt_SGSetSettingsSummary, 1,
+	 PyDoc_STR("(SeqGrabComponent s, Handle summaryText) -> (ComponentResult _rv)")},
+	{"SGSetChannelUsage", (PyCFunction)Qt_SGSetChannelUsage, 1,
+	 PyDoc_STR("(SGChannel c, long usage) -> (ComponentResult _rv)")},
+	{"SGGetChannelUsage", (PyCFunction)Qt_SGGetChannelUsage, 1,
+	 PyDoc_STR("(SGChannel c) -> (ComponentResult _rv, long usage)")},
+	{"SGSetChannelBounds", (PyCFunction)Qt_SGSetChannelBounds, 1,
+	 PyDoc_STR("(SGChannel c, Rect bounds) -> (ComponentResult _rv)")},
+	{"SGGetChannelBounds", (PyCFunction)Qt_SGGetChannelBounds, 1,
+	 PyDoc_STR("(SGChannel c) -> (ComponentResult _rv, Rect bounds)")},
+	{"SGSetChannelVolume", (PyCFunction)Qt_SGSetChannelVolume, 1,
+	 PyDoc_STR("(SGChannel c, short volume) -> (ComponentResult _rv)")},
+	{"SGGetChannelVolume", (PyCFunction)Qt_SGGetChannelVolume, 1,
+	 PyDoc_STR("(SGChannel c) -> (ComponentResult _rv, short volume)")},
+	{"SGGetChannelInfo", (PyCFunction)Qt_SGGetChannelInfo, 1,
+	 PyDoc_STR("(SGChannel c) -> (ComponentResult _rv, long channelInfo)")},
+	{"SGSetChannelPlayFlags", (PyCFunction)Qt_SGSetChannelPlayFlags, 1,
+	 PyDoc_STR("(SGChannel c, long playFlags) -> (ComponentResult _rv)")},
+	{"SGGetChannelPlayFlags", (PyCFunction)Qt_SGGetChannelPlayFlags, 1,
+	 PyDoc_STR("(SGChannel c) -> (ComponentResult _rv, long playFlags)")},
+	{"SGSetChannelMaxFrames", (PyCFunction)Qt_SGSetChannelMaxFrames, 1,
+	 PyDoc_STR("(SGChannel c, long frameCount) -> (ComponentResult _rv)")},
+	{"SGGetChannelMaxFrames", (PyCFunction)Qt_SGGetChannelMaxFrames, 1,
+	 PyDoc_STR("(SGChannel c) -> (ComponentResult _rv, long frameCount)")},
+	{"SGSetChannelRefCon", (PyCFunction)Qt_SGSetChannelRefCon, 1,
+	 PyDoc_STR("(SGChannel c, long refCon) -> (ComponentResult _rv)")},
+	{"SGSetChannelClip", (PyCFunction)Qt_SGSetChannelClip, 1,
+	 PyDoc_STR("(SGChannel c, RgnHandle theClip) -> (ComponentResult _rv)")},
+	{"SGGetChannelClip", (PyCFunction)Qt_SGGetChannelClip, 1,
+	 PyDoc_STR("(SGChannel c) -> (ComponentResult _rv, RgnHandle theClip)")},
+	{"SGGetChannelSampleDescription", (PyCFunction)Qt_SGGetChannelSampleDescription, 1,
+	 PyDoc_STR("(SGChannel c, Handle sampleDesc) -> (ComponentResult _rv)")},
+	{"SGSetChannelDevice", (PyCFunction)Qt_SGSetChannelDevice, 1,
+	 PyDoc_STR("(SGChannel c, StringPtr name) -> (ComponentResult _rv)")},
+	{"SGGetChannelTimeScale", (PyCFunction)Qt_SGGetChannelTimeScale, 1,
+	 PyDoc_STR("(SGChannel c) -> (ComponentResult _rv, TimeScale scale)")},
+	{"SGChannelPutPicture", (PyCFunction)Qt_SGChannelPutPicture, 1,
+	 PyDoc_STR("(SGChannel c) -> (ComponentResult _rv)")},
+	{"SGChannelSetRequestedDataRate", (PyCFunction)Qt_SGChannelSetRequestedDataRate, 1,
+	 PyDoc_STR("(SGChannel c, long bytesPerSecond) -> (ComponentResult _rv)")},
+	{"SGChannelGetRequestedDataRate", (PyCFunction)Qt_SGChannelGetRequestedDataRate, 1,
+	 PyDoc_STR("(SGChannel c) -> (ComponentResult _rv, long bytesPerSecond)")},
+	{"SGChannelSetDataSourceName", (PyCFunction)Qt_SGChannelSetDataSourceName, 1,
+	 PyDoc_STR("(SGChannel c, Str255 name, ScriptCode scriptTag) -> (ComponentResult _rv)")},
+	{"SGChannelGetDataSourceName", (PyCFunction)Qt_SGChannelGetDataSourceName, 1,
+	 PyDoc_STR("(SGChannel c, Str255 name) -> (ComponentResult _rv, ScriptCode scriptTag)")},
+	{"SGChannelSetCodecSettings", (PyCFunction)Qt_SGChannelSetCodecSettings, 1,
+	 PyDoc_STR("(SGChannel c, Handle settings) -> (ComponentResult _rv)")},
+	{"SGChannelGetCodecSettings", (PyCFunction)Qt_SGChannelGetCodecSettings, 1,
+	 PyDoc_STR("(SGChannel c) -> (ComponentResult _rv, Handle settings)")},
+	{"SGGetChannelTimeBase", (PyCFunction)Qt_SGGetChannelTimeBase, 1,
+	 PyDoc_STR("(SGChannel c) -> (ComponentResult _rv, TimeBase tb)")},
+	{"SGGetChannelRefCon", (PyCFunction)Qt_SGGetChannelRefCon, 1,
+	 PyDoc_STR("(SGChannel c) -> (ComponentResult _rv, long refCon)")},
+	{"SGGetChannelDeviceAndInputNames", (PyCFunction)Qt_SGGetChannelDeviceAndInputNames, 1,
+	 PyDoc_STR("(SGChannel c, Str255 outDeviceName, Str255 outInputName) -> (ComponentResult _rv, short outInputNumber)")},
+	{"SGSetChannelDeviceInput", (PyCFunction)Qt_SGSetChannelDeviceInput, 1,
+	 PyDoc_STR("(SGChannel c, short inInputNumber) -> (ComponentResult _rv)")},
+	{"SGSetChannelSettingsStateChanging", (PyCFunction)Qt_SGSetChannelSettingsStateChanging, 1,
+	 PyDoc_STR("(SGChannel c, UInt32 inFlags) -> (ComponentResult _rv)")},
+	{"SGInitChannel", (PyCFunction)Qt_SGInitChannel, 1,
+	 PyDoc_STR("(SGChannel c, SeqGrabComponent owner) -> (ComponentResult _rv)")},
+	{"SGWriteSamples", (PyCFunction)Qt_SGWriteSamples, 1,
+	 PyDoc_STR("(SGChannel c, Movie m, AliasHandle theFile) -> (ComponentResult _rv)")},
+	{"SGGetDataRate", (PyCFunction)Qt_SGGetDataRate, 1,
+	 PyDoc_STR("(SGChannel c) -> (ComponentResult _rv, long bytesPerSecond)")},
+	{"SGAlignChannelRect", (PyCFunction)Qt_SGAlignChannelRect, 1,
+	 PyDoc_STR("(SGChannel c) -> (ComponentResult _rv, Rect r)")},
+	{"SGPanelGetDitl", (PyCFunction)Qt_SGPanelGetDitl, 1,
+	 PyDoc_STR("(SeqGrabComponent s) -> (ComponentResult _rv, Handle ditl)")},
+	{"SGPanelGetTitle", (PyCFunction)Qt_SGPanelGetTitle, 1,
+	 PyDoc_STR("(SeqGrabComponent s, Str255 title) -> (ComponentResult _rv)")},
+	{"SGPanelCanRun", (PyCFunction)Qt_SGPanelCanRun, 1,
+	 PyDoc_STR("(SeqGrabComponent s, SGChannel c) -> (ComponentResult _rv)")},
+	{"SGPanelInstall", (PyCFunction)Qt_SGPanelInstall, 1,
+	 PyDoc_STR("(SeqGrabComponent s, SGChannel c, DialogPtr d, short itemOffset) -> (ComponentResult _rv)")},
+	{"SGPanelEvent", (PyCFunction)Qt_SGPanelEvent, 1,
+	 PyDoc_STR("(SeqGrabComponent s, SGChannel c, DialogPtr d, short itemOffset, EventRecord theEvent) -> (ComponentResult _rv, short itemHit, Boolean handled)")},
+	{"SGPanelItem", (PyCFunction)Qt_SGPanelItem, 1,
+	 PyDoc_STR("(SeqGrabComponent s, SGChannel c, DialogPtr d, short itemOffset, short itemNum) -> (ComponentResult _rv)")},
+	{"SGPanelRemove", (PyCFunction)Qt_SGPanelRemove, 1,
+	 PyDoc_STR("(SeqGrabComponent s, SGChannel c, DialogPtr d, short itemOffset) -> (ComponentResult _rv)")},
+	{"SGPanelSetGrabber", (PyCFunction)Qt_SGPanelSetGrabber, 1,
+	 PyDoc_STR("(SeqGrabComponent s, SeqGrabComponent sg) -> (ComponentResult _rv)")},
+	{"SGPanelSetResFile", (PyCFunction)Qt_SGPanelSetResFile, 1,
+	 PyDoc_STR("(SeqGrabComponent s, short resRef) -> (ComponentResult _rv)")},
+	{"SGPanelGetSettings", (PyCFunction)Qt_SGPanelGetSettings, 1,
+	 PyDoc_STR("(SeqGrabComponent s, SGChannel c, long flags) -> (ComponentResult _rv, UserData ud)")},
+	{"SGPanelSetSettings", (PyCFunction)Qt_SGPanelSetSettings, 1,
+	 PyDoc_STR("(SeqGrabComponent s, SGChannel c, UserData ud, long flags) -> (ComponentResult _rv)")},
+	{"SGPanelValidateInput", (PyCFunction)Qt_SGPanelValidateInput, 1,
+	 PyDoc_STR("(SeqGrabComponent s) -> (ComponentResult _rv, Boolean ok)")},
+	{"SGPanelGetDITLForSize", (PyCFunction)Qt_SGPanelGetDITLForSize, 1,
+	 PyDoc_STR("(SeqGrabComponent s) -> (ComponentResult _rv, Handle ditl, Point requestedSize)")},
+	{"SGGetSrcVideoBounds", (PyCFunction)Qt_SGGetSrcVideoBounds, 1,
+	 PyDoc_STR("(SGChannel c) -> (ComponentResult _rv, Rect r)")},
+	{"SGSetVideoRect", (PyCFunction)Qt_SGSetVideoRect, 1,
+	 PyDoc_STR("(SGChannel c, Rect r) -> (ComponentResult _rv)")},
+	{"SGGetVideoRect", (PyCFunction)Qt_SGGetVideoRect, 1,
+	 PyDoc_STR("(SGChannel c) -> (ComponentResult _rv, Rect r)")},
+	{"SGGetVideoCompressorType", (PyCFunction)Qt_SGGetVideoCompressorType, 1,
+	 PyDoc_STR("(SGChannel c) -> (ComponentResult _rv, OSType compressorType)")},
+	{"SGSetVideoCompressorType", (PyCFunction)Qt_SGSetVideoCompressorType, 1,
+	 PyDoc_STR("(SGChannel c, OSType compressorType) -> (ComponentResult _rv)")},
+	{"SGSetVideoCompressor", (PyCFunction)Qt_SGSetVideoCompressor, 1,
+	 PyDoc_STR("(SGChannel c, short depth, CompressorComponent compressor, CodecQ spatialQuality, CodecQ temporalQuality, long keyFrameRate) -> (ComponentResult _rv)")},
+	{"SGGetVideoCompressor", (PyCFunction)Qt_SGGetVideoCompressor, 1,
+	 PyDoc_STR("(SGChannel c) -> (ComponentResult _rv, short depth, CompressorComponent compressor, CodecQ spatialQuality, CodecQ temporalQuality, long keyFrameRate)")},
+	{"SGGetVideoDigitizerComponent", (PyCFunction)Qt_SGGetVideoDigitizerComponent, 1,
+	 PyDoc_STR("(SGChannel c) -> (ComponentInstance _rv)")},
+	{"SGSetVideoDigitizerComponent", (PyCFunction)Qt_SGSetVideoDigitizerComponent, 1,
+	 PyDoc_STR("(SGChannel c, ComponentInstance vdig) -> (ComponentResult _rv)")},
+	{"SGVideoDigitizerChanged", (PyCFunction)Qt_SGVideoDigitizerChanged, 1,
+	 PyDoc_STR("(SGChannel c) -> (ComponentResult _rv)")},
+	{"SGGrabFrame", (PyCFunction)Qt_SGGrabFrame, 1,
+	 PyDoc_STR("(SGChannel c, short bufferNum) -> (ComponentResult _rv)")},
+	{"SGGrabFrameComplete", (PyCFunction)Qt_SGGrabFrameComplete, 1,
+	 PyDoc_STR("(SGChannel c, short bufferNum) -> (ComponentResult _rv, Boolean done)")},
+	{"SGCompressFrame", (PyCFunction)Qt_SGCompressFrame, 1,
+	 PyDoc_STR("(SGChannel c, short bufferNum) -> (ComponentResult _rv)")},
+	{"SGSetCompressBuffer", (PyCFunction)Qt_SGSetCompressBuffer, 1,
+	 PyDoc_STR("(SGChannel c, short depth, Rect compressSize) -> (ComponentResult _rv)")},
+	{"SGGetCompressBuffer", (PyCFunction)Qt_SGGetCompressBuffer, 1,
+	 PyDoc_STR("(SGChannel c) -> (ComponentResult _rv, short depth, Rect compressSize)")},
+	{"SGGetBufferInfo", (PyCFunction)Qt_SGGetBufferInfo, 1,
+	 PyDoc_STR("(SGChannel c, short bufferNum) -> (ComponentResult _rv, PixMapHandle bufferPM, Rect bufferRect, GWorldPtr compressBuffer, Rect compressBufferRect)")},
+	{"SGSetUseScreenBuffer", (PyCFunction)Qt_SGSetUseScreenBuffer, 1,
+	 PyDoc_STR("(SGChannel c, Boolean useScreenBuffer) -> (ComponentResult _rv)")},
+	{"SGGetUseScreenBuffer", (PyCFunction)Qt_SGGetUseScreenBuffer, 1,
+	 PyDoc_STR("(SGChannel c) -> (ComponentResult _rv, Boolean useScreenBuffer)")},
+	{"SGSetFrameRate", (PyCFunction)Qt_SGSetFrameRate, 1,
+	 PyDoc_STR("(SGChannel c, Fixed frameRate) -> (ComponentResult _rv)")},
+	{"SGGetFrameRate", (PyCFunction)Qt_SGGetFrameRate, 1,
+	 PyDoc_STR("(SGChannel c) -> (ComponentResult _rv, Fixed frameRate)")},
+	{"SGSetPreferredPacketSize", (PyCFunction)Qt_SGSetPreferredPacketSize, 1,
+	 PyDoc_STR("(SGChannel c, long preferredPacketSizeInBytes) -> (ComponentResult _rv)")},
+	{"SGGetPreferredPacketSize", (PyCFunction)Qt_SGGetPreferredPacketSize, 1,
+	 PyDoc_STR("(SGChannel c) -> (ComponentResult _rv, long preferredPacketSizeInBytes)")},
+	{"SGSetUserVideoCompressorList", (PyCFunction)Qt_SGSetUserVideoCompressorList, 1,
+	 PyDoc_STR("(SGChannel c, Handle compressorTypes) -> (ComponentResult _rv)")},
+	{"SGGetUserVideoCompressorList", (PyCFunction)Qt_SGGetUserVideoCompressorList, 1,
+	 PyDoc_STR("(SGChannel c) -> (ComponentResult _rv, Handle compressorTypes)")},
+	{"SGSetSoundInputDriver", (PyCFunction)Qt_SGSetSoundInputDriver, 1,
+	 PyDoc_STR("(SGChannel c, Str255 driverName) -> (ComponentResult _rv)")},
+	{"SGGetSoundInputDriver", (PyCFunction)Qt_SGGetSoundInputDriver, 1,
+	 PyDoc_STR("(SGChannel c) -> (long _rv)")},
+	{"SGSoundInputDriverChanged", (PyCFunction)Qt_SGSoundInputDriverChanged, 1,
+	 PyDoc_STR("(SGChannel c) -> (ComponentResult _rv)")},
+	{"SGSetSoundRecordChunkSize", (PyCFunction)Qt_SGSetSoundRecordChunkSize, 1,
+	 PyDoc_STR("(SGChannel c, long seconds) -> (ComponentResult _rv)")},
+	{"SGGetSoundRecordChunkSize", (PyCFunction)Qt_SGGetSoundRecordChunkSize, 1,
+	 PyDoc_STR("(SGChannel c) -> (long _rv)")},
+	{"SGSetSoundInputRate", (PyCFunction)Qt_SGSetSoundInputRate, 1,
+	 PyDoc_STR("(SGChannel c, Fixed rate) -> (ComponentResult _rv)")},
+	{"SGGetSoundInputRate", (PyCFunction)Qt_SGGetSoundInputRate, 1,
+	 PyDoc_STR("(SGChannel c) -> (Fixed _rv)")},
+	{"SGSetSoundInputParameters", (PyCFunction)Qt_SGSetSoundInputParameters, 1,
+	 PyDoc_STR("(SGChannel c, short sampleSize, short numChannels, OSType compressionType) -> (ComponentResult _rv)")},
+	{"SGGetSoundInputParameters", (PyCFunction)Qt_SGGetSoundInputParameters, 1,
+	 PyDoc_STR("(SGChannel c) -> (ComponentResult _rv, short sampleSize, short numChannels, OSType compressionType)")},
+	{"SGSetAdditionalSoundRates", (PyCFunction)Qt_SGSetAdditionalSoundRates, 1,
+	 PyDoc_STR("(SGChannel c, Handle rates) -> (ComponentResult _rv)")},
+	{"SGGetAdditionalSoundRates", (PyCFunction)Qt_SGGetAdditionalSoundRates, 1,
+	 PyDoc_STR("(SGChannel c) -> (ComponentResult _rv, Handle rates)")},
+	{"SGSetFontName", (PyCFunction)Qt_SGSetFontName, 1,
+	 PyDoc_STR("(SGChannel c, StringPtr pstr) -> (ComponentResult _rv)")},
+	{"SGSetFontSize", (PyCFunction)Qt_SGSetFontSize, 1,
+	 PyDoc_STR("(SGChannel c, short fontSize) -> (ComponentResult _rv)")},
+	{"SGSetTextForeColor", (PyCFunction)Qt_SGSetTextForeColor, 1,
+	 PyDoc_STR("(SGChannel c) -> (ComponentResult _rv, RGBColor theColor)")},
+	{"SGSetTextBackColor", (PyCFunction)Qt_SGSetTextBackColor, 1,
+	 PyDoc_STR("(SGChannel c) -> (ComponentResult _rv, RGBColor theColor)")},
+	{"SGSetJustification", (PyCFunction)Qt_SGSetJustification, 1,
+	 PyDoc_STR("(SGChannel c, short just) -> (ComponentResult _rv)")},
+	{"SGGetTextReturnToSpaceValue", (PyCFunction)Qt_SGGetTextReturnToSpaceValue, 1,
+	 PyDoc_STR("(SGChannel c) -> (ComponentResult _rv, short rettospace)")},
+	{"SGSetTextReturnToSpaceValue", (PyCFunction)Qt_SGSetTextReturnToSpaceValue, 1,
+	 PyDoc_STR("(SGChannel c, short rettospace) -> (ComponentResult _rv)")},
+	{"QTVideoOutputGetCurrentClientName", (PyCFunction)Qt_QTVideoOutputGetCurrentClientName, 1,
+	 PyDoc_STR("(QTVideoOutputComponent vo, Str255 str) -> (ComponentResult _rv)")},
+	{"QTVideoOutputSetClientName", (PyCFunction)Qt_QTVideoOutputSetClientName, 1,
+	 PyDoc_STR("(QTVideoOutputComponent vo, Str255 str) -> (ComponentResult _rv)")},
+	{"QTVideoOutputGetClientName", (PyCFunction)Qt_QTVideoOutputGetClientName, 1,
+	 PyDoc_STR("(QTVideoOutputComponent vo, Str255 str) -> (ComponentResult _rv)")},
+	{"QTVideoOutputBegin", (PyCFunction)Qt_QTVideoOutputBegin, 1,
+	 PyDoc_STR("(QTVideoOutputComponent vo) -> (ComponentResult _rv)")},
+	{"QTVideoOutputEnd", (PyCFunction)Qt_QTVideoOutputEnd, 1,
+	 PyDoc_STR("(QTVideoOutputComponent vo) -> (ComponentResult _rv)")},
+	{"QTVideoOutputSetDisplayMode", (PyCFunction)Qt_QTVideoOutputSetDisplayMode, 1,
+	 PyDoc_STR("(QTVideoOutputComponent vo, long displayModeID) -> (ComponentResult _rv)")},
+	{"QTVideoOutputGetDisplayMode", (PyCFunction)Qt_QTVideoOutputGetDisplayMode, 1,
+	 PyDoc_STR("(QTVideoOutputComponent vo) -> (ComponentResult _rv, long displayModeID)")},
+	{"QTVideoOutputGetGWorld", (PyCFunction)Qt_QTVideoOutputGetGWorld, 1,
+	 PyDoc_STR("(QTVideoOutputComponent vo) -> (ComponentResult _rv, GWorldPtr gw)")},
+	{"QTVideoOutputGetIndSoundOutput", (PyCFunction)Qt_QTVideoOutputGetIndSoundOutput, 1,
+	 PyDoc_STR("(QTVideoOutputComponent vo, long index) -> (ComponentResult _rv, Component outputComponent)")},
+	{"QTVideoOutputGetClock", (PyCFunction)Qt_QTVideoOutputGetClock, 1,
+	 PyDoc_STR("(QTVideoOutputComponent vo) -> (ComponentResult _rv, ComponentInstance clock)")},
+	{"QTVideoOutputSetEchoPort", (PyCFunction)Qt_QTVideoOutputSetEchoPort, 1,
+	 PyDoc_STR("(QTVideoOutputComponent vo, CGrafPtr echoPort) -> (ComponentResult _rv)")},
+	{"QTVideoOutputGetIndImageDecompressor", (PyCFunction)Qt_QTVideoOutputGetIndImageDecompressor, 1,
+	 PyDoc_STR("(QTVideoOutputComponent vo, long index) -> (ComponentResult _rv, Component codec)")},
+	{"QTVideoOutputBaseSetEchoPort", (PyCFunction)Qt_QTVideoOutputBaseSetEchoPort, 1,
+	 PyDoc_STR("(QTVideoOutputComponent vo, CGrafPtr echoPort) -> (ComponentResult _rv)")},
 	{"AlignWindow", (PyCFunction)Qt_AlignWindow, 1,
 	 PyDoc_STR("(WindowPtr wp, Boolean front) -> None")},
 	{"DragAlignedWindow", (PyCFunction)Qt_DragAlignedWindow, 1,
@@ -14837,6 +24542,13 @@ void init_Qt(void)
 	/* Backward-compatible name */
 	Py_INCREF(&Movie_Type);
 	PyModule_AddObject(m, "MovieType", (PyObject *)&Movie_Type);
+	SGOutput_Type.ob_type = &PyType_Type;
+	if (PyType_Ready(&SGOutput_Type) < 0) return;
+	Py_INCREF(&SGOutput_Type);
+	PyModule_AddObject(m, "SGOutput", (PyObject *)&SGOutput_Type);
+	/* Backward-compatible name */
+	Py_INCREF(&SGOutput_Type);
+	PyModule_AddObject(m, "SGOutputType", (PyObject *)&SGOutput_Type);
 }
 
 /* ========================= End module _Qt ========================= */
diff --git a/Mac/Modules/qt/qtscan.py b/Mac/Modules/qt/qtscan.py
index 05b4206..c161b7c 100644
--- a/Mac/Modules/qt/qtscan.py
+++ b/Mac/Modules/qt/qtscan.py
@@ -8,15 +8,18 @@ from scantools import Scanner
 
 LONG = "QuickTime"
 SHORT = "qt"
-OBJECTS = ("Movie", "Track", "Media", "UserData", "TimeBase", "MovieController", "IdleManager")
+HEADERFILES= ("Movies.h", "ImageCompression.h", "QuickTimeComponents.h")
+OBJECTS = ("Movie", "Track", "Media", "UserData", "TimeBase", "MovieController", 
+	"IdleManager", "SGOutput")
 
 def main():
-	input = ("Movies.h", "ImageCompression.h")
+	input = HEADERFILES
 	output = SHORT + "gen.py"
 	defsoutput = TOOLBOXDIR + LONG + ".py"
 	scanner = MyScanner(input, output, defsoutput)
 	scanner.scan()
 	scanner.close()
+	scanner.gentypetest(SHORT+"typetest.py")
 	print "=== Testing definitions output code ==="
 	execfile(defsoutput, {}, {})
 	print "=== Done scanning and generating, now importing the generated code... ==="
@@ -37,9 +40,11 @@ class MyScanner(Scanner):
 
 	def writeinitialdefs(self):
 		self.defsfile.write("def FOUR_CHAR_CODE(x): return x\n")
+		self.defsfile.write("xmlIdentifierUnrecognized = -1\n")
 
 	def makeblacklistnames(self):
 		return [
+			"xmlIdentifierUnrecognized", # const with incompatible definition
 			"DisposeMovie",		# Done on python-object disposal
 			"DisposeMovieTrack",	# ditto
 			"DisposeTrackMedia",	# ditto
@@ -78,6 +83,13 @@ class MyScanner(Scanner):
 
             # these are ImageCompression blacklists
 			"GraphicsExportGetInputPtr",
+			
+			# QuickTimeComponents
+			# These two need some help: the first returns a point to a databuffer that
+			# the second disposes. Generate manually?
+			"VDCompressDone",
+			"VDReleaseCompressBuffer",
+			"QTVideoOutputGetGWorldParameters", # How useful is this?
 			]
 
 	def makeblacklisttypes(self):
@@ -156,6 +168,43 @@ class MyScanner(Scanner):
             "PixMapPtr",
             "GWorldFlags",
             "void_ptr",   # XXX Being lazy, this one is doable.
+            
+            # These are from QuickTimeComponents
+            "CDataHandlerUPP",
+            "CharDataHandlerUPP",
+            "CommentHandlerUPP",
+            "DataHCompletionUPP",
+            "'MovieExportGetDataUPP",
+            "MovieExportGetPropertyUPP",
+            "PreprocessInstructionHandlerUPP",
+            "SGModalFilterUPP",
+            "StartDocumentHandlerUPP",
+            "StartElementHandlerUPP",
+            "VdigIntUPP",
+            "SGDataUPP",
+            "EndDocumentHandlerUPP",
+            "EndElementHandlerUPP",
+            "VideoBottles", # Record full of UPPs
+            
+            "SCParams",
+            "ICMCompletionProcRecordPtr",
+            "DataHVolumeList",
+            "DigitizerInfo",
+            "SGCompressInfo",
+            "SeqGrabExtendedFrameInfoPtr",
+            "SeqGrabFrameInfoPtr",
+            "TCTextOptionsPtr",
+            "SGCompressInfo_ptr",
+            "SGDeviceList",
+            "TextDisplayData",
+            "TimeCodeDef",
+            "TimeCodeRecord",
+            "TweenRecord",
+            "VDGamRecPtr",
+            "ToneDescription", 	# XXXX Just lazy: this one is easy.
+            "XMLDoc",
+            "UInt64", 	# XXXX lazy
+            "UInt64_ptr", # XXXX lazy
 			]
 
 	def makerepairinstructions(self):
diff --git a/Mac/Modules/qt/qtsupport.py b/Mac/Modules/qt/qtsupport.py
index bb37380..bdc5e7d 100644
--- a/Mac/Modules/qt/qtsupport.py
+++ b/Mac/Modules/qt/qtsupport.py
@@ -116,6 +116,7 @@ UserData = OpaqueByValueType('UserData', 'UserDataObj')
 TimeBase = OpaqueByValueType('TimeBase', 'TimeBaseObj')
 MovieController = OpaqueByValueType('MovieController', 'MovieCtlObj')
 IdleManager = OpaqueByValueType('IdleManager', 'IdleManagerObj')
+SGOutput = OpaqueByValueType('SGOutput', 'SGOutputObj')
 
 # Other opaque objects
 Component = OpaqueByValueType('Component', 'CmpObj')
@@ -127,11 +128,25 @@ CodecComponent = OpaqueByValueType('CodecComponent', 'CmpObj')
 GraphicsImportComponent = OpaqueByValueType('GraphicsImportComponent', 'CmpObj')
 GraphicsExportComponent = OpaqueByValueType('GraphicsExportComponent', 'CmpObj')
 ImageTranscoderComponent = OpaqueByValueType('ImageTranscoderComponent', 'CmpObj')
-
+DataCodecComponent = OpaqueByValueType('DataCodecComponent', 'CmpObj')
+GraphicImageMovieImportComponent = OpaqueByValueType('GraphicImageMovieImportComponent', 'CmpObj')
+MovieExportComponent = OpaqueByValueType('MovieExportComponent', 'CmpObj')
+MovieImportComponent = OpaqueByValueType('MovieImportComponent', 'CmpObj')
+QTVideoOutputComponent = OpaqueByValueType('QTVideoOutputComponent', 'CmpObj')
+SeqGrabComponent = OpaqueByValueType('SeqGrabComponent', 'CmpObj')
+TextExportComponent = OpaqueByValueType('TextExportComponent', 'CmpObj')
+TweenerComponent = OpaqueByValueType('TweenerComponent', 'CmpObj')
+pnotComponent = OpaqueByValueType('pnotComponent', 'CmpObj')
+VideoDigitizerComponent = OpaqueByValueType('VideoDigitizerComponent', 'CmpObj')
 
 ComponentInstance = OpaqueByValueType('ComponentInstance', 'CmpInstObj')
 MediaHandler = OpaqueByValueType('MediaHandler', 'CmpInstObj')
 DataHandler = OpaqueByValueType('DataHandler', 'CmpInstObj')
+SGChannel = OpaqueByValueType('SGChannel', 'CmpInstObj')
+
+ConstFSSpecPtr = FSSpec_ptr
+GrafPtr = OpaqueByValueType("GrafPtr", "GrafObj")
+Byte = Boolean # XXXX For GetPaused and SetPaused
 
 RgnHandle = OpaqueByValueType("RgnHandle", "ResObj")
 PicHandle = OpaqueByValueType("PicHandle", "ResObj")
@@ -145,6 +160,10 @@ CGrafPtr = OpaqueByValueType("CGrafPtr", "GrafObj")
 GDHandle = OpaqueByValueType("GDHandle", "OptResObj")
 AliasHandle = OpaqueByValueType("AliasHandle", "ResObj")
 SoundDescriptionHandle = OpaqueByValueType("SoundDescriptionHandle", "ResObj")
+VdigBufferRecListHandle = OpaqueByValueType("VdigBufferRecListHandle", "ResObj")
+VDCompressionListHandle = OpaqueByValueType("VDCompressionListHandle", "ResObj")
+TimeCodeDescriptionHandle = OpaqueByValueType("TimeCodeDescriptionHandle", "ResObj")
+DataHFileTypeOrderingHandle = OpaqueByValueType("DataHFileTypeOrderingHandle", "ResObj")
 # Silly Apple, passing an OStype by reference...
 OSType_ptr = OpaqueType("OSType", "PyMac_BuildOSType", "PyMac_GetOSType")
 # And even sillier: passing floats by address
@@ -169,6 +188,7 @@ dataRefAttributesFlags = Type("dataRefAttributesFlags", "l")
 playHintsEnum = Type("playHintsEnum", "l")
 mediaHandlerFlagsEnum = Type("mediaHandlerFlagsEnum", "l")
 ComponentResult = Type("ComponentResult", "l")
+VideoDigitizerError = Type("ComponentResult", "l")
 HandlerError = Type("HandlerError", "l")
 Ptr = InputOnlyType("Ptr", "s")
 StringPtr = Type("StringPtr", "s")
@@ -246,6 +266,20 @@ class IdleManagerObjectDefinition(PEP253Mixin, GlobalObjectDefinition):
 					return NULL;
 				}""")
 
+class SGOutputObjectDefinition(PEP253Mixin, GlobalObjectDefinition):
+	# XXXX I'm not sure I fully understand how SGOutput works. It seems it's always tied
+	# to a specific SeqGrabComponent, but I'm not 100% sure. Also, I'm not sure all the
+	# routines that return an SGOutput actually return a *new* SGOutput. Need to read up on
+	# this.
+	def outputCheckNewArg(self):
+		Output("""if (itself == NULL) {
+					PyErr_SetString(Qt_Error,"Cannot create null SGOutput");
+					return NULL;
+				}""")
+#	def outputFreeIt(self, itselfname):
+#		Output("SGDisposeOutput(%s);", itselfname)
+
+
 # From here on it's basically all boiler plate...
 
 # Create the generator groups and link them
@@ -257,6 +291,7 @@ UserData_object = UserDataObjectDefinition('UserData', 'UserDataObj', 'UserData'
 TimeBase_object = TimeBaseObjectDefinition('TimeBase', 'TimeBaseObj', 'TimeBase')
 MovieController_object = MovieCtlObjectDefinition('MovieController', 'MovieCtlObj', 'MovieController')
 IdleManager_object = IdleManagerObjectDefinition('IdleManager', 'IdleManagerObj', 'IdleManager')
+SGOutput_object = SGOutputObjectDefinition('SGOutput', 'SGOutputObj', 'SGOutput')
 
 module.addobject(IdleManager_object)
 module.addobject(MovieController_object)
@@ -265,6 +300,10 @@ module.addobject(UserData_object)
 module.addobject(Media_object)
 module.addobject(Track_object)
 module.addobject(Movie_object)
+module.addobject(SGOutput_object)
+
+# Test which types we are still missing.
+execfile(string.lower(MODPREFIX) + 'typetest.py')
 
 # Create the generator classes used to populate the lists
 Function = OSErrWeakLinkFunctionGenerator
@@ -279,6 +318,7 @@ UserData_methods = []
 Media_methods = []
 Track_methods = []
 Movie_methods = []
+SGOutput_methods = []
 execfile(INPUTFILE)
 
 #
-- 
cgit v0.12

