VideoCaptureSystem.cpp

#include "VideoCaptureSystem.h"
 
#include "VideoCaptureRenderer.h"
#include "IVideoEncoder.h"
 
#include "Context.h"
#include "Components/Core/CameraComponent.h"
#include "Renderer/RenderResources.h"
#include "Renderer/RenderTexture.h"
#include "Systems/Core/CameraSystem.h"
#include "Resources/Texture.h"
 
#include "Rendering/IContext.h"
 
#include "Foundation/Platform/Timer.h"
#include "Foundation/Logging/Logger.h"
 
using namespace Cogs::Core;
 
namespace
{
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("VideoCaptureSystem");
}// namespace ...
 
void Cogs::Core::VideoCaptureSystem::initialize(Context * context)
{
  ComponentSystemWithDataPool::initialize(context);
  if(!renderer){
    renderer = new VideoCaptureRenderer;
    context->renderer->registerExtension(renderer);
  }
}
 
void Cogs::Core::VideoCaptureSystem::cleanup(Context * context)
{
  assert(renderer);
  if (context->renderer) {
    context->renderer->unregisterExtension(renderer);
  }
  delete renderer;
  renderer = nullptr;
  ComponentSystemWithDataPool::cleanup(context);
}
 
void Cogs::Core::VideoCaptureSystem::update(Context *)
{
  if (!context->videoEncoderContext) return;
  for (auto & capComp : pool) {
     auto & capData = getData(&capComp);
     if (!capData.encoder || capComp.endOfStream) continue;
     if(capComp.updateTimestamp)
       capComp.timestamp = Timer::currentTimeMicroseconds();
  }
}
 
void Cogs::Core::VideoCaptureSystem::preUpdate(Context * context)
{
  if (!context->videoEncoderContext) return;
  for (auto & capComp : pool) {
    CameraComponent*  camComp = capComp.getComponent<CameraComponent>();
 
    if (!camComp) {
      continue;
    }
 
    VideoCaptureData& capData = getData(&capComp);
    int64_t           now = Timer::currentTimeMilliseconds();
 
    if (capComp.restart) {
      capComp.endOfStream = false;
    }
 
    if (((!capData.encoder && (capData.nextRestartTime < now)) || capComp.restart || capComp.reconfig) && !capComp.endOfStream) {
      if(capData.encoder && capComp.restart) {
        context->videoEncoderContext->destroyVideoEncoder(capData.encoder);
      }
      VideoEncoderDescription desc = {};
 
      desc.codec = capComp.codec;
      desc.encodeWidth = capComp.width;
      desc.encodeHeight = capComp.height;
      desc.darWidth = desc.encodeWidth;
      desc.darHeight = desc.encodeHeight;
      desc.maxWidth = capComp.maxWidth;
      desc.maxHeight = capComp.maxHeight;
      desc.bitrate = capComp.bitrate;
      desc.maxBitrate = capComp.maxBitrate;
      desc.bFrameCount = capComp.bFrameCount;
      desc.bFrameReference = (uint32_t)capComp.bFrameReference;
      desc.frameRate = 1000.0f / capComp.frameInterval;
      desc.lookahead = capComp.lookahead;
      desc.recordToDisk = capComp.recordToDisk;
      desc.recordPath = capComp.recordPath;
      desc.callback = capComp.callback;
      desc.useMSAA = capComp.useMSAA;
 
      if(!capData.encoder || capComp.restart) {
        capData.encoder = context->videoEncoderContext->createVideoEncoder(desc);
 
        if (!capData.encoder) {
          // If we failed to create an encoder, don't try again for three seconds.
          // (Or when the application specifically requests it through the VideoCaptureComponent.)
          capData.nextRestartTime = now + 3000;
        }
        else {
          capData.nextRestartTime = 0;
        }
      }
      else {
        capData.encoder->reconfigure(desc, false, true);
      }
      capComp.width = desc.encodeWidth;
      capComp.height = desc.encodeHeight;
      capComp.maxWidth = desc.maxWidth;
      capComp.maxHeight = desc.maxHeight;
      capComp.bFrameCount = desc.bFrameCount;
      capComp.restart = false;
      capComp.reconfig = false;
 
      camComp->renderTexture = capData.encoder->getRenderTarget();
    }
    if (!capData.encoder || capComp.endOfStream) {
      continue;
    }
    camComp->resolveTarget = capData.encoder->getNextInputBuffer();
    camComp->viewportSize = glm::vec2(0, 0);
#ifndef _WIN32
    camComp->flags |= CameraFlags::FlipY;
#endif
    camComp->setChanged();
  }
}
 
void Cogs::Core::VideoCaptureSystem::postRender(Context * context)
{
  if (!context->videoEncoderContext) {
    return;
  }
  for (auto& capComp : pool) {
    CameraComponent* camComp = capComp.getComponent<CameraComponent>();
 
    if (!camComp) {
      continue;
    }
    if (!camComp->renderTexture) {
      continue;
    }
    if ((camComp->flags & CameraFlags::EnableRender) != CameraFlags::EnableRender) {
      continue;
    }
    auto & capData = getData(&capComp);
    if (!capData.encoder) {
      continue;
    }
    if (capComp.endOfStream) {
      if (capData.encoder) {
        context->videoEncoderContext->destroyVideoEncoder(capData.encoder);
        capData.encoder = nullptr;
      }
      continue;
    }
    int64_t now = Timer::currentTimeMilliseconds();
 
    if (capData.nextEncodeTime < now) {
      capData.nextEncodeTime = now + capComp.frameInterval;
 
      VideoEncoderInput input = VideoEncoderInput();
 
      input.texture = camComp->resolveTarget;
      input.timestamp = capComp.timestamp;
      input.duration = capComp.duration;
      input.forceIntra = capComp.forceIntra;
      input.forceIDR = capComp.forceIDR;
      input.outputSPSPPS = capComp.outputSPSPPS;
 
      capData.encoder->encode(input);
      capComp.forceIntra = false;
      capComp.forceIDR = false;
      capComp.outputSPSPPS = false;
    }
  }
}
 
void Cogs::Core::VideoCaptureSystem::destroyComponent(ComponentHandle component)
{
  if (context->videoEncoderContext){
    VideoCaptureComponent*  vcComp = component.resolveComponent<VideoCaptureComponent>();
    VideoCaptureData&       capData = getData(vcComp);
 
#ifndef _WIN32
    CameraComponent* camComp = vcComp->getComponent<CameraComponent>();
 
    if (camComp) {
      camComp->flags &= ~CameraFlags::FlipY;
      camComp->setChanged();
    }
#endif
 
    if(capData.encoder){
      context->videoEncoderContext->destroyVideoEncoder(capData.encoder);
      capData.encoder = nullptr;
    }
  }
  ComponentSystemWithDataPool::destroyComponent(component);
}