PCast™ Express

import PhenixSdk
 
let pcastExpressOptions = PhenixPCastExpressFactory.createPCastExpressOptionsBuilder(unrecoverableErrorCallback: { status, errorDescription in
          // Best option is to try rebuilding the ChannelExpress instance and/or quit your app
    })
     .buildPCastExpressOptions()
 
 
let pcastExpress = PhenixPCastExpressFactory.createPCastExpress(pcastExpressOptions)

import PhenixSdk
 
let pcastExpress: PhenixPCastExpress = ...  // previously obtained
 
let userMediaConstraints = PhenixUserMediaOptions()
userMediaConstraints.video.enabled = true
userMediaConstraints.video.capabilityConstraints[PhenixDeviceCapability.facingMode.rawValue] =
    [PhenixDeviceConstraint.initWith(PhenixFacingMode.user)]
userMediaConstraints.audio.enabled = true
userMediaConstraints.audio.capabilityConstraints[PhenixDeviceCapability.audioEchoCancellationMode.rawValue] =
    [PhenixDeviceConstraint.initWith(PhenixAudioEchoCancellationMode.on)]
 
let publishOptions = PhenixPCastExpressFactory.createPublishOptionsBuilder()
    .withStreamToken("DIGEST:eyJhc...")
    .withMediaConstraints(userMediaConstraints)
    .buildPublishOptions()
 
pcastExpress.publish(publishOptions) { (status: PhenixRequestStatus, publisher: PhenixExpressPublisher?) in
  if status == .ok {
    // Do something with publisher
  } else {
    // Handle error
  }
}
 
 
// Create a publisher
let publishOptions = PhenixPCastExpressFactory.createPublishOptionsBuilder()
    .withStreamToken("DIGEST:eyJhc...")
    .withMediaConstraints(userMediaConstraints)
    .buildPublishOptions()
 
pcastExpress.publish(publishOptions) {
    (status: PhenixRequestStatus, publisher: PhenixExpressPublisher?) in
  if status == .ok {
    // Do something with publisher
  } else {
    // Handle error
  }
}

import PhenixSdk
 
let pcastExpress: PhenixPCastExpress = ...  // previously obtained
let renderLayer: CALayer = ...  // previously obtained
 
let subscribeOptions = PhenixPCastExpressFactory.createSubscribeOptionsBuilder()
    .withStreamId("us-west#us-west1-b.zzzzzzzz.20000000.xxxxxxxx")
    .withStreamToken("DIGEST:eyJhc...")
    .withRenderer(renderLayer)
    .buildSubscribeOptions()
 
pcastExpress.subscribe(subscribeOptions) { (status: PhenixRequestStatus, subscriber: PhenixExpressSubscriber?, renderer: PhenixRenderer?) in
  if status == .ok {
    // Do something with subscriber
 
    if let renderer = renderer {
      // Returned if `withRenderer...` option was enabled - Do something with renderer
    }
  } else {
    // Handle error
  }
}

import PhenixSdk
 
let monitorOptions = PhenixPCastExpressFactory.createMonitorOptionsBuilder().buildMonitorOptions();
 
let subscribeOptions = PhenixPCastExpressFactory.createSubscribeOptionsBuilder()
    .withStreamId("us-west#us-west1-b.zzzzzzzz.20000000.xxxxxxxx")
    .withStreamToken("DIGEST:eyJhc...")
    .withMonitor({ (status: PhenixRequestStatus, retry: PhenixOptionalAction?) in
          // Stream failed to setup, check if retry is a possibility:
          if let retry = retry, retry.isPresent() {
            if determineWhetherToRetry() {
              retry.perform()
            } else {
              // Not technically necessary, but here for clarity
              retry.dismiss()
            }
          }
        },
        { (reason: PhenixStreamEndedReason, description: String?, retry: PhenixOptionalAction?) in
          // Stream has ended, check if due to failure
          if let retry = retry, retry.isPresent() {
            if reason == .failed {
              retry.perform()
            } else {
              // Not technically necessary, but here for clarity
              retry.dismiss()
            }
          }
        },
        monitorOptions)
    .buildSubscribeOptions()

import PhenixSdk
 
let pcastExpress: PhenixPCastExpress = ...  // previously obtained
 
let userMediaOptions = PhenixUserMediaOptions()
 
pcastExpress.getUserMedia(userMediaOptions) { (status: PhenixRequestStatus, userMedia: PhenixUserMediaStream?) in
  if status == .ok {
    // Do something with user media stream
  } else {
    // Handle error
  }
}

import PhenixSdk
 
let pcastExpress: PhenixPCastExpress = ...  // previously obtained
 
let pcast = pcastExpress.pcast

import PhenixSdk
 
var disposable: PhenixDisposable = ...  // declare a property
 
self.disposable = pcastExpress.getObservableAuthenticationStatus().subscribe { [weak self] change in
  guard let self = self else { return }
  let status = PhenixAuthenticationStatus(rawValue: change!.value.intValue)!
 
  if PhenixAuthenticationStatus.unauthenticated == status {
    self.handleUnauthenticatedStatus()
  }
}

import PhenixSdk
 
func fetchANewAuthenticationToken(_ closure: @escaping (String) -> Void) {
  // This method calls a client backend to fetch a new authentication token generated using EdgeAuth library
  // and returns a fetched token using closure callback
}
 
func handleUnauthenticatedStatus() {
  fetchANewAuthenticationToken({ [weak self] token in
    guard let self = self else { return }
    // Set a new token to SDK
    let status = self.pcastExpress.setAuthenticationToken(token)
    if status != PhenixRequestStatus.ok {
      // Handle error when setting a new token
      // This situation can only occur if the token is invalid and cannot be processed by the SDK.
    }
  })
}

import PhenixSdk
 
let userMediaStream: PhenixUserMediaStream = ... // previously obtained
 
// Assume there is at least one video track:
let videoTrack = userMediaStream.mediaStream.getVideoTracks()[0]
 
// 1) Example showing how read incoming video frame and produce and outgoing one:
userMediaStream.setFrameReadyCallback(videoTrack) { (frameNotification: PhenixFrameNotification?) in
  frameNotification?.read { (inputFrame: CMSampleBuffer?) in
    let pixelBuffer: CVPixelBuffer = CMSampleBufferGetImageBuffer(inputFrame!)!
 
    // Process, manipulate pixel buffer
    // ...
 
    // Assume we generate an output CVPixelBuffer, which may or may not be based
    // on the incoming frame:
    let outputPixelBuffer: CVPixelBuffer = ...
 
    // Assemble an output frame using the same timestamps as the input sample buffer:
    let presentationTimeStamp = CMSampleBufferGetPresentationTimeStamp(inputFrame!)
    let duration = CMSampleBufferGetDuration(inputFrame!)
 
    var sampleTimingInfo = CMSampleTimingInfo.init(
        duration: duration,
        presentationTimeStamp: presentationTimeStamp,
        decodeTimeStamp: CMTime.invalid)
 
    var formatDescription: CMFormatDescription? = nil
    CMVideoFormatDescriptionCreateForImageBuffer(
        allocator: kCFAllocatorDefault,
        imageBuffer: outputPixelBuffer,
        formatDescriptionOut: &formatDescription)
 
    var outputFrame: CMSampleBuffer? = nil
    CMSampleBufferCreateReadyWithImageBuffer(
        allocator: kCFAllocatorDefault,
        imageBuffer: outputPixelBuffer,
        formatDescription: formatDescription!,
        sampleTiming: &sampleTimingInfo,
        sampleBufferOut: &outputFrame)
 
    frameNotification?.write(outputFrame)
  }
}
 
// 2) Example showing how we can just directly write output frames from a custom source without the need to
//    read the incoming frame:
userMediaStream.setFrameReadyCallback(videoTrack) { (frameNotification: PhenixFrameNotification?) in
  // Assume we have a custom source that is able to provide CMSampleBuffer:
  let outputFrame: CMSampleBuffer? = ...
 
  frameNotification?.write(outputFrame)
}
 
// 3) Example showing how we can stop frames from getting propagated by instructing the notification
//    to drop them:
userMediaStream.setFrameReadyCallback(videoTrack) { (frameNotification: PhenixFrameNotification?) in
  // We want to prevent frames from getting propagated further:
  frameNotification?.drop()
}
 
// 4) Example showing how to read and convert incoming frames to a specific pixel format:
userMediaStream.setFrameReadyCallback(videoTrack) { (frameNotification) in
  frameNotification?.read(with: .BGRA) { (inputFrame: CMSampleBuffer?) in
    let bgraPixelBuffer: CVPixelBuffer = CMSampleBufferGetImageBuffer(inputFrame!)!
 
    // ...
  }
}

import PhenixSdk
 
let userMediaStream: PhenixUserMediaStream = ... // previously obtained
 
// Assume there is at least one audio track:
let audioTrack = userMediaStream.mediaStream.getAudioTracks()[0]
 
// 1) Example showing how read incoming audio frame and produce and outgoing one:
userMediaStream.setFrameReadyCallback(audioTrack) { (frameNotification: PhenixFrameNotification?) in
  frameNotification?.read { (inputFrame: CMSampleBuffer?) in
    let blockBuffer = CMSampleBufferGetDataBuffer(inputFrame!)
 
    var totalLength = Int()
    var lengthAtOffset = Int()
    var dataPointer: UnsafeMutablePointer<Int8>? = nil
 
    guard CMBlockBufferGetDataPointer(
        blockBuffer!,
        atOffset: 0,
        lengthAtOffsetOut: &lengthAtOffset,
        totalLengthOut: &totalLength,
        dataPointerOut: &dataPointer) == kCMBlockBufferNoErr && lengthAtOffset == totalLength else {
      // Handle error, unexpected buffer length
      return
    }
 
    // Verify audio format:
    guard let formatDescription: CMAudioFormatDescription =
        CMSampleBufferGetFormatDescription(inputFrame!) else {
      return
    }
    guard let audioStreamBasicDescription =
        CMAudioFormatDescriptionGetStreamBasicDescription(formatDescription) else {
      return
    }
    guard (audioStreamBasicDescription.pointee.mFormatFlags & kAudioFormatFlagIsSignedInteger)
            == kAudioFormatFlagIsSignedInteger &&
          audioStreamBasicDescription.pointee.mBitsPerChannel == 16 else {
      return
    }
 
    // Raw samples are contained in `dataPointer` as Int16 values
    ...
 
    // Assume we generate an output CMBlockBuffer, which may or may not be based
    // on the incoming audio frame, and which as the same audio format and same
    // length as the incoming frame:
    let outputAudioBuffer: CMBlockBuffer = ...
 
    let presentationTimeStamp = CMSampleBufferGetPresentationTimeStamp(inputFrame!)
    let numberOfSamples =
        totalLength /
        Int(audioStreamBasicDescription.pointee.mChannelsPerFrame * audioStreamBasicDescription.pointee.mBitsPerChannel / 8)
 
    var outputFrame: CMSampleBuffer? = nil
    CMAudioSampleBufferCreateReadyWithPacketDescriptions(
        allocator: kCFAllocatorDefault,
        dataBuffer: outputAudioBuffer,
        formatDescription: formatDescription,
        sampleCount: numberOfSamples,
        presentationTimeStamp: presentationTimeStamp,
        packetDescriptions: nil,
        sampleBufferOut: &outputFrame)
 
    frameNotification?.write(outputFrame)
  }
}
 
// Other examples would look very similar to video

import PhenixSdk
 
let mediaStream: PhenixMediaStream = ... // previously obtained
let renderer: PhenixRenderer = ... // previously obtained
 
// Assume there is at least one video track:
let videoTrack = mediaStream.getVideoTracks()[0]
 
renderer.setFrameReadyCallback(videoTrack, ...
// Remainder of code identical to Publish Side

import PhenixSdk
 
let expressSubscriber: PhenixExpressSubscriber = ... // previously obtained
let renderer: PhenixRenderer = ... // previously obtained
 
// Assume there is at least one video track:
let videoTrack = expressSubscriber.getVideoTracks()[0]
 
renderer.setFrameReadyCallback(videoTrack, ...
// Remainder of code identical to Publish Side

import PhenixSdk
 
// Previously obtained
let publisher: PhenixPublisher = ...
 
// Limit video bitrate to 200kbps for 10 seconds
var disposable = publisher.limitBandwidth(200000)
 
DispatchQueue.main.asyncAfter(deadline: .now() + 10) {
  // Dropping the disposable will undo the bandwidth limitation
  disposable = nil
}

import PhenixSdk
 
// Previously obtained
let expressPublisher: PhenixExpressPublisher = ...
 
// Limit video bitrate to 200kbps for 10 seconds
var disposable = expressPublisher.limitBandwidth(200000)
 
DispatchQueue.main.asyncAfter(deadline: .now() + 10) {
  // Dropping the disposable will undo the bandwidth limitation
  disposable = nil
}

import PhenixSdk
 
// Previously obtained
let subscriber: PhenixMediaStream = ...
 
// Limit video bitrate to 200kbps for 10 seconds
// We assume there is at least one video track on this stream
var disposable = subscriber.getVideoTracks()[0].limitBandwidth(200000)
 
DispatchQueue.main.asyncAfter(deadline: .now() + 10) {
  // Dropping the disposable will undo the bandwidth limitation
  disposable = nil
}

import PhenixSdk
 
// Previously obtained
let subscriber: PhenixExpressSubscriber = ...
 
// Limit video bitrate to 200kbps for 10 seconds
// We assume there is at least one video track on this stream
var disposable = subscriber.getVideoTracks()[0].limitBandwidth(200000)
 
DispatchQueue.main.asyncAfter(deadline: .now() + 10) {
  // Dropping the disposable will undo the bandwidth limitation
  disposable = nil
}