Overzicht

bijgewerkt

De Camo SDK van Reincubate biedt de mogelijkheid om realtime audiovisuele gegevens van uw applicatie naar Camo Studio op macOS en Windows te sturen. Het werkt via USB en is geoptimaliseerd voor lage latentie en prestaties; zo min mogelijk bronnen in uw app verbruiken.

Momenteel ondersteunt de SDK alleen iOS-applicaties die draaien op een fysiek iOS- of iPadOS-apparaat (exclusief simulators en Mac Catalyst) op iOS 12 of hoger. De Camo SDK heeft standaard geen Objective-C-compatibiliteit, dus als uw app voornamelijk Objective-C is, moet u mogelijk een wrapper maken.


API-referentie

Als je er meteen in wilt springen, kun je de volledige API-referentie bekijken , die elk symbool documenteert dat door de Camo SDK wordt geleverd. Anders leidt dit document u door een voorbeeldintegratie met de SDK.


De Camo SDK installeren

When you receive the Camo SDK, you will have received a file called CamoProducerKit.xcframework. This self-contained framework has everything you need with no external dependencies, so installation is easy.

  1. Selecteer het project van uw toepassing in de Project Navigator.
  2. Kies het doel van uw toepassing in de doelzijbalk van het project. Als u geen zijbalk ziet, bevindt deze zich mogelijk in een vervolgkeuzelijst bovenaan de pagina.
  3. Zorg ervoor dat u zich op het tabblad 'Algemeen' bevindt en scrol omlaag naar de kop 'Frameworks, bibliotheken en ingesloten inhoud'.
  4. Sleep het CamoProducerKit.xcframework en zet het neer in de lijst met bestanden onder die kop.
  5. Zorg ervoor dat de SDK is ingesteld op 'Insluiten en ondertekenen'.

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

Integreren met uw app

De Camo-service bedienen

De kern van CamoProducerKit is de CamoController , die uw app één gecentraliseerde interface biedt voor het besturen van de Camo SDK.

In uw app moet u een instantie van de CamoController initialiseren . U kunt ervoor kiezen om dit te doen bij het starten van de app of om het op te slaan voor later. Totdat expliciet gestart is met start() , zal de Camo-controller heel weinig bronnen gebruiken. Het zal zich echter voorbereiden op audio- en videocodering bij initialisatie.

import CamoProducerKit

class MyVideoManager {
    let controller = CamoController()

    // ...
}

Als je de Camo-integratie in je app wilt activeren en de Camo-service wilt opstarten om verbindingen te vergemakkelijken, kun je start() aanroepen. Als je klaar bent, kun je het stoppen door stop() aan te roepen.

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

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

Reageren op nieuwe connecties

Voordat uw app nieuwe verbindingen van Camo Studio kan accepteren, moet u de CamoControllerDelegate implementeren. Door deze twee gedelegeerde methoden te implementeren, kunt u op de hoogte worden gesteld van wijzigingen in de verbindingsstatus en beslissen of u een verbinding wilt accepteren of weigeren.

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

Als dat klaar is, zou je nu je app moeten kunnen openen, verbinding kunnen maken met USB en je apparaat in Camo Studio kunnen bekijken.

Verbindingsstatus bepalen

De CamoController biedt een CamoControllerState- eigenschap, die ook is opgenomen in de methode voor gedelegeerde statuswijzigingen, zoals hierboven te zien is. Deze opsomming biedt nuttige informatie voor uw app, zoals de naam van de aangesloten computer voor weergave in de gebruikersinterface.

Hier is een voorbeeld van hoe u uw gebruikersinterface 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 gegevens verzenden

Om klanten zoveel mogelijk flexibiliteit te bieden, biedt of controleert de Camo SDK geen opname. In plaats daarvan bent u verantwoordelijk voor het verstrekken van audio- en videogegevens 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 toegang hebt tot een CMSampleBuffer in je videopijplijn, is het triviaal om deze gegevens door te geven aan de Camo SDK.

Hierdoor is het opzetten hiervan met een basisvideo AVCaptureSession uiterst eenvoudig. Hier is een voorbeeld van dat 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 frameduur is 30 FPS.
  • Het pixelformaat is kCVPixelFormatType_32BGRA .

U kunt meer details bekijken in de API-referentie .

Audio verzenden

Het verzenden van audio is vergelijkbaar met video, maar het kan zijn dat er nog een paar stappen nodig zijn, afhankelijk van hoe uw toepassing het ontvangt. Zie de demo-app die bij de Camo SDK is geleverd voor een voorbeeldimplementatie.

Zorg er bij het verzenden van audiogegevens voor dat:

  • Uw samplefrequentie is 48 kHz.
  • De audiocodec is LPCM.
  • Het aantal kanalen is 2.
  • De bitdiepte is 32.
  • Het aantal samples per audiopakket is afhankelijk van Studio (macOS of Windows), je kunt het krijgen van CamoController.audioSamplesRequired .

U kunt meer details bekijken in de API-referentie .

Hoe kunnen we helpen?

Ons ondersteuningsteam is er om u te helpen!

Onze kantooruren zijn van maandag tot vrijdag van 09.00 tot 17.00 uur GMT. De tijd is momenteel 2:52 AM GMT.

We streven ernaar om alle berichten binnen één werkdag te beantwoorden.

Ons geweldige ondersteuningsteam

Word lid van de community

Word lid van een community die draait om het verbinden van onze gebruikers! De Camo-gemeenschap biedt forums voor discussie en ondersteuning, videostreams, games, weggeefacties en meer naarmate we groeien.

Meld u hier aan voor de laatste updates over onze volgende evenementen.

© 2008 - 2021 Reincubate Ltd. Alle rechten voorbehouden. Geregistreerd in Engeland en Wales #5189175, VAT GB151788978. Reincubate® en Camo® zijn geregistreerde handelsmerken. Privacybeleid & termen. Gebouwd met in Londen.