visão global

Atualizada

O Camo SDK da Reincubate oferece a capacidade de enviar dados audiovisuais em tempo real de seu aplicativo para o Camo Studio no macOS e Windows. Funciona através de USB e é otimizado para baixa latência e desempenho; consumindo o mínimo possível de recursos em seu aplicativo.

Atualmente, o SDK só oferece suporte a aplicativos iOS executados em um dispositivo iOS ou iPadOS físico (excluindo simuladores e Mac Catalyst) no iOS 12 ou superior. O Camo SDK não tem compatibilidade com Objective-C pronto para uso, portanto, se seu aplicativo for principalmente Objective-C, talvez você precise criar um wrapper.


Referência API

Se quiser começar, você pode ver a referência completa da API , que documenta todos os símbolos fornecidos pelo Camo SDK. Caso contrário, este documento o guiará por um exemplo de integração com o SDK.


Instalando o Camo SDK

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. Selecione o projeto do seu aplicativo no Project Navigator.
  2. Escolha o destino do seu aplicativo na barra lateral de destino do projeto. Se você não vir uma barra lateral, ela pode estar em uma lista suspensa na parte superior da página.
  3. Certifique-se de estar na guia 'Geral' e role para baixo até o cabeçalho "Estruturas, bibliotecas e conteúdo incorporado".
  4. Arraste o CamoProducerKit.xcframework e solte-o na lista de arquivos abaixo desse cabeçalho.
  5. Certifique-se de que o SDK está definido como "Embed & Sign".

Quando terminar, você deve ver a estrutura conforme ilustrada:

Integração com seu aplicativo

Controlando o serviço Camo

No núcleo do CamoProducerKit está o CamoController , que fornece ao seu aplicativo uma interface centralizada para controlar o Camo SDK.

Em seu aplicativo, você deve inicializar uma instância do CamoController . Você pode optar por fazer isso no lançamento do aplicativo ou salvá-lo para mais tarde. Até que seja explicitamente iniciado com start() , o controlador Camo usará poucos recursos. No entanto, ele se preparará para a codificação de áudio e vídeo na inicialização.

import CamoProducerKit

class MyVideoManager {
    let controller = CamoController()

    // ...
}

Quando quiser ativar a integração Camo em seu aplicativo, iniciando o serviço Camo para facilitar as conexões, pode-se chamar start() . Quando terminar, você pode pará-lo chamando stop() .

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

Este código é um começo, mas ainda não aceita novas conexões do Camo Studio.

Respondendo a novas conexões

Antes que seu aplicativo seja capaz de aceitar novas conexões do Camo Studio, você precisará implementar o CamoControllerDelegate . Ao implementar esses dois métodos de delegação, você pode ser notificado sobre as alterações no estado da conexão e decidir se aceita ou rejeita uma conexão.

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

Feito isso, agora você deve ser capaz de abrir seu aplicativo, conectar-se ao USB e visualizar seu dispositivo no Camo Studio.

Determinando o estado da conexão

O CamoController fornece uma propriedade CamoControllerState , que também está incluída no método de delegação de mudança de estado, conforme visto acima. Este enum fornece informações úteis para seu aplicativo, como o nome do computador conectado para exibição na IU.

Aqui está um exemplo de como você pode atualizar sua IU para refletir o estado da conexão:

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

Envio de dados audiovisuais

Para permitir aos clientes o máximo de flexibilidade possível, o Camo SDK não fornece nem controla nenhuma captura. Em vez disso, você é responsável por fornecer ao CamoController os dados de áudio e vídeo. Isso pode ser feito com duas chamadas de 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)

Enviando vídeo

Se você tiver acesso a um CMSampleBuffer em seu pipeline de vídeo, é trivial passar esses dados para o Camo SDK.

Por causa disso, configurar isso com um vídeo básico AVCaptureSession é extremamente simples. Aqui está um exemplo disso em ação.

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

Ao enviar quadros de vídeo, certifique-se de que:

  • A duração do quadro é de 30 FPS.
  • O formato do pixel é kCVPixelFormatType_32BGRA .

Você pode ver mais detalhes na referência da API.

Enviando áudio

O envio de áudio é semelhante ao vídeo, mas pode exigir mais algumas etapas, dependendo de como seu aplicativo o recebe. Para obter um exemplo de implementação, consulte o aplicativo de demonstração incluído no Camo SDK.

Ao enviar dados de áudio, certifique-se de que:

  • Sua taxa de amostragem é 48 kHz.
  • O codec de áudio é LPCM.
  • O número de canais é 2.
  • A profundidade de bits é de 32.
  • O número de amostras por pacote de áudio depende do Studio (macOS ou Windows), você pode obtê-lo em CamoController.audioSamplesRequired .

Você pode ver mais detalhes na referência da API.

Como podemos ajudar?

Nossa equipe de suporte está aqui para ajudar!

Nosso horário de atendimento é de segunda a sexta, das 9h às 17h GMT. A hora é atualmente 3:11 AM GMT.

Nosso objetivo é responder a todas as mensagens dentro de um dia útil.

Nossa equipe de suporte incrível

Junte-se à comunidade

Junte-se a uma comunidade centrada em conectar nossos usuários! A comunidade Camo oferecerá fóruns para discussão e suporte, streams de vídeo, jogos, brindes e muito mais conforme crescemos.

Inscreva-se aqui para obter as últimas atualizações sobre nossos próximos eventos.

© 2008 - 2021 Reincubate Ltd. Todos os direitos reservados. Registrado na Inglaterra e no País de Gales #5189175, VAT GB151788978. Reincubate® e Camo® são marcas registradas. Política de Privacidade & termos. Construído com em Londres.