C++ (Cpp) printErrCode Exemples

Exemple #1

Fichier : otMacAudioStream.cpp Projet : GYGit/oneteam

OSStatus
otMacAudioInputStream::InputReadyCb(void *userdata, AudioUnitRenderActionFlags *actionFlags,
                                    const AudioTimeStamp *timeStamp, UInt32 busNumber,
                                    UInt32 numberFrames, AudioBufferList *data)
{
  otMacAudioInputStream *_this = (otMacAudioInputStream*)userdata;
  OSStatus err;
  DEBUG_DUMP2("InputReadyCb numberFrames = %d, frameEnd = %d", numberFrames, _this->mFrameEnd);

  err = AudioUnitRender(_this->mAudioUnit, actionFlags, timeStamp, busNumber,
                        numberFrames, _this->mBuffer);
  if (err == noErr) {
    UInt32 bytes = _this->mBuffer->mBuffers[0].mDataByteSize;
    char *data = (char*) _this->mBuffer->mBuffers[0].mData;

    while (bytes > 0) {
      PRUint32 len = PR_MIN(_this->mInputFrameSize - _this->mFrameEnd, bytes);
      memcpy(_this->mFrame + _this->mFrameEnd, data, len);

  DEBUG_DUMP_N(("InputReadyCbInt bytes = %d frameEnd = %d, inputFrameSize = %d, frameSize = %d", bytes, _this->mFrameEnd, _this->mInputFrameSize, _this->mFrameSize));

      data += len;
      bytes -= len;
      _this->mFrameEnd += len;

      if (_this->mFrameEnd < _this->mInputFrameSize)
        break;

      UInt32 frameSize = _this->mFrameSize/2;

      err = AudioConverterFillComplexBuffer(_this->mConverter,
                                            &ConverterCb, _this, &frameSize,
                                            _this->mConvertBuffer, NULL);
      if (err != noErr) {
        printErrCode(err);
        return err;
      }

      DEBUG_DUMP("SendFrame");

      char *data2 = (char*)_this->mConvertBuffer->mBuffers[0].mData;

      _this->mFilter->InputData(data2, _this->mFrameSize);
      if (_this->mTarget)
        _this->mTarget->AcceptData(data2, _this->mFrameSize);

      //_this->mFrameEnd = 0;
    }
  } else {
    printErrCode(err);
  }

  return noErr;
}

Exemple #2

Fichier : com_igmp.c Projet : Alkorin/ngadmin

int do_igmp_set (int argc, const char **argv, struct ngadmin *nga)
{
	int i;
	struct igmp_conf ic;
	
	
	if (argc != 4) {
		printf("usage: igmp set <enable> <vlan> <validate> <block>\n");
		return 1;
	}
	
	if (ngadmin_getCurrentSwitch(nga) == NULL) {
		printf("must be logged\n");
		return 1;
	}
	
	ic.enable = strtol(argv[0], NULL, 0);
	ic.vlan = strtol(argv[1], NULL, 0);
	ic.validate = strtol(argv[2], NULL, 0);
	ic.block = strtol(argv[3], NULL, 0);
	
	i = ngadmin_setIGMPConf(nga, &ic);
	printErrCode(i);
	
	
	return 0;
}

Exemple #3

Fichier : com_login.c Projet : Alkorin/ngadmin

int do_login (int argc, const char **argv, struct ngadmin *nga)
{
	int i;
	
	
	if (argc != 1) {
		printf("usage: login <num>\n");
		return 1;
	}
	
	i = strtol(argv[0], NULL, 0);
	i = ngadmin_login(nga, i);
	printErrCode(i);
	
	
	return 0;
}

Exemple #4

Fichier : otMacAudioStream.cpp Projet : GYGit/oneteam

nsresult
otMacAudioStreamBase::CreateUnit(PRBool forInput, PRUint32 sampleRate,
                                 PRUint16 channels, PRUint32 frameSize,
                                 AURenderCallback cb, void *userdata)
{
  Component component;
  ComponentDescription description;
  UInt32 param, internalFrameSize;
  AudioDeviceID deviceID;
  AURenderCallbackStruct callback;
  AudioStreamBasicDescription dataFormat, inputFormat;
  OSStatus err;

  description.componentType = kAudioUnitType_Output;
  description.componentSubType = kAudioUnitSubType_HALOutput;
  description.componentManufacturer = kAudioUnitManufacturer_Apple;
  description.componentFlags = 0;
  description.componentFlagsMask = 0;

  if (!(component = FindNextComponent(NULL, &description)) ||
      OpenAComponent(component, &mAudioUnit) != noErr)
    return NS_ERROR_OUT_OF_MEMORY;
  DEBUG_DUMP1("CU1 %d", forInput);

  param = forInput ? 1 : 0;
  if (AudioUnitSetProperty(mAudioUnit, kAudioOutputUnitProperty_EnableIO,
                           kAudioUnitScope_Input, 1, &param, sizeof(param)) != noErr)
    return NS_ERROR_OUT_OF_MEMORY;
  DEBUG_DUMP1("CU2 %d", forInput);

  param = forInput ? 0 : 1;
  if (AudioUnitSetProperty(mAudioUnit, kAudioOutputUnitProperty_EnableIO,
                           kAudioUnitScope_Output, 0, &param, sizeof(param)) != noErr)
    return NS_ERROR_OUT_OF_MEMORY;
  DEBUG_DUMP1("CU3 %d", forInput);

  param = sizeof(deviceID);
  if (forInput)
    err = AudioHardwareGetProperty(kAudioHardwarePropertyDefaultInputDevice,
                                   &param, &deviceID);
  else
    err = AudioHardwareGetProperty(kAudioHardwarePropertyDefaultOutputDevice,
                                   &param, &deviceID);

  if (err != noErr)
    return NS_ERROR_OUT_OF_MEMORY;
  DEBUG_DUMP1("CU4 %d", forInput);

  if (AudioUnitSetProperty(mAudioUnit, kAudioOutputUnitProperty_CurrentDevice,
                           kAudioUnitScope_Global, 0, &deviceID,
                           sizeof(deviceID)) != noErr)
    return NS_ERROR_OUT_OF_MEMORY;
  DEBUG_DUMP1("CU5 %d", forInput);

  callback.inputProc = cb;
  callback.inputProcRefCon = userdata;

  if (forInput)
    err = AudioUnitSetProperty(mAudioUnit, kAudioOutputUnitProperty_SetInputCallback,
                               kAudioUnitScope_Global, 0, &callback, sizeof(callback));
  else
    err = AudioUnitSetProperty(mAudioUnit, kAudioUnitProperty_SetRenderCallback,
                               kAudioUnitScope_Input, 0, &callback, sizeof(callback));

  if (err != noErr)
    return NS_ERROR_OUT_OF_MEMORY;
  DEBUG_DUMP1("CU6 %d", forInput);

  memset(&dataFormat, 0, sizeof(dataFormat));

  dataFormat.mFormatID = kAudioFormatLinearPCM;
  dataFormat.mChannelsPerFrame = channels;
  dataFormat.mSampleRate = sampleRate;
  dataFormat.mFormatFlags = kLinearPCMFormatFlagIsSignedInteger | kAudioFormatFlagIsPacked;
#if __BIG_ENDIAN__
  dataFormat.mFormatFlags |= kAudioFormatFlagIsBigEndian;
#endif
  dataFormat.mBitsPerChannel = 16;
  dataFormat.mBytesPerFrame = 2*dataFormat.mChannelsPerFrame;
  dataFormat.mFramesPerPacket = 1;
  dataFormat.mBytesPerPacket = dataFormat.mFramesPerPacket*dataFormat.mBytesPerFrame;

  if (forInput) {
    param = sizeof(inputFormat);
    if (AudioUnitGetProperty(mAudioUnit, kAudioUnitProperty_StreamFormat,
                             kAudioUnitScope_Output, 1, &inputFormat, &param) != noErr)
      return NS_ERROR_OUT_OF_MEMORY;
    DEBUG_DUMP1("CU6.1 %d", forInput);

    inputFormat.mChannelsPerFrame = channels;
    inputFormat.mFormatID = kAudioFormatLinearPCM;
    inputFormat.mFormatFlags = kAudioFormatFlagIsFloat | kAudioFormatFlagIsPacked;
#if __BIG_ENDIAN__
    inputFormat.mFormatFlags |= kAudioFormatFlagIsBigEndian;
#endif
    inputFormat.mBitsPerChannel = sizeof(Float32) * 8;
    inputFormat.mBytesPerFrame = inputFormat.mBitsPerChannel / 8;
    inputFormat.mFramesPerPacket = 1;
    inputFormat.mBytesPerPacket = inputFormat.mBytesPerFrame;

    if (AudioConverterNew(&inputFormat, &dataFormat, &mConverter) != noErr)
      return NS_ERROR_OUT_OF_MEMORY;
    DEBUG_DUMP1("CU6.2 %d", forInput);

    err = AudioUnitSetProperty(mAudioUnit, kAudioUnitProperty_StreamFormat,
                               kAudioUnitScope_Output, 1, &inputFormat, sizeof(inputFormat));
  } else
    err = AudioUnitSetProperty(mAudioUnit, kAudioUnitProperty_StreamFormat,
                               kAudioUnitScope_Input, 0, &dataFormat, sizeof(dataFormat));

  if (err != noErr)
    return NS_ERROR_OUT_OF_MEMORY;
  DEBUG_DUMP1("CU7 %d", forInput);

  if (AudioUnitInitialize(mAudioUnit) != noErr)
    return NS_ERROR_OUT_OF_MEMORY;
  DEBUG_DUMP1("CU9 %d", forInput);

  if (forInput) {
    param = sizeof(internalFrameSize);
    if (AudioUnitGetProperty(mAudioUnit, kAudioDevicePropertyBufferFrameSize,
                             kAudioUnitScope_Global, 0, &internalFrameSize,
                             &param) != noErr)
      return NS_ERROR_OUT_OF_MEMORY;
  DEBUG_DUMP2("CU9.1 inSR=%f outSr=%f", inputFormat.mSampleRate, dataFormat.mSampleRate);
    internalFrameSize *= inputFormat.mBytesPerFrame;

    mBuffer = (AudioBufferList*)nsMemory::Alloc(sizeof(AudioBufferList) +
                                                channels * sizeof(AudioBuffer));
    if (!mBuffer)
      return NS_ERROR_OUT_OF_MEMORY;
  DEBUG_DUMP2("CU9.2 %d %d", forInput, internalFrameSize);

    mBuffer->mNumberBuffers = channels;
    for (int i = 0; i < channels; i++)
      mBuffer->mBuffers[i].mData = nsnull;

    for (int i = 0; i < channels; i++) {
      mBuffer->mBuffers[i].mNumberChannels = 1;
      mBuffer->mBuffers[i].mDataByteSize = internalFrameSize;
      mBuffer->mBuffers[i].mData = nsMemory::Alloc(internalFrameSize);
      if (!mBuffer->mBuffers[i].mData)
        return NS_ERROR_OUT_OF_MEMORY;
    }

    mInputFrameSize = ceil(frameSize*2*inputFormat.mSampleRate/sampleRate);

    mConvertBuffer = (AudioBufferList*)nsMemory::Alloc(sizeof(AudioBufferList) +
                                                       channels * sizeof(AudioBuffer));
    if (!mConvertBuffer)
      return NS_ERROR_OUT_OF_MEMORY;
  DEBUG_DUMP1("CU9.3 %d", forInput);

    mConvertBuffer->mNumberBuffers = channels;
    for (int i = 0; i < channels; i++)
      mConvertBuffer->mBuffers[i].mData = nsnull;

    for (int i = 0; i < channels; i++) {
      mConvertBuffer->mBuffers[i].mNumberChannels = 1;
      mConvertBuffer->mBuffers[i].mDataByteSize = frameSize;
      mConvertBuffer->mBuffers[i].mData = nsMemory::Alloc(frameSize);
      if (!mConvertBuffer->mBuffers[i].mData)
        return NS_ERROR_OUT_OF_MEMORY;
    }

    param = sizeof(mInputFrameSize);
    mInputFrameSize = frameSize;
    err = AudioConverterGetProperty(mConverter,
                                    kAudioConverterPropertyCalculateOutputBufferSize,
                                    &param, &mInputFrameSize);
  printErrCode(err);
  DEBUG_DUMP2("conversion %d -> %d", frameSize, mInputFrameSize);

  mInputFrameSize = frameSize;
    err = AudioConverterGetProperty(mConverter,
                                    kAudioConverterPropertyCalculateInputBufferSize,
                                    &param, &mInputFrameSize);
  printErrCode(err);
  DEBUG_DUMP2("conversion %d -> %d", frameSize, mInputFrameSize);
  }
  DEBUG_DUMP1("CU10 %d", forInput);

  return NS_OK;
}