// ######################################################################
static void setVideoChannelBounds(SGChannel videoChannel,
const Rect* scaledSourceBounds,
const Rect* scaledVideoBounds)
{
// Notes: see Q&A 1250
// calculate the matrix to transform the
// scaledSourceBounds to the source bounds
Rect sourceBounds;
SGGetSrcVideoBounds(videoChannel, &sourceBounds);
MatrixRecord scaledSourceBoundsToSourceBounds;
RectMatrix(&scaledSourceBoundsToSourceBounds,
scaledSourceBounds, &sourceBounds);
// apply the same transform to the
// scaledVideoBounds to get the video bounds
Rect videoBounds = *scaledVideoBounds;
TransformRect(&scaledSourceBoundsToSourceBounds, &videoBounds, 0);
if (noErr != SGSetVideoRect(videoChannel, &videoBounds))
{
// some video digitizers may only be able to capture full frame
// and will return qtParamErr or possibly digiUnimpErr if they
// can't handle working with less than full frame
SGSetVideoRect(videoChannel, &sourceBounds);
}
// the channel bounds is scaledVideoBounds offset to (0, 0)
Rect channelBounds = *scaledVideoBounds;
OffsetRect(&channelBounds, -channelBounds.left, -channelBounds.top);
// Note: SGSetChannelBounds merely allows the client to specify it's
// preferred bounds. The actual bounds returned by the vDig in the
// image description may be different
if (noErr != SGSetChannelBounds(videoChannel, &channelBounds))
LFATAL("SGSetChannelBounds() failed");
}
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;
}
