NGIAgoraVideoFrame.h

 
// Copyright (c) 2020 Agora.io. All rights reserved
 
// This program is confidential and proprietary to Agora.io.
// And may not be copied, reproduced, modified, disclosed to others, published
// or used, in whole or in part, without the express prior written permission
// of Agora.io.
 
#pragma once  // NOLINT(build/header_guard)
 
#include "AgoraBase.h"
 
#ifndef OPTIONAL_ENUM_CLASS
#if __cplusplus >= 201103L || (defined(_MSC_VER) && _MSC_VER >= 1800)
#define OPTIONAL_ENUM_CLASS enum class
#else
#define OPTIONAL_ENUM_CLASS enum
#endif
#endif
 
namespace agora {
namespace rtc {
 
struct TextureInfo {
  OPTIONAL_ENUM_CLASS TextureType {
    kGlTextureOes,
    kGlTexture2D,
  };
  OPTIONAL_ENUM_CLASS EglContextType {
    kEglContext10,
    kEglContext14,
  };
 
  TextureType texture_type;
  EglContextType context_type;
  void* shared_context;
  int texture_id;
  int64_t fence_object;
  int frame_buffer_id;  
  float transform_matrix[16];
};
 
struct RawPixelBuffer {
  OPTIONAL_ENUM_CLASS Format {
    kUnknown,
    kI420,
    kI422,
    kNV21,
    kNV12,
    kI010,
    kRGBA,
    kARGB,
    kBGRA,
    kABGR
  };
  Format format;
  uint8_t* data;
  int size;
};
 
struct PaddedRawPixelBuffer {
  RawPixelBuffer::Format format;
  uint8_t* data;
  int size;
  int stride;
  int width;
  int height;
  uint8_t* data_y;
  int stride_y;
  uint8_t* data_u;
  int stride_u;
  uint8_t* data_v;
  int stride_v;
  PaddedRawPixelBuffer()
    : data(NULL), size(0), stride(0), width(0), height(0), data_y(NULL), stride_y(0),
      data_u(NULL), stride_u(0), data_v(NULL), stride_v(0) {}
};
 
struct VideoFrameData {
  OPTIONAL_ENUM_CLASS Type {
    kRawPixels, // Raw pixels in memory
    kTexture, // Deprecated Android: GL_TEXTURE_2D/GL_TEXTURE_OES
    kCVPixelBuffer, // iOS: CVPixelBufferRef
    kPaddedRawPixels, // Raw pixels with paddings
    kTextureOES,// Android: GL_TEXTURE_OES
    kTexture2D, // Android: GL_TEXTURE_2D
    kDoubleBuffer, //Android: double buffer
  };
  Type type;
  union {
    TextureInfo texture; // Android (To be supported)
    RawPixelBuffer pixels; // All platform
    void* cvpixelbuffer; // iOS (To be supported)
  };
  int width;
  int height;
  int rotation;
  agora::media::base::ColorSpace color_space;
  int64_t timestamp_ms; // Capture time in milli-seconds
};
 
struct VideoFrameDataV2 : public VideoFrameData {
  PaddedRawPixelBuffer padded_pixels; // All platform
};
 
OPTIONAL_ENUM_CLASS VideoFrameMetaDataType {
  kAlphaChannel,
  kScreenMetaInfo,
  kVideoSourceType,
  kFaceInfo,
  kFaceCaptureInfo,
  kGravityRotation,
  // Add other types afterwards
};
 
OPTIONAL_ENUM_CLASS VideoFrameGravityRotation {
  kGravityRotation_Unknown = -1,
  kGravityRotation_0 = 0,
  kGravityRotation_90 = 90,
  kGravityRotation_180 = 180,
  kGravityRotation_270 = 270
};
 
struct AlphaChannel {
  uint8_t* data;
  int size;
};
 
typedef int32_t VideoSourceType;
 
class IVideoFrame : public RefCountInterface {
 public:
  virtual int getVideoFrameData(VideoFrameData& data) const = 0;
 
  virtual int fillVideoFrameData(const VideoFrameData& data) = 0;
 
  virtual int getVideoFrameMetaData(VideoFrameMetaDataType type, void* data) = 0;
 
  virtual int fillVideoFrameMetaData(VideoFrameMetaDataType type, const void* data) = 0;
 
 protected:
  ~IVideoFrame() {}
};
 
class IVideoFrameMemoryPool : public RefCountInterface {
 public:
  virtual agora::agora_refptr<IVideoFrame> createVideoFrame(
      const VideoFrameData& data, const VideoFrameMetaDataType* metatypes = NULL, int count = 0) = 0;
 
 protected:
  virtual ~IVideoFrameMemoryPool() {}
};
 
}  // namespace rtc
}  // namespace agora