Overzicht

Met de Camo SDK van Reincubate kun je realtime audiovisuele data vanuit je applicatie naar Camo Studio op macOS en Windows sturen. Dit werkt via USB of draadloos. USB is geoptimaliseerd voor lage latentie en prestaties, en verbruikt zo min mogelijk bronnen in je app. Draadloos geeft je vrijheid zonder kabels.

De Camo SDK is beschikbaar voor gebruik door commerciële partners en samenwerkingspartners. Neem voor meer informatie contact op met je team via enterprise@reincubate.com.

Op dit moment ondersteunt de SDK alleen iOS-applicaties die draaien op een fysiek iOS- of iPadOS-apparaat (simulators en Mac Catalyst uitgezonderd) met iOS 12 of hoger. De Camo SDK heeft standaard geen Objective-C-compatibiliteit, dus als je app voornamelijk in Objective-C is geschreven, moet je mogelijk een wrapper maken.

API-referentie

Wil je er meteen induiken, dan kun je de volledige API-referentie bekijken, waarin elk symbool van de Camo SDK wordt gedocumenteerd. Anders neemt dit document je mee door een voorbeeldintegratie met de SDK.

De Camo SDK installeren

Wanneer je de Camo SDK ontvangt, krijg je ook een bestand met de naam CamoProducerKit.xcframework. Dit op zichzelf staande framework bevat alles wat je nodig hebt, zonder externe afhankelijkheden, waardoor de installatie eenvoudig is.

Selecteer het project van je applicatie in de Project Navigator.
Kies het target van je applicatie in de targetzijbalk van het project. Zie je geen zijbalk, dan vind je deze mogelijk in een vervolgkeuzemenu bovenaan de pagina.
Zorg dat je op het tabblad „General” staat en scroll naar beneden naar de kop „Frameworks, Libraries, and Embedded Content”.
Sleep het CamoProducerKit.xcframework-bestand en zet het neer in de bestandslijst onder die kop.
Zorg dat de SDK is ingesteld op „Embed & Sign”.

Als je klaar bent, zou je het framework moeten zien zoals afgebeeld:

Camo SDK ingesloten in een voorbeeldapplicatie

Integreren met je app

De Camo-service beheren

In de kern van CamoProducerKit staat de CamoController, die je app één centrale interface biedt voor het besturen van de Camo SDK.

In je app initialiseer je een instantie van de CamoController. Je kunt dit doen bij het opstarten van de app, of dit voor later bewaren. Totdat deze expliciet wordt gestart met start(), gebruikt de Camo-controller zeer weinig bronnen. Bij initialisatie bereidt deze zich echter al voor op audio- en video-encoding.

import CamoProducerKit

class MyVideoManager {
    let controller = CamoController()

    // ...
}

Wanneer je de Camo-integratie in je app wilt activeren en de Camo-service wilt starten om verbindingen mogelijk te maken, roep je start() aan. Zodra je klaar bent, kun je deze stoppen door stop() aan te roepen.

controller.start()
// ...
controller.stop()

Deze code is een begin, maar kan nog geen nieuwe verbindingen van Camo Studio accepteren.

Reageren op nieuwe verbindingen

Voordat je app nieuwe verbindingen van Camo Studio kan accepteren, moet je de CamoControllerDelegate implementeren. Door deze twee delegate-methoden te implementeren, word je op de hoogte gesteld van wijzigingen in de verbindingsstatus en kun je beslissen of je een verbinding accepteert of weigert.

extension MyVideoManager: CamoControllerDelegate {
    // Upon receiving a connection request, you can decide whether or not to accept it.
    func camoControllerShouldAcceptIncomingConnection(_ controller: CamoController) -> Bool {
        // You could return false if you aren't ready to accept connections, such as during onboarding.
        return true
    }

    // Called whenever the connection state changes, such as if the Camo service starts or stops, or if a new connection is made.
    func camoController(_ controller: CamoController, stateDidChangeTo state: CamoControllerState?) {
        // From here, you can update your UI and other state
        print("New state:", state)
    }
}

Zodra dit is gedaan, zou je je app moeten kunnen openen, verbinding kunnen maken via USB en je apparaat in Camo Studio moeten kunnen zien.

Draadloze verbindingen

Om draadloze verbindingen te gebruiken, moeten gebruikers toegang tot het lokale netwerk verlenen. Bonjour-services moeten worden toegevoegd als NSBonjourServices in Info.plist:

_camo._tcp
_camopairing._tcp

Wanneer je camoController.start() aanroept, is de SDK klaar voor koppeling en voor het tot stand brengen van netwerkverbindingen met Camo Studio.

Koppelen

Wanneer een gebruiker op de knop „+” in Camo Studio klikt, start het koppelingsproces. Camo Studio toont een QR-code die aan de kant van de app moet worden gescand.

Stappen voor koppelen:

Klik op „+” in Camo Studio om de QR-code te tonen
Scan de QR-code en verkrijg de data ervan als een string
Geef die data door aan de SDK door camoController.pairStudioWithQRCodeData(codeData) { success in } aan te roepen
De methode pairStudioWithQRCodeData heeft een callback die aangeeft of het koppelen is gelukt
De SDK voert de koppeling met Camo Studio uit en de verbinding wordt automatisch tot stand gebracht.

Als je de koppeling moet annuleren (bijvoorbeeld als de gebruiker de QR-scanner of de app heeft gesloten), roep je camoController.cancelPairing() aan

Koppelen heeft een time-out van 30 seconden. De callback voor de methode pairStudioWithQRCodeData wordt aangeroepen met de waarde success false als er geen koppeling heeft plaatsgevonden binnen 30 seconden na het aanroepen van pairStudioWithQRCodeData.

Gekoppelde apparaten

Na het koppelen slaat de SDK de koppelingsgegevens op in de lijst met gekoppelde apparaten. CamoController heeft 2 methoden om met die lijst te werken:

pairedDevices om de lijst op te halen (als je die lijst in de UI wilt tonen)
removePairedDevice om het apparaat te vergeten

Om de volgende keer een draadloze verbinding met Camo Studio tot stand te brengen, klik je gewoon op de knop „+” in Camo Studio en wacht je tot de verbinding tot stand is gebracht; je hoeft de QR-code niet opnieuw te scannen.

De verbindingsstatus bepalen

De CamoController biedt een CamoControllerState-eigenschap, die ook is opgenomen in de delegate-methode voor statuswijziging, zoals hierboven te zien. Deze enum biedt informatie die nuttig is voor je app, zoals de naam van de verbonden computer voor weergave in de UI.

Hier is een voorbeeld van hoe je je UI kunt bijwerken om de verbindingsstatus weer te geven:

func camoController(_ controller: CamoController, stateDidChangeTo state: CamoControllerState?) {
    let statusText = { () -> String in
        guard case let .running(serviceState) = state else {
            return "Camo service not running"
        }
        switch serviceState {
        case .active(let connection): return "Connected to \(connection.name)"
        case .paused(let connection): return "Paused, but connected to \(connection.name)"
        case .notConnected: return "Camo service running, but no connection"
        }
    }()

    DispatchQueue.main.async {
        self.statusTextLabel.text = statusText
    }
}

Audiovisuele data verzenden

Om clients zoveel mogelijk flexibiliteit te bieden, biedt of beheert de Camo SDK zelf geen opname. In plaats daarvan ben jij verantwoordelijk voor het aanleveren van audio- en videodata aan de CamoController. Dit kan met twee eenvoudige API-aanroepen:

// upon receiving video from the camera or elsewhere
camoController.enqueueVideo(sampleBuffer: sampleBuffer)

// upon receiving audio from the microphone or elsewhere
camoController.enqueuePCMAudio(data: chunk)

Video verzenden

Als je in je videopipeline toegang hebt tot een CMSampleBuffer, is het triviaal om deze data door te geven aan de Camo SDK.

Hierdoor is het instellen hiervan met een basis-AVCaptureSession voor video uiterst eenvoudig. Hier is een voorbeeld daarvan in actie.

class CaptureController: AVCaptureVideoDataOutputSampleBufferDelegate {
    // ...

    func startSession() throws {
        guard let camera = AVCaptureDevice.default(for: .video) else { fatalError("No camera found") }

        let input = try AVCaptureDeviceInput(device: camera)
        captureSession.addInput(input)

        let output = AVCaptureVideoDataOutput()
        output.alwaysDiscardsLateVideoFrames = true
        output.setSampleBufferDelegate(self, queue: videoDataOutputQueue)
        captureSession.addOutput(output)

        captureSession.startRunning()
    }

    // ...

    func captureOutput(_ output: AVCaptureOutput, didOutput sampleBuffer: CMSampleBuffer, from connection: AVCaptureConnection) {
        camoController.enqueueVideo(sampleBuffer: sampleBuffer)
    }
}

Zorg er bij het verzenden van videoframes voor dat:

De framerate 30 FPS is.
Het pixelformaat kCVPixelFormatType_32BGRA is.

Meer details vind je in de API-referentie.

Audio verzenden

Audio verzenden lijkt op video verzenden, maar kan afhankelijk van hoe je applicatie het ontvangt, een paar extra stappen vereisen. Voor een voorbeeldimplementatie, zie de demo-app die bij de Camo SDK is inbegrepen.

Zorg er bij het verzenden van audiodata voor dat:

Je samplerate 48 kHz is.
De audiocodec LPCM is.
Het aantal kanalen 2 is.
De bitdiepte 32 is.
Het aantal samples per audiopakket hangt af van Studio (macOS of Windows); je kunt dit ophalen via CamoController.audioSamplesRequired.

Meer details vind je in de API-referentie.

Overzicht

Hulp nodig?