PCast™ Express

1import PhenixSdk
2
3let pcastExpressOptions = PhenixPCastExpressFactory.createPCastExpressOptionsBuilder()
4    .withBackendUri("https://example.yourdomain.com/phenix/")
5    .buildPCastExpressOptions()
6
7let pcastExpress = PhenixPCastExpressFactory.createPCastExpress(pcastExpressOptions)

1import PhenixSdk
2
3let pcastExpress: PhenixPCastExpress = ...  // previously obtained
4
5let userMediaConstraints = PhenixUserMediaOptions()
6userMediaConstraints.video.enabled = true
7userMediaConstraints.video.capabilityConstraints[PhenixDeviceCapability.facingMode.rawValue] =
8    [PhenixDeviceConstraint.initWith(PhenixFacingMode.user)]
9userMediaConstraints.audio.enabled = true
10userMediaConstraints.audio.capabilityConstraints[PhenixDeviceCapability.audioEchoCancelationMode.rawValue] =
11    [PhenixDeviceConstraint.initWith(PhenixAudioEchoCancelationMode.on)]
12
13let publishOptions = PhenixPCastExpressFactory.createPublishOptionsBuilder()
14    .withCapabilities(["real-time"])
15    .withMediaConstraints(userMediaConstraints)
16    .buildPublishOptions()
17
18pcastExpress.publish(publishOptions) { (status: PhenixRequestStatus, publisher: PhenixExpressPublisher?) in
19  if status == .ok {
20    // Do something with publisher
21  } else {
22    // Handle error
23  }
24}
25
26
27// Create a publisher with an automatically started preview renderer
28let renderLayer: CALayer = ...  // previously obtained
29let publishOptionsWithPreview = PhenixPCastExpressFactory.createPublishOptionsBuilder()
30    .withCapabilities(["real-time"])
31    .withMediaConstraints(userMediaConstraints)
32    .withPreviewRenderer(renderLayer)
33    .buildPublishOptions()
34
35pcastExpress.publish(withPreview: publishOptionsWithPreview) {
36    (status: PhenixRequestStatus, publisher: PhenixExpressPublisher?, preview: PhenixRenderer?) in
37  if status == .ok {
38    // Do something with publisher and preview renderer
39  } else {
40    // Handle error
41  }
42}

1import PhenixSdk
2
3let pcastExpress: PhenixPCastExpress = ...  // previously obtained
4
5let publishRemoteOptions = PhenixPCastExpressFactory.createPublishRemoteOptionsBuilder()
6    .withStreamUri("http://mycdn.example.com/mystream.mp4")
7    .withCapabilities([""])
8    .buildPublishRemoteOptions()
9
10pcastExpress.publishRemote(publishRemoteOptions) { (status: PhenixRequestStatus, publisher: PhenixExpressPublisher?) in
11  if status == .ok {
12    // Do something with publisher
13  } else {
14    // Handle error
15  }
16}

1import PhenixSdk
2
3let pcastExpress: PhenixPCastExpress = ...  // previously obtained
4let renderLayer: CALayer = ...  // previously obtained
5
6let subscribeOptions = PhenixPCastExpressFactory.createSubscribeOptionsBuilder()
7    .withStreamId("us-west#us-west1-b.zzzzzzzz.20000000.xxxxxxxx")
8    .withCapabilities(["real-time"])
9    .withRenderer(renderLayer)
10    .buildSubscribeOptions()
11
12pcastExpress.subscribe(subscribeOptions) { (status: PhenixRequestStatus, subscriber: PhenixExpressSubscriber?, renderer: PhenixRenderer?) in
13  if status == .ok {
14    // Do something with subscriber
15
16    if let renderer = renderer {
17      // Returned if `withRenderer...` option was enabled - Do something with renderer
18    }
19  } else {
20    // Handle error
21  }
22}

1import PhenixSdk
2
3let monitorOptions = PhenixPCastExpressFactory.createMonitorOptionsBuilder().buildMonitorOptions();
4
5let subscribeOptions = PhenixPCastExpressFactory.createSubscribeOptionsBuilder()
6    .withStreamId("us-west#us-west1-b.zzzzzzzz.20000000.xxxxxxxx")
7    .withCapabilities(["real-time"])
8    .withMonitor({ (status: PhenixRequestStatus, retry: PhenixOptionalAction?) in
9          // Stream failed to setup, check if retry is a possibility:
10          if let retry = retry, retry.isPresent() {
11            if determineWhetherToRetry() {
12              retry.perform()
13            } else {
14              // Not technically necessary, but here for clarity
15              retry.dismiss()
16            }
17          }
18        },
19        { (reason: PhenixStreamEndedReason, description: String?, retry: PhenixOptionalAction?) in
20          // Stream has ended, check if due to failure
21          if let retry = retry, retry.isPresent() {
22            if reason == .failed {
23              retry.perform()
24            } else {
25              // Not technically necessary, but here for clarity
26              retry.dismiss()
27            }
28          }
29        },
30        monitorOptions)
31    .buildSubscribeOptions()

1import PhenixSdk
2
3let pcastExpress: PhenixPCastExpress = ...  // previously obtained
4
5let userMediaOptions = PhenixUserMediaOptions()
6
7pcastExpress.getUserMedia(userMediaOptions) { (status: PhenixRequestStatus, userMedia: PhenixUserMediaStream?) in
8  if status == .ok {
9    // Do something with user media stream
10  } else {
11    // Handle error
12  }
13}

1import PhenixSdk
2
3let pcastExpress: PhenixPCastExpress = ...  // previously obtained
4
5let pcast = pcastExpress.pcast

1import PhenixSdk
2
3let userMediaStream: PhenixUserMediaStream = ... // previously obtained
4
5// Assume there is at least one video track:
6let videoTrack = userMediaStream.mediaStream.getVideoTracks()[0]
7
8// 1) Example showing how read incoming video frame and produce and outgoing one:
9userMediaStream.setFrameReadyCallback(videoTrack) { (frameNotification: PhenixFrameNotification?) in
10  frameNotification?.read { (inputFrame: CMSampleBuffer?) in
11    let pixelBuffer: CVPixelBuffer = CMSampleBufferGetImageBuffer(inputFrame!)!
12
13    // Process, manipulate pixel buffer
14    // ...
15
16    // Assume we generate an output CVPixelBuffer, which may or may not be based
17    // on the incoming frame:
18    let outputPixelBuffer: CVPixelBuffer = ...
19
20    // Assemble an output frame using the same timestamps as the input sample buffer:
21    let presentationTimeStamp = CMSampleBufferGetPresentationTimeStamp(inputFrame!)
22    let duration = CMSampleBufferGetDuration(inputFrame!)
23
24    var sampleTimingInfo = CMSampleTimingInfo.init(
25        duration: duration,
26        presentationTimeStamp: presentationTimeStamp,
27        decodeTimeStamp: CMTime.invalid)
28
29    var formatDescription: CMFormatDescription? = nil
30    CMVideoFormatDescriptionCreateForImageBuffer(
31        allocator: kCFAllocatorDefault,
32        imageBuffer: outputPixelBuffer,
33        formatDescriptionOut: &formatDescription)
34
35    var outputFrame: CMSampleBuffer? = nil
36    CMSampleBufferCreateReadyWithImageBuffer(
37        allocator: kCFAllocatorDefault,
38        imageBuffer: outputPixelBuffer,
39        formatDescription: formatDescription!,
40        sampleTiming: &sampleTimingInfo,
41        sampleBufferOut: &outputFrame)
42
43    frameNotification?.write(outputFrame)
44  }
45}
46
47// 2) Example showing how we can just directly write output frames from a custom source without the need to
48//    read the incoming frame:
49userMediaStream.setFrameReadyCallback(videoTrack) { (frameNotification: PhenixFrameNotification?) in
50  // Assume we have a custom source that is able to provide CMSampleBuffer:
51  let outputFrame: CMSampleBuffer? = ...
52
53  frameNotification?.write(outputFrame)
54}
55
56// 3) Example showing how we can stop frames from getting propagated by instructing the notification
57//    to drop them:
58userMediaStream.setFrameReadyCallback(videoTrack) { (frameNotification: PhenixFrameNotification?) in
59  // We want to prevent frames from getting propagated further:
60  frameNotification?.drop()
61}
62
63// 4) Example showing how to read and convert incoming frames to a specific pixel format:
64userMediaStream.setFrameReadyCallback(videoTrack) { (frameNotification) in
65  frameNotification?.read(with: .BGRA) { (inputFrame: CMSampleBuffer?) in
66    let bgraPixelBuffer: CVPixelBuffer = CMSampleBufferGetImageBuffer(inputFrame!)!
67
68    // ...
69  }
70}

1import PhenixSdk
2
3let userMediaStream: PhenixUserMediaStream = ... // previously obtained
4
5// Assume there is at least one audio track:
6let audioTrack = userMediaStream.mediaStream.getAudioTracks()[0]
7
8// 1) Example showing how read incoming audio frame and produce and outgoing one:
9userMediaStream.setFrameReadyCallback(audioTrack) { (frameNotification: PhenixFrameNotification?) in
10  frameNotification?.read { (inputFrame: CMSampleBuffer?) in
11    let blockBuffer = CMSampleBufferGetDataBuffer(inputFrame!)
12
13    var totalLength = Int()
14    var lengthAtOffset = Int()
15    var dataPointer: UnsafeMutablePointer<Int8>? = nil
16
17    guard CMBlockBufferGetDataPointer(
18        blockBuffer!,
19        atOffset: 0,
20        lengthAtOffsetOut: &lengthAtOffset,
21        totalLengthOut: &totalLength,
22        dataPointerOut: &dataPointer) == kCMBlockBufferNoErr && lengthAtOffset == totalLength else {
23      // Handle error, unexpected buffer length
24      return
25    }
26
27    // Verify audio format:
28    guard let formatDescription: CMAudioFormatDescription =
29        CMSampleBufferGetFormatDescription(inputFrame!) else {
30      return
31    }
32    guard let audioStreamBasicDescription =
33        CMAudioFormatDescriptionGetStreamBasicDescription(formatDescription) else {
34      return
35    }
36    guard (audioStreamBasicDescription.pointee.mFormatFlags & kAudioFormatFlagIsSignedInteger)
37            == kAudioFormatFlagIsSignedInteger &&
38          audioStreamBasicDescription.pointee.mBitsPerChannel == 16 else {
39      return
40    }
41
42    // Raw samples are contained in `dataPointer` as Int16 values
43    ...
44
45    // Assume we generate an output CMBlockBuffer, which may or may not be based
46    // on the incoming audio frame, and which as the same audio format and same
47    // length as the incoming frame:
48    let outputAudioBuffer: CMBlockBuffer = ...
49
50    let presentationTimeStamp = CMSampleBufferGetPresentationTimeStamp(inputFrame!)
51    let numberOfSamples =
52        totalLength /
53        Int(audioStreamBasicDescription.pointee.mChannelsPerFrame * audioStreamBasicDescription.pointee.mBitsPerChannel / 8)
54
55    var outputFrame: CMSampleBuffer? = nil
56    CMAudioSampleBufferCreateReadyWithPacketDescriptions(
57        allocator: kCFAllocatorDefault,
58        dataBuffer: outputAudioBuffer,
59        formatDescription: formatDescription,
60        sampleCount: numberOfSamples,
61        presentationTimeStamp: presentationTimeStamp,
62        packetDescriptions: nil,
63        sampleBufferOut: &outputFrame)
64
65    frameNotification?.write(outputFrame)
66  }
67}
68
69// Other examples would look very similar to video

1import PhenixSdk
2
3let mediaStream: PhenixMediaStream = ... // previously obtained
4let renderer: PhenixRenderer = ... // previously obtained
5
6// Assume there is at least one video track:
7let videoTrack = mediaStream.getVideoTracks()[0]
8
9renderer.setFrameReadyCallback(videoTrack, ...
10// Remainder of code identical to Publish Side

1import PhenixSdk
2
3let expressSubscriber: PhenixExpressSubscriber = ... // previously obtained
4let renderer: PhenixRenderer = ... // previously obtained
5
6// Assume there is at least one video track:
7let videoTrack = expressSubscriber.getVideoTracks()[0]
8
9renderer.setFrameReadyCallback(videoTrack, ...
10// Remainder of code identical to Publish Side

1import PhenixSdk
2
3// Previously obtained
4let publisher: PhenixPublisher = ...
5
6// Limit video bitrate to 200kbps for 10 seconds
7var disposable = publisher.limitBandwidth(200000)
8
9DispatchQueue.main.asyncAfter(deadline: .now() + 10) {
10  // Dropping the disposable will undo the bandwidth limitation
11  disposable = nil
12}

1import PhenixSdk
2
3// Previously obtained
4let expressPublisher: PhenixExpressPublisher = ...
5
6// Limit video bitrate to 200kbps for 10 seconds
7var disposable = expressPublisher.limitBandwidth(200000)
8
9DispatchQueue.main.asyncAfter(deadline: .now() + 10) {
10  // Dropping the disposable will undo the bandwidth limitation
11  disposable = nil
12}

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

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