//--------------------------------------------------------------------
void ofVideoGrabber::listDevices(){
//---------------------------------
#ifdef OF_VIDEO_CAPTURE_QUICKTIME
//---------------------------------
bool bNeedToInitGrabberFirst = false;
if (!bSgInited) bNeedToInitGrabberFirst = true;
//if we need to initialize the grabbing component then do it
if( bNeedToInitGrabberFirst ){
if( !qtInitSeqGrabber() ){
return;
}
}
printf("-------------------------------------");
/*
//input selection stuff (ie multiple webcams)
//from http://developer.apple.com/samplecode/SGDevices/listing13.html
//and originally http://lists.apple.com/archives/QuickTime-API/2008/Jan/msg00178.html
*/
SGDeviceList deviceList;
SGGetChannelDeviceList (gVideoChannel, sgDeviceListIncludeInputs, &deviceList);
unsigned char pascalName[256];
unsigned char pascalNameInput[256];
//this is our new way of enumerating devices
//quicktime can have multiple capture 'inputs' on the same capture 'device'
//ie the USB Video Class Video 'device' - can have multiple usb webcams attached on what QT calls 'inputs'
//The isight for example will show up as:
//USB Video Class Video - Built-in iSight ('input' 1 of the USB Video Class Video 'device')
//Where as another webcam also plugged whill show up as
//USB Video Class Video - Philips SPC 1000NC Webcam ('input' 2 of the USB Video Class Video 'device')
//this means our the device ID we use for selection has to count both capture 'devices' and their 'inputs'
//this needs to be the same in our init grabber method so that we select the device we ask for
int deviceCount = 0;
ofLog(OF_LOG_NOTICE, "listing available capture devices");
for(int i = 0 ; i < (*deviceList)->count ; ++i)
{
SGDeviceName nameRec;
nameRec = (*deviceList)->entry[i];
SGDeviceInputList deviceInputList = nameRec.inputs;
int numInputs = 0;
if( deviceInputList ) numInputs = ((*deviceInputList)->count);
memcpy(pascalName, (*deviceList)->entry[i].name, sizeof(char) * 256);
//this means we can use the capture method
if(nameRec.flags != sgDeviceNameFlagDeviceUnavailable){
//if we have a capture 'device' (qt's word not mine - I would prefer 'system' ) that is ready to be used
//we go through its inputs to list all physical devices - as there could be more than one!
for(int j = 0; j < numInputs; j++){
//if our 'device' has inputs we get their names here
if( deviceInputList ){
SGDeviceInputName inputNameRec = (*deviceInputList)->entry[j];
memcpy(pascalNameInput, inputNameRec.name, sizeof(char) * 256);
}
printf( "device[%i] %s - %s", deviceCount, p2cstr(pascalName), p2cstr(pascalNameInput) );
//we count this way as we need to be able to distinguish multiple inputs as devices
deviceCount++;
}
}else{
printf( "(unavailable) device[%i] %s", deviceCount, p2cstr(pascalName) );
deviceCount++;
}
}
printf( "-------------------------------------");
//if we initialized the grabbing component then close it
if( bNeedToInitGrabberFirst ){
qtCloseSeqGrabber();
}
//---------------------------------
#endif
//---------------------------------
//---------------------------------
#ifdef OF_VIDEO_CAPTURE_DIRECTSHOW
//---------------------------------
ofLog(OF_LOG_NOTICE, "---");
VI.listDevices();
ofLog(OF_LOG_NOTICE, "---");
//---------------------------------
#endif
//---------------------------------
//---------------------------------
#ifdef OF_VIDEO_CAPTURE_UNICAP
//--------------------------------
ucGrabber.listUCDevices();
//---------------------------------
#endif
//---------------------------------
//---------------------------------
#ifdef OF_VIDEO_CAPTURE_GSTREAMER
//--------------------------------
gstUtils.listDevices();
//---------------------------------
#endif
//---------------------------------
//---------------------------------
#ifdef OF_VIDEO_CAPTURE_V4L
//--------------------------------
struct stat st;
printf( "listing available capture devices");
printf( "---");
for (int i = 0; i < 8; i++)
{
sprintf(dev_name, "/dev/video%i", i);
if (stat (dev_name, &st) == 0) {
printf( "Video device %i = /dev/video%i",i,i);
} else {
}
}
printf( "---");
//---------------------------------
#endif
//---------------------------------
}
//--------------------------------------------------------------------
bool ofVideoGrabber::qtSelectDevice(int deviceNumber, bool didWeChooseADevice){
//note - check for memory freeing possibly needed for the all SGGetChannelDeviceList mac stuff
// also see notes in listDevices() regarding new enunemeration method.
//Generate a device list and enumerate
//all devices availble to the channel
SGDeviceList deviceList;
SGGetChannelDeviceList(gVideoChannel, sgDeviceListIncludeInputs, &deviceList);
unsigned char pascalName[256];
unsigned char pascalNameInput[256];
int numDevices = (*deviceList)->count;
if(numDevices == 0){
ofLog(OF_LOG_ERROR, "error: No catpure devices found");
return false;
}
int deviceCount = 0;
for(int i = 0 ; i < numDevices; ++i)
{
SGDeviceName nameRec;
nameRec = (*deviceList)->entry[i];
SGDeviceInputList deviceInputList = nameRec.inputs;
int numInputs = 0;
if( deviceInputList ) numInputs = ((*deviceInputList)->count);
memcpy(pascalName, (*deviceList)->entry[i].name, sizeof(char) * 256);
memset(pascalNameInput, 0, sizeof(char)*256);
//this means we can use the capture method
if(nameRec.flags != sgDeviceNameFlagDeviceUnavailable){
//if we have a capture 'device' (qt's word not mine - I would prefer 'system' ) that is ready to be used
//we go through its inputs to list all physical devices - as there could be more than one!
for(int j = 0; j < numInputs; j++){
//if our 'device' has inputs we get their names here
if( deviceInputList ){
SGDeviceInputName inputNameRec = (*deviceInputList)->entry[j];
memcpy(pascalNameInput, inputNameRec.name, sizeof(char) * 256);
}
//if the device number matches we try and setup the device
//if we didn't specifiy a device then we will try all devices till one works!
if( deviceCount == deviceNumber || !didWeChooseADevice ){
ofLog(OF_LOG_NOTICE, "attempting to open device[%i] %s - %s", deviceCount, p2cstr(pascalName), p2cstr(pascalNameInput) );
OSErr err1 = SGSetChannelDevice(gVideoChannel, pascalName);
OSErr err2 = SGSetChannelDeviceInput(gVideoChannel, j);
int successLevel = 0;
//if there were no errors then we have opened the device without issue
if ( err1 == noErr && err2 == noErr){
successLevel = 2;
}
//parameter errors are not fatal so we will try and open but will caution the user
else if ( (err1 == paramErr || err1 == noErr) && (err2 == noErr || err2 == paramErr) ){
successLevel = 1;
}
//the device is opened!
if ( successLevel > 0 ){
deviceName = (char *)p2cstr(pascalName);
deviceName += "-";
deviceName += (char *)p2cstr(pascalNameInput);
if(successLevel == 2)ofLog(OF_LOG_NOTICE, "device opened successfully");
else ofLog(OF_LOG_WARNING, "device opened with some paramater errors - should be fine though!");
//no need to keep searching - return that we have opened a device!
return true;
}else{
//if we selected a device in particular but failed we want to go through the whole list again - starting from 0 and try any device.
//so we return false - and try one more time without a preference
if( didWeChooseADevice ){
ofLog(OF_LOG_WARNING, "problems setting device[%i] %s - %s *****", deviceNumber, p2cstr(pascalName), p2cstr(pascalNameInput));
return false;
}else{
ofLog(OF_LOG_WARNING, "unable to open device, trying next device");
}
}
}
//we count this way as we need to be able to distinguish multiple inputs as devices
deviceCount++;
}
}else{
//ofLog(OF_LOG_ERROR, "(unavailable) device[%i] %s", deviceCount, p2cstr(pascalName) );
deviceCount++;
}
}
return false;
}
//--------------------------------------------------------------------
vector<ofVideoDevice> ofQuickTimeGrabber::listDevices(){
vector <ofVideoDevice> devices;
//---------------------------------
#ifdef OF_VIDEO_CAPTURE_QUICKTIME
//---------------------------------
bool bNeedToInitGrabberFirst = false;
if (!bSgInited) bNeedToInitGrabberFirst = true;
//if we need to initialize the grabbing component then do it
if( bNeedToInitGrabberFirst ){
if( !qtInitSeqGrabber() ){
return devices;
}
}
ofLogNotice("ofQuickTimeGrabber") << "-------------------------------------";
/*
//input selection stuff (ie multiple webcams)
//from http://developer.apple.com/samplecode/SGDevices/listing13.html
//and originally http://lists.apple.com/archives/QuickTime-API/2008/Jan/msg00178.html
*/
SGDeviceList deviceList;
SGGetChannelDeviceList (gVideoChannel, sgDeviceListIncludeInputs, &deviceList);
unsigned char pascalName[64];
unsigned char pascalNameInput[64];
//this is our new way of enumerating devices
//quicktime can have multiple capture 'inputs' on the same capture 'device'
//ie the USB Video Class Video 'device' - can have multiple usb webcams attached on what QT calls 'inputs'
//The isight for example will show up as:
//USB Video Class Video - Built-in iSight ('input' 1 of the USB Video Class Video 'device')
//Where as another webcam also plugged whill show up as
//USB Video Class Video - Philips SPC 1000NC Webcam ('input' 2 of the USB Video Class Video 'device')
//this means our the device ID we use for selection has to count both capture 'devices' and their 'inputs'
//this needs to be the same in our init grabber method so that we select the device we ask for
int deviceCount = 0;
ofLogNotice("ofQuickTimeGrabber") << "listing available capture devices";
for(int i = 0 ; i < (*deviceList)->count ; ++i)
{
SGDeviceName nameRec;
nameRec = (*deviceList)->entry[i];
SGDeviceInputList deviceInputList = nameRec.inputs;
int numInputs = 0;
if( deviceInputList ) numInputs = ((*deviceInputList)->count);
memcpy(pascalName, (*deviceList)->entry[i].name, sizeof(char) * 64);
//this means we can use the capture method
if(nameRec.flags != sgDeviceNameFlagDeviceUnavailable){
//if we have a capture 'device' (qt's word not mine - I would prefer 'system' ) that is ready to be used
//we go through its inputs to list all physical devices - as there could be more than one!
for(int j = 0; j < numInputs; j++){
//if our 'device' has inputs we get their names here
if( deviceInputList ){
SGDeviceInputName inputNameRec = (*deviceInputList)->entry[j];
memcpy(pascalNameInput, inputNameRec.name, sizeof(char) * 64);
}
ofLogNotice() << "device [" << deviceCount << "] " << p2cstr(pascalName) << " - " << p2cstr(pascalNameInput);
ofVideoDevice vd;
vd.id = deviceCount;
vd.deviceName = p2cstr(pascalName);
vd.bAvailable = true;
devices.push_back(vd);
//we count this way as we need to be able to distinguish multiple inputs as devices
deviceCount++;
}
}else{
ofLogNotice("ofQuickTimeGrabber") << "(unavailable) device [" << deviceCount << "] " << p2cstr(pascalName);
ofVideoDevice vd;
vd.id = deviceCount;
vd.deviceName = p2cstr(pascalName);
vd.bAvailable = false;
devices.push_back(vd);
deviceCount++;
}
}
ofLogNotice("ofQuickTimeGrabber") << "-------------------------------------";
//if we initialized the grabbing component then close it
if( bNeedToInitGrabberFirst ){
qtCloseSeqGrabber();
}
//---------------------------------
#endif
//---------------------------------
return devices;
}
/* return a list of available devices. the default device (if any) will be
* the first in the list.
*/
static GList *
device_list (GstOSXVideoSrc * src)
{
SeqGrabComponent component = NULL;
SGChannel channel;
SGDeviceList deviceList;
SGDeviceName *deviceEntry;
SGDeviceInputList inputList;
SGDeviceInputName *inputEntry;
ComponentResult err;
int n, i;
GList *list;
video_device *dev, *default_dev;
gchar sgname[256];
gchar friendly_name[256];
list = NULL;
default_dev = NULL;
if (src->video_chan) {
/* if we already have a video channel allocated, use that */
GST_DEBUG_OBJECT (src, "reusing existing channel for device_list");
channel = src->video_chan;
} else {
/* otherwise, allocate a temporary one */
component = OpenDefaultComponent (SeqGrabComponentType, 0);
if (!component) {
err = paramErr;
GST_ERROR_OBJECT (src, "OpenDefaultComponent failed. paramErr=%d",
(int) err);
goto end;
}
err = SGInitialize (component);
if (err != noErr) {
GST_ERROR_OBJECT (src, "SGInitialize returned %d", (int) err);
goto end;
}
err = SGSetDataRef (component, 0, 0, seqGrabDontMakeMovie);
if (err != noErr) {
GST_ERROR_OBJECT (src, "SGSetDataRef returned %d", (int) err);
goto end;
}
err = SGNewChannel (component, VideoMediaType, &channel);
if (err != noErr) {
GST_ERROR_OBJECT (src, "SGNewChannel returned %d", (int) err);
goto end;
}
}
err =
SGGetChannelDeviceList (channel, sgDeviceListIncludeInputs, &deviceList);
if (err != noErr) {
GST_ERROR_OBJECT (src, "SGGetChannelDeviceList returned %d", (int) err);
goto end;
}
for (n = 0; n < (*deviceList)->count; ++n) {
deviceEntry = &(*deviceList)->entry[n];
if (deviceEntry->flags & sgDeviceNameFlagDeviceUnavailable)
continue;
p2cstrcpy (sgname, deviceEntry->name);
inputList = deviceEntry->inputs;
if (inputList && (*inputList)->count >= 1) {
for (i = 0; i < (*inputList)->count; ++i) {
inputEntry = &(*inputList)->entry[i];
p2cstrcpy (friendly_name, inputEntry->name);
dev = video_device_alloc ();
dev->id = create_device_id (sgname, i);
if (!dev->id) {
video_device_free (dev);
i = -1;
break;
}
dev->name = g_strdup (friendly_name);
list = g_list_append (list, dev);
/* if this is the default device, note it */
if (n == (*deviceList)->selectedIndex
&& i == (*inputList)->selectedIndex) {
default_dev = dev;
}
}
/* error */
if (i == -1)
break;
} else {
/* ### can a device have no defined inputs? */
dev = video_device_alloc ();
dev->id = create_device_id (sgname, -1);
if (!dev->id) {
video_device_free (dev);
break;
}
dev->name = g_strdup (sgname);
list = g_list_append (list, dev);
/* if this is the default device, note it */
if (n == (*deviceList)->selectedIndex) {
default_dev = dev;
}
}
}
/* move default device to the front */
if (default_dev) {
list = g_list_remove (list, default_dev);
list = g_list_prepend (list, default_dev);
}
end:
if (!src->video_chan && component) {
err = CloseComponent (component);
if (err != noErr)
GST_WARNING_OBJECT (src, "CloseComponent returned %d", (int) err);
}
return list;
}
/* Initialize the QuickTime grabber */
static int qt_open_grabber(struct qt_grabber_state *s, char *fmt)
{
GrafPtr savedPort;
WindowPtr gMonitor;
//SGModalFilterUPP seqGrabModalFilterUPP;
assert(s != NULL);
assert(s->magic == MAGIC_QT_GRABBER);
/****************************************************************************************/
/* Step 0: Initialise the QuickTime movie toolbox. */
InitCursor();
EnterMovies();
/****************************************************************************************/
/* Step 1: Create an off-screen graphics world object, into which we can capture video. */
/* Lock it into position, to prevent QuickTime from messing with it while capturing. */
OSType pixelFormat;
pixelFormat = FOUR_CHAR_CODE('BGRA');
/****************************************************************************************/
/* Step 2: Open and initialise the default sequence grabber. */
s->grabber = OpenDefaultComponent(SeqGrabComponentType, 0);
if (s->grabber == 0) {
debug_msg("Unable to open grabber\n");
return 0;
}
gMonitor = GetDialogWindow(GetNewDialog(1000, NULL, (WindowPtr) - 1L));
GetPort(&savedPort);
SetPort((GrafPtr)gMonitor);
if (SGInitialize(s->grabber) != noErr) {
debug_msg("Unable to init grabber\n");
return 0;
}
SGSetGWorld(s->grabber, GetDialogPort((DialogPtr)gMonitor), NULL);
/****************************************************************************************/
/* Specify the destination data reference for a record operation tell it */
/* we're not making a movie if the flag seqGrabDontMakeMovie is used, */
/* the sequence grabber still calls your data function, but does not */
/* write any data to the movie file writeType will always be set to */
/* seqGrabWriteAppend */
if (SGSetDataRef(s->grabber, 0, 0, seqGrabDontMakeMovie) != noErr) {
CloseComponent(s->grabber);
debug_msg("Unable to set data ref\n");
return 0;
}
if (SGSetGWorld(s->grabber, NULL, NULL) != noErr) {
debug_msg("Unable to get gworld from grabber\n");
return 0;
}
if (SGNewChannel(s->grabber, VideoMediaType, &s->video_channel) !=
noErr) {
debug_msg("Unable to open video channel\n");
return 0;
}
/* do not check for grab audio in case that we will only display usage */
if (SGNewChannel(s->grabber, SoundMediaType, &s->audio_channel) !=
noErr) {
fprintf(stderr, "Warning: Creating audio channel failed. "
"Disabling sound output.\n");
s->grab_audio = FALSE;
}
/* Print available devices */
int i;
int j;
SGDeviceInputList inputList;
SGDeviceList deviceList;
if (strcmp(fmt, "help") == 0) {
printf("\nUsage:\t-t quicktime:<device>:<mode>:<pixel_type>[:<audio_device>:<audio_mode>]\n\n");
if (SGGetChannelDeviceList
(s->video_channel, sgDeviceListIncludeInputs,
&deviceList) == noErr) {
fprintf(stdout, "\nAvailable capture devices:\n");
for (i = 0; i < (*deviceList)->count; i++) {
SGDeviceName *deviceEntry =
&(*deviceList)->entry[i];
fprintf(stdout, " Device %d: ", i);
nprintf((char *) deviceEntry->name);
if (deviceEntry->flags &
sgDeviceNameFlagDeviceUnavailable) {
fprintf(stdout,
" - ### NOT AVAILABLE ###");
}
if (i == (*deviceList)->selectedIndex) {
fprintf(stdout, " - ### ACTIVE ###");
}
fprintf(stdout, "\n");
short activeInputIndex = 0;
inputList = deviceEntry->inputs;
if (inputList && (*inputList)->count >= 1) {
SGGetChannelDeviceAndInputNames
(s->video_channel, NULL, NULL,
&activeInputIndex);
for (j = 0; j < (*inputList)->count;
j++) {
fprintf(stdout, "\t");
fprintf(stdout, "- %d. ", j);
nprintf((char *) &(*inputList)->entry
[j].name);
if ((i ==
(*deviceList)->selectedIndex)
&& (j == activeInputIndex))
fprintf(stdout,
" - ### ACTIVE ###");
fprintf(stdout, "\n");
}
}
}
SGDisposeDeviceList(s->grabber, deviceList);
CodecNameSpecListPtr list;
GetCodecNameList(&list, 1);
printf("\nCompression types:\n");
for (i = 0; i < list->count; i++) {
int fcc = list->list[i].cType;
printf("\t%d) ", i);
nprintf((char *) list->list[i].typeName);
printf(" - FCC (%c%c%c%c)",
fcc >> 24,
(fcc >> 16) & 0xff,
(fcc >> 8) & 0xff, (fcc) & 0xff);
printf(" - codec id %x",
(unsigned int)(list->list[i].codec));
printf(" - cType %x",
(unsigned int)list->list[i].cType);
printf("\n");
}
}
void pix_videoDarwin :: InitSeqGrabber()
{
OSErr anErr;
Rect m_srcRect = {0,0, m_vidYSize, m_vidXSize};
SGDeviceList devices;
short deviceIndex,inputIndex;
short deviceCount = 0;
SGDeviceInputList theSGInputList = NULL;
bool showInputsAsDevices;
// UserData *uD;
/*
int num_components = 0;
Component c = 0;
ComponentDescription cd;
cd.componentType = SeqGrabComponentType;
cd.componentSubType = 0;
cd.componentManufacturer = 0;
cd.componentFlags = 0;
cd.componentFlagsMask = 0;
while((c = FindNextComponent(c, &cd)) != 0) {
num_components++; } // add component c to the list.
// post("number of SGcomponents: %d",num_components);
*/
m_sg = OpenDefaultComponent(SeqGrabComponentType, 0);
if(m_sg==NULL){
error("could not open default component");
return;
}
anErr = SGInitialize(m_sg);
if(anErr!=noErr){
error("could not initialize SG error %d",anErr);
return;
}
anErr = SGSetDataRef(m_sg, 0, 0, seqGrabDontMakeMovie);
if (anErr != noErr){
error("dataref failed with error %d",anErr);
}
anErr = SGNewChannel(m_sg, VideoMediaType, &m_vc);
if(anErr!=noErr){
error("could not make new SG channnel error %d",anErr);
return;
}
anErr = SGGetChannelDeviceList(m_vc, sgDeviceListIncludeInputs, &devices);
if(anErr!=noErr){
error("could not get SG channnel Device List");
}else{
deviceCount = (*devices)->count;
deviceIndex = (*devices)->selectedIndex;
logpost(NULL, 3, "SG channnel Device List count %d index %d",deviceCount,deviceIndex);
int i;
for (i = 0; i < deviceCount; i++){
logpost(NULL, 3, "SG channnel Device List %.*s",
(*devices)->entry[i].name[0],
(*devices)->entry[i].name+1);
}
SGGetChannelDeviceAndInputNames(m_vc, NULL, NULL, &inputIndex);
showInputsAsDevices = ((*devices)->entry[deviceIndex].flags) & sgDeviceNameFlagShowInputsAsDevices;
theSGInputList = ((SGDeviceName *)(&((*devices)->entry[deviceIndex])))->inputs; //fugly
//we should have device names in big ass undocumented structs
//walk through the list
//for (i = 0; i < deviceCount; i++){
for (i = 0; i < inputIndex; i++){
logpost(NULL, 3, "SG channnel Input Device List %d %.*s",
i,
(*theSGInputList)->entry[i].name[0],
(*theSGInputList)->entry[i].name+1);
}
}
//this call sets the input device
if (m_inputDevice > 0 && m_inputDevice < deviceCount) //check that the device is not out of bounds
//anErr = SGSetChannelDeviceInput(m_vc,m_inputDevice);
logpost(NULL, 3, "SGSetChannelDevice trying %s",
(*devices)->entry[m_inputDevice].name[0],
(*devices)->entry[m_inputDevice].name+1);
anErr = SGSetChannelDevice(m_vc, (*devices)->entry[m_inputDevice].name);
if(anErr!=noErr) error("SGSetChannelDevice returned error %d",anErr);
anErr = SGSetChannelDeviceInput(m_vc,m_inputDeviceChannel);
if(anErr!=noErr) error("SGSetChannelDeviceInput returned error %d",anErr);
/* //attempt to save SG settings to disk
NewUserData(uD);
SGGetSettings(m_sg,uD,0);
short uDCount;
uDCount = CountUserDataType(*uD,sgClipType);
post("UserDataType count %d",uDCount);
Handle myHandle;
PutUserDataIntoHandle(*uD,myHandle);
int myFile;
myFile = open("/Users/lincoln/Documents/temp",O_CREAT | O_RDWR, 0600);
write(myFile,myHandle,4096);
close(myFile);
*/
//grab the VDIG info from the SGChannel
m_vdig = SGGetVideoDigitizerComponent(m_vc);
vdigErr = VDGetDigitizerInfo(m_vdig,&m_vdigInfo); //not sure if this is useful
Str255 vdigName;
memset(vdigName,0,255);
vdigErr = VDGetInputName(m_vdig,m_inputDevice,vdigName);
logpost(NULL, 3, "vdigName is %s",vdigName); // pascal string?
Rect vdRect;
vdigErr = VDGetDigitizerRect(m_vdig,&vdRect);
logpost(NULL, 3, "digitizer rect is top %d bottom %d left %d right %d",vdRect.top,vdRect.bottom,vdRect.left,vdRect.right);
vdigErr = VDGetActiveSrcRect(m_vdig,0,&vdRect);
logpost(NULL, 3, "active src rect is top %d bottom %d left %d right %d",vdRect.top,vdRect.bottom,vdRect.left,vdRect.right);
anErr = SGSetChannelBounds(m_vc, &m_srcRect);
if(anErr!=noErr){
error("could not set SG ChannelBounds ");
}
anErr = SGSetVideoRect(m_vc, &m_srcRect);
if(anErr!=noErr){
error("could not set SG Rect ");
}
anErr = SGSetChannelUsage(m_vc, seqGrabPreview);
if(anErr!=noErr){
error("could not set SG ChannelUsage ");
}
switch (m_quality){
case 0:
anErr = SGSetChannelPlayFlags(m_vc, channelPlayNormal);
post("set SG NormalQuality");
break;
case 1:
anErr = SGSetChannelPlayFlags(m_vc, channelPlayHighQuality);
post("set SG HighQuality");
break;
case 2:
anErr = SGSetChannelPlayFlags(m_vc, channelPlayFast);
post("set SG FastQuality");
break;
case 3:
anErr = SGSetChannelPlayFlags(m_vc, channelPlayAllData);
post("set SG PlayAlldata");
break;
}
if (m_colorspace==GL_BGRA_EXT){
m_pixBlock.image.xsize = m_vidXSize;
m_pixBlock.image.ysize = m_vidYSize;
m_pixBlock.image.setCsizeByFormat(GL_RGBA_GEM);
m_pixBlock.image.reallocate();
m_rowBytes = m_vidXSize*4;
anErr = QTNewGWorldFromPtr (&m_srcGWorld,
k32ARGBPixelFormat,
&m_srcRect,
NULL,
NULL,
0,
m_pixBlock.image.data,
m_rowBytes);
post ("using RGB");
}else{
m_pixBlock.image.xsize = m_vidXSize;
m_pixBlock.image.ysize = m_vidYSize;
m_pixBlock.image.csize = 2;
m_pixBlock.image.format = GL_YCBCR_422_APPLE;
#ifdef __VEC__
m_pixBlock.image.type = GL_UNSIGNED_SHORT_8_8_REV_APPLE;
#else
m_pixBlock.image.type = GL_UNSIGNED_SHORT_8_8_APPLE;
#endif
m_pixBlock.image.reallocate();
m_rowBytes = m_vidXSize*2;
anErr = QTNewGWorldFromPtr (&m_srcGWorld,
// k422YpCbCr8CodecType,
k422YpCbCr8PixelFormat,
// '2vuy',
// kComponentVideoUnsigned,
&m_srcRect,
NULL,
NULL,
0,
m_pixBlock.image.data,
m_rowBytes);
post ("using YUV");
}
if (anErr!= noErr)
{
error("%d error at QTNewGWorldFromPtr", anErr);
return;
}
if (NULL == m_srcGWorld)
{
error("could not allocate off screen");
return;
}
SGSetGWorld(m_sg,(CGrafPtr)m_srcGWorld, NULL);
SGStartPreview(m_sg); //moved to starttransfer?
m_haveVideo = 1;
}