/*
* Convert a filename to a string for display purposes.
* See pp 2-44--2-46 of IM:Files
*
* XXX static storage considered harmful
*/
const char *filename_to_str(const Filename *fn)
{
CInfoPBRec pb;
Str255 dirname;
OSErr err;
static char *path = NULL;
char *newpath;
if (path != NULL) sfree(path);
path = snewn(fn->fss.name[0], char);
p2cstrcpy(path, fn->fss.name);
pb.dirInfo.ioNamePtr = dirname;
pb.dirInfo.ioVRefNum = fn->fss.vRefNum;
pb.dirInfo.ioDrParID = fn->fss.parID;
pb.dirInfo.ioFDirIndex = -1;
do {
pb.dirInfo.ioDrDirID = pb.dirInfo.ioDrParID;
err = PBGetCatInfoSync(&pb);
/* XXX Assume not A/UX */
newpath = snewn(strlen(path) + dirname[0] + 2, char);
p2cstrcpy(newpath, dirname);
strcat(newpath, ":");
strcat(newpath, path);
sfree(path);
path = newpath;
} while (pb.dirInfo.ioDrDirID != fsRtDirID);
return path;
}
bool ofQtVideoSaver::setCodecPhotoJpeg() {
initializeQuicktime();
OSStatus error = noErr;
CodecNameSpecListPtr list;
CodecNameSpec * codecNameSpecPtr;
char typeName[32];
bool set = false;
error = GetCodecNameList( &list, 0 );
if ( error ) return false;
int numCodecs = list->count;
codecNameSpecPtr = (CodecNameSpec *)((short *)list + 1);
for (int i = 0; i < numCodecs; i++ ){
p2cstrcpy( typeName, codecNameSpecPtr->typeName );
//printf("codec (%i) = %s \n", i, typeName);
codecNameSpecPtr++;
//if(string(typeName) == "Photo - JPEG")
//if(string(typeName) == "H.264")
if(string(typeName) == "MPEG-4 Video")
{
codecType = codecNameSpecPtr->cType;
set = true;
printf("Setting Codec to %s\n", typeName);
break;
}
}
DisposeCodecNameList( list );
return set;
}
const String& Location_Disk_FSSpec::get_FileName( void ) const
{
static String Name;
const FSSpec* ps = get_FSSpec();
char cName[65];
p2cstrcpy( (StringPtr) ps->name, cName, sizeof(cName) );
Name = cName;
return Name;
}
void write_setting_fontspec(void *handle, const char *name, FontSpec font)
{
char *settingname;
char tmp[256];
p2cstrcpy(tmp, font.name);
write_setting_s(handle, name, tmp);
settingname = dupcat(name, "Face", NULL);
write_setting_i(handle, settingname, font.face);
sfree(settingname);
settingname = dupcat(name, "Size", NULL);
write_setting_i(handle, settingname, font.size);
sfree(settingname);
}
FILE *f_open(Filename fn, char const *mode)
{
short savevol;
long savedir;
char tmp[256];
FILE *ret;
HGetVol(NULL, &savevol, &savedir);
if (HSetVol(NULL, fn.fss.vRefNum, fn.fss.parID) == noErr) {
p2cstrcpy(tmp, fn.fss.name);
ret = fopen(tmp, mode);
} else
ret = NULL;
HSetVol(NULL, savevol, savedir);
return ret;
}
static void set_instrument(MidiEvent *ev)
{
long instrumentNumber;
int ch = ev->channel;
channel[ch].program = ev->a;
if(drum_part[ch]){
if(play_system_mode == GS_SYSTEM_MODE && channel[ch].bank_lsb == 2) // SC-88 Map
instrumentNumber = kFirstDrumkit + sc88_drum_kit[ev->a] + 1;
else if(play_system_mode == GS_SYSTEM_MODE && channel[ch].bank_lsb == 3) // SC-88Pro Map
instrumentNumber = kFirstDrumkit + sc88pro_drum_kit[ev->a] + 1;
else
instrumentNumber = kFirstDrumkit + ev->a + 1;
}
else {
if(play_system_mode == GS_SYSTEM_MODE)
instrumentNumber = kFirstGSInstrument + (channel[ch].bank_msb<<7) + ev->a;
else if(play_system_mode == XG_SYSTEM_MODE)
instrumentNumber = xg_instrument_number(ch, ev->a);
else
instrumentNumber = kFirstGMInstrument + ev->a;
}
if(instrument_number[ch] != instrumentNumber){
NoteRequest nr;
long index, part;
OSType synthType;
Str31 name;
SynthesizerConnections connections;
MusicComponent mc;
instrument_number[ch] = instrumentNumber;
if(note_channel[ch] != NULL)
NADisposeNoteChannel(gNoteAllocator, note_channel[ch]);
nr.info.flags = 0;
nr.info.reserved = 0;
*(short *)(&nr.info.polyphony) = EndianS16_NtoB(8); // 8 voices poliphonic
*(Fixed *)(&nr.info.typicalPolyphony) = EndianU32_NtoB(0x00010000);
NAStuffToneDescription(gNoteAllocator, instrumentNumber, &nr.tone);
NANewNoteChannel(gNoteAllocator, &nr, ¬e_channel[ch]);
NAGetNoteChannelInfo(gNoteAllocator, note_channel[ch], &index, &part);
NAGetRegisteredMusicDevice(gNoteAllocator, index, &synthType, name, &connections, &mc);
MusicGetPartName(mc, part, name);
p2cstrcpy(instrument_name[ch], name);
}
ctl_prog_event(ch, ev->a);
}
//--------------------------------------------------------------
void ofQtVideoSaver::listCodecs(){
initializeQuicktime();
OSStatus error = noErr;
CodecNameSpecListPtr list;
CodecNameSpec * codecNameSpecPtr;
char typeName[32];
error = GetCodecNameList( &list, 0 );
if ( error ) return;
int numCodecs = list->count;
codecNameSpecPtr = (CodecNameSpec *)((short *)list + 1);
for (int i = 0; i < numCodecs; i++ ){
p2cstrcpy( typeName, codecNameSpecPtr->typeName );
printf("codec (%i) = %s \n", i, typeName);
codecNameSpecPtr++;
}
DisposeCodecNameList( list );
}
char *enum_settings_next(void *handle, char *buffer, int buflen) {
struct enum_settings_state *e = handle;
CInfoPBRec pb;
OSErr error = noErr;
Str255 name;
if (e == NULL) return NULL;
do {
pb.hFileInfo.ioNamePtr = name;
pb.hFileInfo.ioVRefNum = e->vRefNum;
pb.hFileInfo.ioDirID = e->dirID;
pb.hFileInfo.ioFDirIndex = e->index++;
error = PBGetCatInfoSync(&pb);
if (error != noErr) return NULL;
} while (!((pb.hFileInfo.ioFlAttrib & ioDirMask) == 0 &&
pb.hFileInfo.ioFlFndrInfo.fdCreator == PUTTY_CREATOR &&
pb.hFileInfo.ioFlFndrInfo.fdType == SESS_TYPE &&
name[0] < buflen));
p2cstrcpy(buffer, name);
return buffer;
}
//--------------------------------------------------------------
void ofQtVideoSaver::setCodecType( int chosenCodec ){
initializeQuicktime();
OSStatus error = noErr;
CodecNameSpecListPtr list;
CodecNameSpec * codecNameSpecPtr;
char typeName[32];
error = GetCodecNameList( &list, 0 );
if ( error ) return;
int numCodecs = list->count;
codecNameSpecPtr = (CodecNameSpec *)((short *)list + 1);
for (int i = 0; i < numCodecs; i++ ){
if (i == chosenCodec){
p2cstrcpy( typeName, codecNameSpecPtr->typeName );
printf("trying to set codec type to (%s) \n", typeName);
codecType = codecNameSpecPtr->cType;
}
codecNameSpecPtr++;
}
}
/* 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;
}
struct servent *getservent(void)
{
static int preferedProto = 0;
OSStatus err;
long len;
ICAttr attr;
ICServices *buf;
ICServiceEntry tmpICSvc; /* We use this to store an aligned copy of *curSvc. */
static ICServiceEntry *curICSvc = NULL;
static struct servent svc = {NULL, NULL, 0, NULL};
ncbi_ClearErrno();
// Deallocate the last service name we returned.
if (svc.s_name!=NULL)
{
free(svc.s_name);
svc.s_name=NULL;
}
// If we haven't loaded the service table, load it now.
if (gServices==NULL)
{
err=ICStart(&gConfig, 'Sock');
if (err) {
ncbi_SetOTErrno(err);
return NULL;
}
#if !TARGET_API_MAC_CARBON
// Need to #ifdef this out for Carbon builds
err=ICFindConfigFile(gConfig, 0, nil);
if (err) {
ncbi_SetOTErrno(err);
return NULL;
}
// End of #ifdef for Carbon
#endif
len = 0;
err = ICGetPref(gConfig, kICServices, &attr, NULL, &len);
if (err) {
ncbi_SetOTErrno(err);
return NULL;
}
buf=(ICServices*)NewPtr(len);
if (buf==NULL || MemError()!=noErr) {
ncbi_SetOTErrno(MemError());
return NULL;
}
err=ICGetPref(gConfig, kICServices, &attr, (char*)buf, &len);
if (err){
ncbi_SetOTErrno(err);
return NULL;
}
gServices=buf;
curICSvc=&gServices->services[0];
gServiceIndex=0;
}
/* If we are out of entries, return NULL. */
if (curICSvc==NULL || gServiceIndex>=gServices->count) return NULL;
/* gServices is "packed", which means we cannot directly index gServices->services.
* So, we have to manually increment the current record pointer. We also have to
* memmove any numbers into an aligned variable, because entries in gServices are
* not guaranteed to be on whatever boundary the current processor prefers.
*/
/* Make an aligned copy of *curICSvc */
memmove(tmpICSvc.name, curICSvc, ((char*)curICSvc)[0]+1);
memmove(&tmpICSvc.port, (char*)curICSvc+((char*)curICSvc)[0]+1, 2);
memmove(&tmpICSvc.flags, (char*)curICSvc+((char*)curICSvc)[0]+3, 2);
/* Put together a servent based on the current service table entry. */
len = tmpICSvc.name[0]+1;
svc.s_name = malloc(len);
if (svc.s_name == NULL) {
ncbi_SetOTErrno(memFullErr);
return NULL;
}
//memmove(svc.s_name, tmpICSvc.name, len);
//p2cstr((StringPtr)svc.s_name);
p2cstrcpy(svc.s_name, tmpICSvc.name);
svc.s_aliases=(char**)¬_an_alias;
svc.s_port=tmpICSvc.port;
switch(preferedProto){
case 0:
switch(tmpICSvc.flags){
case 0:
svc.s_proto=(char*)prot_none;
break;
case kICServicesUDPMask:
svc.s_proto=(char*)prot_udp;
break;
case kICServicesTCPMask:
svc.s_proto=(char*)prot_tcp;
break;
case 3:
svc.s_proto=(char*)prot_udp;
preferedProto=kICServicesTCPMask;
break;
}
break;
case kICServicesUDPMask:
svc.s_proto=(char*)prot_udp;
preferedProto=0;
break;
case kICServicesTCPMask:
svc.s_proto=(char*)prot_tcp;
preferedProto=0;
break;
default:
// Assert_(0); /* We have set a preferedProto that we don't support. */
break;
}
if (preferedProto==0){
if ((++gServiceIndex)<gServices->count){
/* Cast gCurrentService to char* so we can play pointer arithmetic games in
* byte-sized increments. The 5 is the length byte plus two 2-byte ints.
*/
curICSvc=(ICServiceEntry*)((char*)curICSvc+((char*)curICSvc)[0]+5);
}
else {
curICSvc=NULL;
}
}
return &svc;
}
