char *CAStringForOSType (OSType t, char *writeLocation, size_t bufsize)
{
if (bufsize > 0) {
char *p = writeLocation, *pend = writeLocation + bufsize;
union { UInt32 i; unsigned char str[4]; } u;
unsigned char *q = u.str;
u.i = CFSwapInt32HostToBig(t);
bool hasNonPrint = false;
for (int i = 0; i < 4; ++i) {
if (!(isprint(*q) && *q != '\\')) {
hasNonPrint = true;
break;
}
q++;
}
q = u.str;
if (hasNonPrint)
p += snprintf (p, pend - p, "0x");
else if (p < pend)
*p++ = '\'';
for (int i = 0; i < 4 && p < pend; ++i) {
if (hasNonPrint) {
p += snprintf(p, pend - p, "%02X", *q++);
} else {
*p++ = *q++;
}
}
if (!hasNonPrint && p < pend)
*p++ = '\'';
if (p >= pend) p -= 1;
*p = '\0';
}
return writeLocation;
}
void CAStreamBasicDescription::PrintFormat2(FILE *f, const char *indent, const char *name) const
{
fprintf(f, "%s%s ", indent, name);
char formatID[5];
*(UInt32 *)formatID = CFSwapInt32HostToBig(mFormatID);
formatID[4] = '\0';
fprintf(f, "%2d ch, %6.0f Hz, '%-4.4s' (0x%08X) ",
(int)NumberChannels(), mSampleRate, formatID,
(int)mFormatFlags);
if (mFormatID == kAudioFormatLinearPCM) {
bool isInt = !(mFormatFlags & kLinearPCMFormatFlagIsFloat);
int wordSize = SampleWordSize();
const char *endian = (wordSize > 1) ?
((mFormatFlags & kLinearPCMFormatFlagIsBigEndian) ? " big-endian" : " little-endian" ) : "";
const char *sign = isInt ?
((mFormatFlags & kLinearPCMFormatFlagIsSignedInteger) ? " signed" : " unsigned") : "";
const char *floatInt = isInt ? "integer" : "float";
char packed[32];
if (wordSize > 0 && PackednessIsSignificant()) {
if (mFormatFlags & kLinearPCMFormatFlagIsPacked)
sprintf(packed, "packed in %d bytes", wordSize);
else
sprintf(packed, "unpacked in %d bytes", wordSize);
} else
packed[0] = '\0';
const char *align = (wordSize > 0 && AlignmentIsSignificant()) ?
((mFormatFlags & kLinearPCMFormatFlagIsAlignedHigh) ? " high-aligned" : " low-aligned") : "";
const char *deinter = (mFormatFlags & kAudioFormatFlagIsNonInterleaved) ? ", deinterleaved" : "";
const char *commaSpace = (packed[0]!='\0') || (align[0]!='\0') ? ", " : "";
fprintf(f, "%d-bit%s%s %s%s%s%s%s",
(int)mBitsPerChannel, endian, sign, floatInt,
commaSpace, packed, align, deinter);
} else if (mFormatID == 'alac') { // kAudioFormatAppleLossless
int sourceBits = 0;
switch (mFormatFlags)
{
case 1: // kAppleLosslessFormatFlag_16BitSourceData
sourceBits = 16;
break;
case 2: // kAppleLosslessFormatFlag_20BitSourceData
sourceBits = 20;
break;
case 3: // kAppleLosslessFormatFlag_24BitSourceData
sourceBits = 24;
break;
case 4: // kAppleLosslessFormatFlag_32BitSourceData
sourceBits = 32;
break;
}
if (sourceBits)
fprintf(f, "from %d-bit source, ", sourceBits);
else
fprintf(f, "from UNKNOWN source bit depth, ");
fprintf(f, "%d frames/packet", (int)mFramesPerPacket);
}
else
fprintf(f, "%d bits/channel, %d bytes/packet, %d frames/packet, %d bytes/frame",
(int)mBitsPerChannel, (int)mBytesPerPacket, (int)mFramesPerPacket, (int)mBytesPerFrame);
}
/*! Helper function used throughout the login process to query the target.
* This function will take a dictionary of key-value pairs and send the
* appropriate login PDU to the target. It will then receive one or more
* login response PDUs from the target, parse them and return the key-value
* pairs received as a dictionary. If an error occurs, this function will
* return the C error code. If communications are successful but the iSCSI
* layer experiences errors, it will return an iSCSI error code, either in the
* form of a login status code or a PDU rejection code in addition to
* a standard C error code.
* @param context the context to query (session identifier, etc)
* @param statusCode the iSCSI status code returned by the target
* @param rejectCode the iSCSI reject code, if the command was rejected
* @param textCmd a dictionary of key-value pairs to send.
* @param textRsp a dictionary of key-value pairs to receive.
* @return an error code that indicates the result of the operation. */
errno_t iSCSISessionLoginQuery(struct iSCSILoginQueryContext * context,
enum iSCSILoginStatusCode * statusCode,
enum iSCSIRejectCode * rejectCode,
CFDictionaryRef textCmd,
CFMutableDictionaryRef textRsp)
{
// Create a new login request basic header segment
iSCSIPDULoginReqBHS cmd = iSCSIPDULoginReqBHSInit;
cmd.TSIH = CFSwapInt16HostToBig(context->targetSessionId);
cmd.CID = CFSwapInt32HostToBig(context->connectionId);
cmd.ISIDd = CFSwapInt16HostToBig(context->sessionId);
cmd.loginStage = (context->nextStage << kiSCSIPDULoginNSGBitOffset);
cmd.loginStage |= (context->currentStage << kiSCSIPDULoginCSGBitOffset);
// If stages aren't the same then we are going to transition
if(context->currentStage != context->nextStage)
cmd.loginStage |= kiSCSIPDULoginTransitFlag;
// Create a data segment based on text commands (key-value pairs)
void * data;
size_t length;
iSCSIPDUDataCreateFromDict(textCmd,&data,&length);
errno_t error = iSCSIKernelSend(context->sessionId,context->connectionId,
(iSCSIPDUInitiatorBHS *)&cmd,
data,length);
iSCSIPDUDataRelease(&data);
if(error) {
return error;
}
// Get response from iSCSI portal, continue until response is complete
iSCSIPDULoginRspBHS rsp;
do {
if((error = iSCSIKernelRecv(context->sessionId,context->connectionId,
(iSCSIPDUTargetBHS *)&rsp,&data,&length)))
{
iSCSIPDUDataRelease(&data);
return error;
}
if(rsp.opCode == kiSCSIPDUOpCodeLoginRsp)
{
// Per RFC3720, the status and detail together make up the code
// where the class is the high byte and the detail is the low
*statusCode = ((((UInt16)rsp.statusClass)<<8) | rsp.statusDetail);
if(*statusCode != kiSCSILoginSuccess) {
error = EINVAL;
break;
}
iSCSIPDUDataParseToDict(data,length,textRsp);
}
// For this case some other kind of PDU or invalid data was received
else if(rsp.opCode == kiSCSIPDUOpCodeReject)
{
error = EOPNOTSUPP;
break;
}
}
while(rsp.loginStage & kiSCSIPDUTextReqContinueFlag);
iSCSIPDUDataRelease(&data);
return error;
}
/* Convert an OSType value to a 4-char string object */
PyObject *AE_BuildOSType(OSType t)
{
uint32_t tmp = CFSwapInt32HostToBig((uint32_t)t);
return PyBytes_FromStringAndSize((char *)&tmp, 4);
}
void NumToStr (char* outStr, UInt32 inNum)
{
int num = CFSwapInt32HostToBig (inNum);
sprintf (outStr, "%4.4s", (char*)&(num));
}
bool
ScaledFontMac::GetFontFileData(FontFileDataOutput aDataCallback, void *aBaton)
{
// We'll reconstruct a TTF font from the tables we can get from the CGFont
CFArrayRef tags = CGFontCopyTableTags(mFont);
CFIndex count = CFArrayGetCount(tags);
TableRecord *records = new TableRecord[count];
uint32_t offset = 0;
offset += sizeof(uint32_t)*3;
offset += sizeof(uint32_t)*4*count;
bool CFF = false;
for (CFIndex i = 0; i<count; i++) {
uint32_t tag = (uint32_t)(uintptr_t)CFArrayGetValueAtIndex(tags, i);
if (tag == 0x43464620) // 'CFF '
CFF = true;
CFDataRef data = CGFontCopyTableForTag(mFont, tag);
records[i].tag = tag;
records[i].offset = offset;
records[i].data = data;
records[i].length = CFDataGetLength(data);
bool skipChecksumAdjust = (tag == 0x68656164); // 'head'
records[i].checkSum = CalcTableChecksum(reinterpret_cast<const uint32_t*>(CFDataGetBytePtr(data)),
records[i].length, skipChecksumAdjust);
offset += records[i].length;
// 32 bit align the tables
offset = (offset + 3) & ~3;
}
CFRelease(tags);
struct writeBuf buf(offset);
// write header/offset table
if (CFF) {
buf.writeElement(CFSwapInt32HostToBig(0x4f54544f));
} else {
buf.writeElement(CFSwapInt32HostToBig(0x00010000));
}
buf.writeElement(CFSwapInt16HostToBig(count));
buf.writeElement(CFSwapInt16HostToBig((1<<maxPow2LessThan(count))*16));
buf.writeElement(CFSwapInt16HostToBig(maxPow2LessThan(count)));
buf.writeElement(CFSwapInt16HostToBig(count*16-((1<<maxPow2LessThan(count))*16)));
// write table record entries
for (CFIndex i = 0; i<count; i++) {
buf.writeElement(CFSwapInt32HostToBig(records[i].tag));
buf.writeElement(CFSwapInt32HostToBig(records[i].checkSum));
buf.writeElement(CFSwapInt32HostToBig(records[i].offset));
buf.writeElement(CFSwapInt32HostToBig(records[i].length));
}
// write tables
int checkSumAdjustmentOffset = 0;
for (CFIndex i = 0; i<count; i++) {
if (records[i].tag == 0x68656164) {
checkSumAdjustmentOffset = buf.offset + 2*4;
}
buf.writeMem(CFDataGetBytePtr(records[i].data), CFDataGetLength(records[i].data));
buf.align();
CFRelease(records[i].data);
}
delete[] records;
// clear the checksumAdjust field before checksumming the whole font
memset(&buf.data[checkSumAdjustmentOffset], 0, sizeof(uint32_t));
uint32_t fontChecksum = CFSwapInt32HostToBig(0xb1b0afba - CalcTableChecksum(reinterpret_cast<const uint32_t*>(buf.data), offset));
// set checkSumAdjust to the computed checksum
memcpy(&buf.data[checkSumAdjustmentOffset], &fontChecksum, sizeof(fontChecksum));
// we always use an index of 0
aDataCallback(buf.data, buf.offset, 0, mSize, aBaton);
return true;
}
// generic error handler - if err is nonzero, prints error message and exits program.
void CheckError(OSStatus error, const char *operation) {
if (error == noErr) return;
char str[20];
// see if it appears to be a 4-char-code
*(UInt32 *)(str + 1) = CFSwapInt32HostToBig(error);
if (isprint(str[1]) && isprint(str[2]) && isprint(str[3]) && isprint(str[4])) {
str[0] = str[5] = '\'';
str[6] = '\0';
} else {
// no, format it as an integer
sprintf(str, "%d", (int)error);
}
fprintf(stderr, "Error: %s (%s)\n", operation, str);
// from Audio Unit Processing Graph Services Reference
switch(error) {
case kAUGraphErr_NodeNotFound:
fprintf(stderr, "Error:kAUGraphErr_NodeNotFound \n");
break;
case kAUGraphErr_OutputNodeErr:
fprintf(stderr, "Error:kAUGraphErr_OutputNodeErr \n");
break;
case kAUGraphErr_InvalidConnection:
fprintf(stderr, "Error:kAUGraphErr_InvalidConnection \n");
break;
case kAUGraphErr_CannotDoInCurrentContext:
fprintf(stderr, "Error:kAUGraphErr_CannotDoInCurrentContext \n");
break;
case kAUGraphErr_InvalidAudioUnit:
fprintf(stderr, "Error:kAUGraphErr_InvalidAudioUnit \n");
break;
case kMIDIInvalidClient :
fprintf(stderr, "kMIDIInvalidClient ");
break;
case kMIDIInvalidPort :
fprintf(stderr, "kMIDIInvalidPort ");
break;
case kMIDIWrongEndpointType :
fprintf(stderr, "kMIDIWrongEndpointType");
break;
case kMIDINoConnection :
fprintf(stderr, "kMIDINoConnection ");
break;
case kMIDIUnknownEndpoint :
fprintf(stderr, "kMIDIUnknownEndpoint ");
break;
case kMIDIUnknownProperty :
fprintf(stderr, "kMIDIUnknownProperty ");
break;
case kMIDIWrongPropertyType :
fprintf(stderr, "kMIDIWrongPropertyType ");
break;
case kMIDINoCurrentSetup :
fprintf(stderr, "kMIDINoCurrentSetup ");
break;
case kMIDIMessageSendErr :
fprintf(stderr, "kMIDIMessageSendErr ");
break;
case kMIDIServerStartErr :
fprintf(stderr, "kMIDIServerStartErr ");
break;
case kMIDISetupFormatErr :
fprintf(stderr, "kMIDISetupFormatErr ");
break;
case kMIDIWrongThread :
fprintf(stderr, "kMIDIWrongThread ");
break;
case kMIDIObjectNotFound :
fprintf(stderr, "kMIDIObjectNotFound ");
break;
case kMIDIIDNotUnique :
fprintf(stderr, "kMIDIIDNotUnique ");
break;
case kAudioToolboxErr_InvalidSequenceType :
fprintf(stderr, " kAudioToolboxErr_InvalidSequenceType ");
break;
case kAudioToolboxErr_TrackIndexError :
fprintf(stderr, " kAudioToolboxErr_TrackIndexError ");
break;
case kAudioToolboxErr_TrackNotFound :
fprintf(stderr, " kAudioToolboxErr_TrackNotFound ");
break;
case kAudioToolboxErr_EndOfTrack :
fprintf(stderr, " kAudioToolboxErr_EndOfTrack ");
break;
case kAudioToolboxErr_StartOfTrack :
fprintf(stderr, " kAudioToolboxErr_StartOfTrack ");
break;
case kAudioToolboxErr_IllegalTrackDestination :
fprintf(stderr, " kAudioToolboxErr_IllegalTrackDestination");
break;
case kAudioToolboxErr_NoSequence :
fprintf(stderr, " kAudioToolboxErr_NoSequence ");
break;
case kAudioToolboxErr_InvalidEventType :
fprintf(stderr, " kAudioToolboxErr_InvalidEventType");
break;
case kAudioToolboxErr_InvalidPlayerState :
fprintf(stderr, " kAudioToolboxErr_InvalidPlayerState");
break;
// case kAudioToolboxErr_CannotDoInCurrentContext :
// fprintf(stderr, " kAudioToolboxErr_CannotDoInCurrentContext");
// break;
case kAudioUnitErr_InvalidProperty :
fprintf(stderr, " kAudioUnitErr_InvalidProperty");
break;
case kAudioUnitErr_InvalidParameter :
fprintf(stderr, " kAudioUnitErr_InvalidParameter");
break;
case kAudioUnitErr_InvalidElement :
fprintf(stderr, " kAudioUnitErr_InvalidElement");
break;
case kAudioUnitErr_NoConnection :
fprintf(stderr, " kAudioUnitErr_NoConnection");
break;
case kAudioUnitErr_FailedInitialization :
fprintf(stderr, " kAudioUnitErr_FailedInitialization");
break;
case kAudioUnitErr_TooManyFramesToProcess :
fprintf(stderr, " kAudioUnitErr_TooManyFramesToProcess");
break;
case kAudioUnitErr_InvalidFile :
fprintf(stderr, " kAudioUnitErr_InvalidFile");
break;
case kAudioUnitErr_FormatNotSupported :
fprintf(stderr, " kAudioUnitErr_FormatNotSupported");
break;
case kAudioUnitErr_Uninitialized :
fprintf(stderr, " kAudioUnitErr_Uninitialized");
break;
case kAudioUnitErr_InvalidScope :
fprintf(stderr, " kAudioUnitErr_InvalidScope");
break;
case kAudioUnitErr_PropertyNotWritable :
fprintf(stderr, " kAudioUnitErr_PropertyNotWritable");
break;
case kAudioUnitErr_InvalidPropertyValue :
fprintf(stderr, " kAudioUnitErr_InvalidPropertyValue");
break;
case kAudioUnitErr_PropertyNotInUse :
fprintf(stderr, " kAudioUnitErr_PropertyNotInUse");
break;
case kAudioUnitErr_Initialized :
fprintf(stderr, " kAudioUnitErr_Initialized");
break;
case kAudioUnitErr_InvalidOfflineRender :
fprintf(stderr, " kAudioUnitErr_InvalidOfflineRender");
break;
case kAudioUnitErr_Unauthorized :
fprintf(stderr, " kAudioUnitErr_Unauthorized");
break;
}
exit(1);
}
