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
|
#include <stdlib.h>
#include <util/threading.h>
#include <util/platform.h>
#include <obs.h>
struct async_sync_test {
obs_source_t *source;
os_event_t *stop_signal;
pthread_t thread;
bool initialized;
};
/* middle C */
static const double rate = 261.63 / 48000.0;
#ifndef M_PI
#define M_PI 3.1415926535897932384626433832795
#endif
#define M_PI_X2 M_PI * 2
static const char *ast_getname(void *unused)
{
UNUSED_PARAMETER(unused);
return "Sync Test (Async Video/Audio Source)";
}
static void ast_destroy(void *data)
{
struct async_sync_test *ast = data;
if (ast->initialized) {
os_event_signal(ast->stop_signal);
pthread_join(ast->thread, NULL);
}
os_event_destroy(ast->stop_signal);
bfree(ast);
}
static inline void fill_texture(uint32_t *pixels, uint32_t color)
{
size_t x, y;
for (y = 0; y < 20; y++) {
for (x = 0; x < 20; x++) {
pixels[y * 20 + x] = color;
}
}
}
static void *video_thread(void *data)
{
struct async_sync_test *ast = data;
uint32_t sample_rate = audio_output_get_sample_rate(obs_get_audio());
uint32_t *pixels = bmalloc(20 * 20 * sizeof(uint32_t));
float *samples = bmalloc(sample_rate * sizeof(float));
uint64_t cur_time = os_gettime_ns();
bool whitelist = false;
double cos_val = 0.0;
uint64_t start_time = cur_time;
struct obs_source_frame frame = {
.data = {[0] = (uint8_t *)pixels},
.linesize = {[0] = 20 * 4},
.width = 20,
.height = 20,
.format = VIDEO_FORMAT_BGRX,
};
struct obs_source_audio audio = {
.speakers = SPEAKERS_MONO,
.data = {[0] = (uint8_t *)samples},
.samples_per_sec = sample_rate,
.frames = sample_rate,
.format = AUDIO_FORMAT_FLOAT,
};
while (os_event_try(ast->stop_signal) == EAGAIN) {
fill_texture(pixels, whitelist ? 0xFFFFFFFF : 0xFF000000);
frame.timestamp = cur_time - start_time;
audio.timestamp = cur_time - start_time;
if (whitelist) {
for (size_t i = 0; i < sample_rate; i++) {
cos_val += rate * M_PI_X2;
if (cos_val > M_PI_X2)
cos_val -= M_PI_X2;
samples[i] = (float)(cos(cos_val) * 0.5);
}
} else {
for (size_t i = 0; i < sample_rate; i++)
samples[i] = 0.0f;
}
obs_source_output_video(ast->source, &frame);
obs_source_output_audio(ast->source, &audio);
os_sleepto_ns(cur_time += 1000000000);
whitelist = !whitelist;
}
bfree(pixels);
bfree(samples);
return NULL;
}
static void *ast_create(obs_data_t *settings, obs_source_t *source)
{
struct async_sync_test *ast = bzalloc(sizeof(struct async_sync_test));
ast->source = source;
if (os_event_init(&ast->stop_signal, OS_EVENT_TYPE_MANUAL) != 0) {
ast_destroy(ast);
return NULL;
}
if (pthread_create(&ast->thread, NULL, video_thread, ast) != 0) {
ast_destroy(ast);
return NULL;
}
ast->initialized = true;
UNUSED_PARAMETER(settings);
UNUSED_PARAMETER(source);
return ast;
}
struct obs_source_info async_sync_test = {
.id = "async_sync_test",
.type = OBS_SOURCE_TYPE_INPUT,
.output_flags = OBS_SOURCE_ASYNC_VIDEO | OBS_SOURCE_AUDIO,
.get_name = ast_getname,
.create = ast_create,
.destroy = ast_destroy,
};
|
