ffmpeg_encoder_plugin/plugin.cpp at main · EdvinNilsson/ffmpeg_encoder_plugin · GitHub

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
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
#include "plugin.h"

#include <cstring>

#include "av1_encoder.h"
#include "av1_nvenc_encoder.h"
#include "ffmpeg_encoder.h"
#include "h264_encoder.h"
#include "h264_nvenc_encoder.h"
#include "h265_encoder.h"
#include "h265_nvenc_encoder.h"
#include "svt_av1_encoder.h"
#include "uisettings_controller.h"
#include "x264_encoder.h"
#include "x265_encoder.h"

static const uint8_t UUID[] = {0xdc, 0xe2, 0xaf, 0xa7, 0x91, 0xe0, 0x75, 0xb7,
                               0x29, 0x41, 0xe8, 0xe0, 0xee, 0xa2, 0x52, 0x59};

StatusCode g_HandleGetInfo(HostPropertyCollectionRef* p_pProps) {
    StatusCode err = p_pProps->SetProperty(pIOPropUUID, propTypeUInt8, UUID, 16);
    if (err == errNone) {
        const char* name = "FFmpeg Plugin";
        err = p_pProps->SetProperty(pIOPropName, propTypeString, name, static_cast<int>(strlen(name)));
    }

    return err;
}

StatusCode g_HandleCreateObj(unsigned char* p_pUUID, ObjectRef* p_ppObj) {
    if (memcmp(p_pUUID, H264Encoder::encoderInfo.UUID, 15) == 0) {
        const uint8_t formatIndex = p_pUUID[15] - H264Encoder::encoderInfo.UUID[15];
        *p_ppObj = new H264Encoder(formatIndex);
        return errNone;
    }

    if (memcmp(p_pUUID, X264Encoder::encoderInfo.UUID, 15) == 0) {
        const uint8_t formatIndex = p_pUUID[15] - X264Encoder::encoderInfo.UUID[15];
        *p_ppObj = new X264Encoder(formatIndex);
        return errNone;
    }

    if (memcmp(p_pUUID, H264NvencEncoder::encoderInfo.UUID, 15) == 0) {
        const uint8_t formatIndex = p_pUUID[15] - H264NvencEncoder::encoderInfo.UUID[15];
        *p_ppObj = new H264NvencEncoder(formatIndex);
        return errNone;
    }

    if (memcmp(p_pUUID, H265Encoder::encoderInfo.UUID, 15) == 0) {
        const uint8_t formatIndex = p_pUUID[15] - H265Encoder::encoderInfo.UUID[15];
        *p_ppObj = new H265Encoder(formatIndex);
        return errNone;
    }

    if (memcmp(p_pUUID, X265Encoder::encoderInfo.UUID, 15) == 0) {
        const uint8_t formatIndex = p_pUUID[15] - X265Encoder::encoderInfo.UUID[15];
        *p_ppObj = new X265Encoder(formatIndex);
        return errNone;
    }

    if (memcmp(p_pUUID, H265NvencEncoder::encoderInfo.UUID, 15) == 0) {
        const uint8_t formatIndex = p_pUUID[15] - H265NvencEncoder::encoderInfo.UUID[15];
        *p_ppObj = new H265NvencEncoder(formatIndex);
        return errNone;
    }

    if (memcmp(p_pUUID, Av1Encoder::encoderInfo.UUID, 15) == 0) {
        const uint8_t formatIndex = p_pUUID[15] - Av1Encoder::encoderInfo.UUID[15];
        *p_ppObj = new Av1Encoder(formatIndex);
        return errNone;
    }

    if (memcmp(p_pUUID, SvtAv1Encoder::encoderInfo.UUID, 15) == 0) {
        const uint8_t formatIndex = p_pUUID[15] - SvtAv1Encoder::encoderInfo.UUID[15];
        *p_ppObj = new SvtAv1Encoder(formatIndex);
        return errNone;
    }

    if (memcmp(p_pUUID, Av1NvencEncoder::encoderInfo.UUID, 15) == 0) {
        const uint8_t formatIndex = p_pUUID[15] - Av1NvencEncoder::encoderInfo.UUID[15];
        *p_ppObj = new Av1NvencEncoder(formatIndex);
        return errNone;
    }

    return errUnsupported;
}

StatusCode g_HandlePluginStart() { return errNone; }

StatusCode g_HandlePluginTerminate() { return errNone; }

StatusCode g_ListCodecs(HostListRef* p_pList) {
    StatusCode err = H264Encoder::RegisterCodecs(p_pList);
    if (err != errNone) return err;

    err = X264Encoder::RegisterCodecs(p_pList);
    if (err != errNone) return err;

    err = H264NvencEncoder::RegisterCodecs(p_pList);
    if (err != errNone) return err;

    err = H265Encoder::RegisterCodecs(p_pList);
    if (err != errNone) return err;

    err = X265Encoder::RegisterCodecs(p_pList);
    if (err != errNone) return err;

    err = H265NvencEncoder::RegisterCodecs(p_pList);
    if (err != errNone) return err;

    err = Av1Encoder::RegisterCodecs(p_pList);
    if (err != errNone) return err;

    err = SvtAv1Encoder::RegisterCodecs(p_pList);
    if (err != errNone) return err;

    err = Av1NvencEncoder::RegisterCodecs(p_pList);
    if (err != errNone) return err;

    return errNone;
}

StatusCode g_ListContainers(HostListRef* p_pList) { return errNone; }

StatusCode g_GetEncoderSettings(unsigned char* p_pUUID, HostPropertyCollectionRef* p_pValues,
                                HostListRef* p_pSettingsList) {
    if (memcmp(p_pUUID, H264Encoder::encoderInfo.UUID, 15) == 0) {
        return H264Encoder::GetEncoderSettings(p_pValues, p_pSettingsList);
    }

    if (memcmp(p_pUUID, X264Encoder::encoderInfo.UUID, 15) == 0) {
        return X264Encoder::GetEncoderSettings(p_pValues, p_pSettingsList);
    }

    if (memcmp(p_pUUID, H264NvencEncoder::encoderInfo.UUID, 15) == 0) {
        return H264NvencEncoder::GetEncoderSettings(p_pValues, p_pSettingsList);
    }

    if (memcmp(p_pUUID, H265Encoder::encoderInfo.UUID, 15) == 0) {
        return H265Encoder::GetEncoderSettings(p_pValues, p_pSettingsList);
    }

    if (memcmp(p_pUUID, X265Encoder::encoderInfo.UUID, 15) == 0) {
        return X265Encoder::GetEncoderSettings(p_pValues, p_pSettingsList);
    }

    if (memcmp(p_pUUID, H265NvencEncoder::encoderInfo.UUID, 15) == 0) {
        return H265NvencEncoder::GetEncoderSettings(p_pValues, p_pSettingsList);
    }

    if (memcmp(p_pUUID, Av1Encoder::encoderInfo.UUID, 15) == 0) {
        return Av1Encoder::GetEncoderSettings(p_pValues, p_pSettingsList);
    }

    if (memcmp(p_pUUID, SvtAv1Encoder::encoderInfo.UUID, 15) == 0) {
        return SvtAv1Encoder::GetEncoderSettings(p_pValues, p_pSettingsList);
    }

    if (memcmp(p_pUUID, Av1NvencEncoder::encoderInfo.UUID, 15) == 0) {
        return Av1NvencEncoder::GetEncoderSettings(p_pValues, p_pSettingsList);
    }

    return errNoCodec;
}