webrtc-sys 0.3.34

Unsafe bindings to libwebrtc
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127

#ifndef VAAPI_H264_ENCODER_WRAPPER_H_
#define VAAPI_H264_ENCODER_WRAPPER_H_

#include <stdbool.h>
#include <stdint.h>
#include <va/va.h>
#include <va/va_enc_h264.h>

#include <memory>
#include <vector>

#if defined(WIN32)
#include "vaapi_display_win32.h"
using VaapiDisplay = livekit_ffi::VaapiDisplayWin32;
#elif defined(__linux__)
#include "vaapi_display_drm.h"
using VaapiDisplay = livekit_ffi::VaapiDisplayDrm ;
#endif
#define SURFACE_NUM 16 /* 16 surfaces for reference */

typedef struct {
  // one of: VAProfileH264ConstrainedBaseline, VAProfileH264Main,
  // VAProfileH264High
  VAProfile h264_profile;
  int h264_entropy_mode;
  int frame_width;
  int frame_height;
  int frame_rate;
  uint32_t bitrate;
  int initial_qp;
  int minimal_qp;
  int intra_period;
  int intra_idr_period;
  int ip_period;
  int rc_mode;
} VA264Config;

typedef struct {
  VADisplay va_dpy;

  VAConfigAttrib attrib[VAConfigAttribTypeMax];
  VAConfigAttrib config_attrib[VAConfigAttribTypeMax];
  int config_attrib_num;
  int enc_packed_header_idx;
  VASurfaceID src_surface[SURFACE_NUM];
  VABufferID coded_buf[SURFACE_NUM];
  VASurfaceID ref_surface[SURFACE_NUM];
  VAConfigID config_id;
  VAContextID context_id;
  VAEncSequenceParameterBufferH264 seq_param;
  VAEncPictureParameterBufferH264 pic_param;
  VAEncSliceParameterBufferH264 slice_param;
  VAPictureH264 current_curr_pic;
  VAPictureH264 reference_frames[SURFACE_NUM];
  VAPictureH264 ref_pic_list0_p[SURFACE_NUM * 2];
  VAPictureH264 ref_pic_list0_b[SURFACE_NUM * 2];
  VAPictureH264 ref_pic_list1_b[SURFACE_NUM * 2];

  // Default entrypoint for Encode
  int requested_entrypoint;
  int selected_entrypoint;

  uint32_t num_short_term;
  int constraint_set_flag;
  int h264_packedheader; /* support pack header? */
  int h264_maxref;
  int frame_width_mbaligned;
  int frame_height_mbaligned;
  uint32_t current_frame_num;
  int current_frame_type;
  uint64_t current_frame_encoding;
  uint64_t current_frame_display;
  uint64_t current_idr_display;

  uint8_t* encoded_buffer;
  VA264Config config;
} VA264Context;

namespace livekit_ffi {

class VaapiH264EncoderWrapper {
 public:
  VaapiH264EncoderWrapper();
  ~VaapiH264EncoderWrapper();

  // Initialize the encoder with the given parameters.
  bool Initialize(int width,
                  int height,
                  int bitrate,
                  int intra_period,
                  int idr_period,
                  int ip_period,
                  int frame_rate,
                  VAProfile profile,
                  int rc_mode);

  // Encode a frame and return the encoded data.
  bool Encode(int fourcc,
              const uint8_t* y,
              const uint8_t* u,
              const uint8_t* v,
              bool forceIDR,
              std::vector<uint8_t>& output);

  void UpdateRates(int frame_rate, int bitrate) {
    if (context_) {
      context_->config.frame_rate = frame_rate;
      context_->config.bitrate = bitrate;
    }
  }

  bool IsInitialized() const {
    return initialized_;
  }

  // Release resources.
  void Destroy();

 private:
  std::unique_ptr<VA264Context> context_;
  std::unique_ptr<VaapiDisplay> va_display_;
  bool initialized_ = false;
};

}  // namespace livekit_ffi

#endif  // VAAPI_H264_ENCODER_WRAPPER_H_