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); }