Présentation

Le Camo SDK de Reincubate permet d’envoyer des données audiovisuelles en temps réel depuis votre application vers Camo Studio sur macOS et Windows. Il fonctionne en USB ou sans fil. L’USB est optimisé pour une faible latence et de meilleures performances, en consommant le moins de ressources possible dans votre application. Le mode sans fil vous libère des câbles.

Le Camo SDK est disponible pour les partenaires commerciaux et les collaborateurs. Pour plus d’informations, contactez notre équipe à l’adresse enterprise@reincubate.com.

Actuellement, le SDK ne prend en charge que les applications iOS exécutées sur un appareil iOS ou iPadOS physique (à l’exclusion des simulateurs et de Mac Catalyst) sous iOS 12 ou version ultérieure. Le Camo SDK n’est pas compatible avec Objective-C par défaut ; si votre application est principalement écrite en Objective-C, vous devrez peut-être créer un wrapper.

Référence de l’API

Si vous souhaitez vous lancer directement, vous pouvez consulter la référence complète de l’API, qui documente chaque symbole fourni par le Camo SDK. Sinon, ce document vous guidera à travers un exemple d’intégration du SDK.

Installer le Camo SDK

Lorsque vous recevez le Camo SDK, vous recevez également un fichier nommé CamoProducerKit.xcframework. Ce framework autonome contient tout ce dont vous avez besoin, sans dépendance externe : l’installation est donc simple.

Sélectionnez le projet de votre application dans le Project Navigator.
Choisissez la cible de votre application dans la barre latérale des cibles du projet. Si vous ne voyez pas de barre latérale, elle se trouve peut-être dans un menu déroulant en haut de la page.
Assurez-vous d’être sur l’onglet « General », puis faites défiler jusqu’à la section « Frameworks, Libraries, and Embedded Content ».
Faites glisser le fichier CamoProducerKit.xcframework et déposez-le dans la liste de fichiers sous cette section.
Assurez-vous que le SDK est réglé sur « Embed & Sign ».

Une fois terminé, vous devriez voir le framework comme illustré :

Camo SDK intégré dans une application exemple

Intégration à votre application

Contrôler le service Camo

Au cœur de CamoProducerKit se trouve le CamoController, qui fournit à votre application une interface centralisée unique pour contrôler le Camo SDK.

Dans votre application, vous devez initialiser une instance de CamoController. Vous pouvez le faire au lancement de l’application ou plus tard. Tant qu’il n’est pas explicitement démarré avec start(), le contrôleur Camo utilise très peu de ressources. Il se prépare toutefois pour l’encodage audio et vidéo dès son initialisation.

import CamoProducerKit

class MyVideoManager {
    let controller = CamoController()

    // ...
}

Lorsque vous souhaitez activer l’intégration Camo dans votre application, en démarrant le service Camo pour faciliter les connexions, vous pouvez appeler start(). Une fois que vous n’en avez plus besoin, vous pouvez l’arrêter en appelant stop().

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

Ce code constitue un début, mais il ne peut pas encore accepter de nouvelles connexions depuis Camo Studio.

Répondre aux nouvelles connexions

Avant que votre application puisse accepter de nouvelles connexions depuis Camo Studio, vous devez implémenter le CamoControllerDelegate. En implémentant ces deux méthodes de délégué, vous pouvez être informé des changements d’état de connexion et décider d’accepter ou de refuser une connexion.

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

Cela fait, vous devriez maintenant pouvoir ouvrir votre application, vous connecter en USB et voir votre appareil dans Camo Studio.

Connexions sans fil

Pour utiliser les connexions sans fil, les utilisateurs devront accorder l’accès au Réseau local. Les services Bonjour doivent être ajoutés en tant que NSBonjourServices dans Info.plist :

_camo._tcp
_camopairing._tcp

Lorsque vous appelez camoController.start(), le SDK est prêt pour l’association et l’établissement de connexions réseau avec Camo Studio.

Association

Lorsqu’un utilisateur clique sur le bouton « + » dans Camo Studio, le processus d’association démarre. Camo Studio affiche un code QR qui doit être scanné du côté de l’application.

Étapes de l’association :

Cliquez sur « + » dans Camo Studio pour afficher le code QR
Scannez le code QR et récupérez ses données sous forme de chaîne
Transmettez ces données au SDK en appelant camoController.pairStudioWithQRCodeData(codeData) { success in }
La méthode pairStudioWithQRCodeData dispose d’un callback qui vous indique si l’association a réussi
Le SDK effectuera l’association avec Camo Studio et la connexion sera établie automatiquement.

Si vous devez annuler l’association (par exemple si l’utilisateur a fermé le scanner de QR code ou l’application), vous devez appeler camoController.cancelPairing()

L’association dispose d’un délai d’expiration de 30 secondes. Le callback de la méthode pairStudioWithQRCodeData sera appelé avec la valeur success false si l’association n’a pas eu lieu dans les 30 secondes suivant l’appel de pairStudioWithQRCodeData.

Appareils associés

Une fois l’association effectuée, le SDK enregistre les données d’association dans la liste des appareils associés. CamoController propose 2 méthodes pour utiliser cette liste :

pairedDevices pour récupérer la liste (si vous souhaitez l’afficher dans l’interface)
removePairedDevice pour oublier l’appareil

Pour établir une connexion sans fil avec Camo Studio la fois suivante, il suffit de cliquer sur le bouton « + » dans Camo Studio et d’attendre que la connexion s’établisse ; il n’est pas nécessaire de scanner à nouveau le code QR.

Déterminer l’état de la connexion

Le CamoController fournit une propriété CamoControllerState, également incluse dans la méthode de délégué de changement d’état vue plus haut. Cette énumération fournit des informations utiles à votre application, comme le nom de l’ordinateur connecté à afficher dans l’interface.

Voici un exemple de mise à jour de votre interface pour refléter l’état de la connexion :

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

Envoyer des données audiovisuelles

Pour offrir un maximum de flexibilité aux clients, le Camo SDK ne fournit ni ne contrôle aucune capture. Il vous incombe donc de fournir les données audio et vidéo au CamoController. Cela peut se faire à l’aide de deux appels d’API simples :

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

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

Envoyer la vidéo

Si vous avez accès à un CMSampleBuffer dans votre pipeline vidéo, il est très simple de transmettre ces données au Camo SDK.

Pour cette raison, la mise en place avec une AVCaptureSession vidéo de base est extrêmement simple. Voici un exemple concret.

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

Lorsque vous envoyez des images vidéo, assurez-vous que :

La durée d’image correspond à 30 FPS.
Le format de pixel est kCVPixelFormatType_32BGRA.

Vous trouverez plus de détails dans la référence de l’API.

Envoyer l’audio

L’envoi de l’audio est similaire à celui de la vidéo, mais peut nécessiter quelques étapes supplémentaires selon la façon dont votre application le reçoit. Pour un exemple d’implémentation, consultez l’application de démonstration fournie avec le Camo SDK.

Lorsque vous envoyez des données audio, assurez-vous que :

Votre fréquence d’échantillonnage est de 48 kHz.
Le codec audio est LPCM.
Le nombre de canaux est de 2.
La profondeur de bits est de 32.
Le nombre d’échantillons par paquet audio dépend de Studio (macOS ou Windows) ; vous pouvez l’obtenir via CamoController.audioSamplesRequired.

Vous trouverez plus de détails dans la référence de l’API.

Présentation

Besoin d'aide ?