]> git.sesse.net Git - bmusb/blob - fake_capture.cpp
Fix a typo.
[bmusb] / fake_capture.cpp
1 // A fake capture device that sends single-color frames at a given rate.
2 // Mostly useful for testing themes without actually hooking up capture devices.
3
4 #include "bmusb/fake_capture.h"
5
6 #include <assert.h>
7 #include <stdint.h>
8 #include <stdio.h>
9 #include <stdlib.h>
10 #include <string.h>
11 #include <math.h>
12 #include <unistd.h>
13 #if __SSE2__
14 #include <immintrin.h>
15 #endif
16 #include <cstddef>
17
18 #include "bmusb/bmusb.h"
19
20 #define FRAME_SIZE (8 << 20)  // 8 MB.
21
22 // Pure-color inputs: Red, green, blue, white.
23 #define NUM_COLORS 4
24 constexpr uint8_t ys[NUM_COLORS] = { 81, 145, 41, 235 };
25 constexpr uint8_t cbs[NUM_COLORS] = { 90, 54, 240, 128 };
26 constexpr uint8_t crs[NUM_COLORS] = { 240, 34, 110, 128 };
27
28 using namespace std;
29
30 namespace bmusb {
31 namespace {
32
33 // We don't bother with multiversioning for this, because SSE2
34 // is on by default for all 64-bit compiles, which is really
35 // the target user segment here.
36
37 void memset2(uint8_t *s, const uint8_t c[2], size_t n)
38 {
39         size_t i = 0;
40 #if __SSE2__
41         const uint8_t c_expanded[16] = {
42                 c[0], c[1], c[0], c[1], c[0], c[1], c[0], c[1],
43                 c[0], c[1], c[0], c[1], c[0], c[1], c[0], c[1]
44         };
45         __m128i cc = *(__m128i *)c_expanded;
46         __m128i *out = (__m128i *)s;
47
48         for ( ; i < (n & ~15); i += 16) {
49                 _mm_storeu_si128(out++, cc);
50                 _mm_storeu_si128(out++, cc);
51         }
52
53         s = (uint8_t *)out;
54 #endif
55         for ( ; i < n; ++i) {
56                 *s++ = c[0];
57                 *s++ = c[1];
58         }
59 }
60
61 void memset4(uint8_t *s, const uint8_t c[4], size_t n)
62 {
63         size_t i = 0;
64 #if __SSE2__
65         const uint8_t c_expanded[16] = {
66                 c[0], c[1], c[2], c[3], c[0], c[1], c[2], c[3],
67                 c[0], c[1], c[2], c[3], c[0], c[1], c[2], c[3]
68         };
69         __m128i cc = *(__m128i *)c_expanded;
70         __m128i *out = (__m128i *)s;
71
72         for ( ; i < (n & ~7); i += 8) {
73                 _mm_storeu_si128(out++, cc);
74                 _mm_storeu_si128(out++, cc);
75         }
76
77         s = (uint8_t *)out;
78 #endif
79         for ( ; i < n; ++i) {
80                 *s++ = c[0];
81                 *s++ = c[1];
82                 *s++ = c[2];
83                 *s++ = c[3];
84         }
85 }
86
87 }  // namespace
88
89 FakeCapture::FakeCapture(unsigned width, unsigned height, unsigned fps, unsigned audio_frequency, int card_index)
90         : width(width), height(height), fps(fps), audio_frequency(audio_frequency)
91 {
92         char buf[256];
93         snprintf(buf, sizeof(buf), "Fake card %d", card_index + 1);
94         description = buf;
95
96         y = ys[card_index % NUM_COLORS];
97         cb = cbs[card_index % NUM_COLORS];
98         cr = crs[card_index % NUM_COLORS];
99 }
100
101 FakeCapture::~FakeCapture()
102 {
103         if (has_dequeue_callbacks) {
104                 dequeue_cleanup_callback();
105         }
106 }
107
108 void FakeCapture::configure_card()
109 {
110         if (video_frame_allocator == nullptr) {
111                 owned_video_frame_allocator.reset(new MallocFrameAllocator(FRAME_SIZE, NUM_QUEUED_VIDEO_FRAMES));
112                 set_video_frame_allocator(owned_video_frame_allocator.get());
113         }
114         if (audio_frame_allocator == nullptr) {
115                 owned_audio_frame_allocator.reset(new MallocFrameAllocator(65536, NUM_QUEUED_AUDIO_FRAMES));
116                 set_audio_frame_allocator(owned_audio_frame_allocator.get());
117         }
118 }
119
120 void FakeCapture::start_bm_capture()
121 {
122         producer_thread_should_quit = false;
123         producer_thread = thread(&FakeCapture::producer_thread_func, this);
124 }
125
126 void FakeCapture::stop_dequeue_thread()
127 {
128         producer_thread_should_quit = true;
129         producer_thread.join();
130 }
131         
132 std::map<uint32_t, VideoMode> FakeCapture::get_available_video_modes() const
133 {
134         VideoMode mode;
135
136         char buf[256];
137         snprintf(buf, sizeof(buf), "%ux%u", width, height);
138         mode.name = buf;
139         
140         mode.autodetect = false;
141         mode.width = width;
142         mode.height = height;
143         mode.frame_rate_num = fps;
144         mode.frame_rate_den = 1;
145         mode.interlaced = false;
146
147         return {{ 0, mode }};
148 }
149
150 std::map<uint32_t, std::string> FakeCapture::get_available_video_inputs() const
151 {
152         return {{ 0, "Fake video input (single color)" }};
153 }
154
155 std::map<uint32_t, std::string> FakeCapture::get_available_audio_inputs() const
156 {
157         return {{ 0, "Fake audio input (silence)" }};
158 }
159
160 void FakeCapture::set_video_mode(uint32_t video_mode_id)
161 {
162         assert(video_mode_id == 0);
163 }
164
165 void FakeCapture::set_video_input(uint32_t video_input_id)
166 {
167         assert(video_input_id == 0);
168 }
169
170 void FakeCapture::set_audio_input(uint32_t audio_input_id)
171 {
172         assert(audio_input_id == 0);
173 }
174
175 namespace {
176
177 void add_time(double t, timespec *ts)
178 {
179         ts->tv_nsec += lrint(t * 1e9);
180         ts->tv_sec += ts->tv_nsec / 1000000000;
181         ts->tv_nsec %= 1000000000;
182 }
183
184 bool timespec_less_than(const timespec &a, const timespec &b)
185 {
186         return make_pair(a.tv_sec, a.tv_nsec) < make_pair(b.tv_sec, b.tv_nsec);
187 }
188
189 }  // namespace
190
191 void FakeCapture::producer_thread_func()
192 {
193         uint16_t timecode = 0;
194
195         if (has_dequeue_callbacks) {
196                 dequeue_init_callback();
197         }
198
199         timespec next_frame;
200         clock_gettime(CLOCK_MONOTONIC, &next_frame);
201         add_time(1.0 / fps, &next_frame);
202
203         while (!producer_thread_should_quit) {
204                 timespec now;
205                 clock_gettime(CLOCK_MONOTONIC, &now);
206
207                 if (timespec_less_than(now, next_frame)) {
208                         // Wait until the next frame.
209                         if (clock_nanosleep(CLOCK_MONOTONIC, TIMER_ABSTIME,
210                                             &next_frame, nullptr) == -1) {
211                                 if (errno == EINTR) continue;  // Re-check the flag and then sleep again.
212                                 perror("clock_nanosleep");
213                                 exit(1);
214                         }
215                 } else {
216                         // We've seemingly missed a frame. If we're more than one second behind,
217                         // reset the timer; otherwise, just keep going.
218                         timespec limit = next_frame;
219                         ++limit.tv_sec;
220                         if (!timespec_less_than(now, limit)) {
221                                 fprintf(stderr, "More than one second of missed fake frames; resetting clock.\n");
222                                 next_frame = now;
223                         }
224                 }
225
226                 // Figure out when the next frame is to be, then compute the current one.
227                 add_time(1.0 / fps, &next_frame);
228
229                 VideoFormat video_format;
230                 video_format.width = width;
231                 video_format.height = height;
232                 video_format.frame_rate_nom = fps;
233                 video_format.frame_rate_den = 1;
234                 video_format.has_signal = true;
235                 video_format.is_connected = false;
236
237                 FrameAllocator::Frame video_frame = video_frame_allocator->alloc_frame();
238                 if (video_frame.data != nullptr) {
239                         assert(video_frame.size >= width * height * 2);
240                         if (video_frame.interleaved) {
241                                 uint8_t cbcr[] = { cb, cr };
242                                 memset2(video_frame.data, cbcr, width * height / 2);
243                                 memset(video_frame.data2, y, width * height);
244                         } else {
245                                 uint8_t ycbcr[] = { y, cb, y, cr };
246                                 memset4(video_frame.data, ycbcr, width * height / 2);
247                         }
248                         video_frame.len = width * height * 2;
249                 }
250
251                 AudioFormat audio_format;
252                 audio_format.bits_per_sample = 32;
253                 audio_format.num_channels = 2;
254
255                 FrameAllocator::Frame audio_frame = audio_frame_allocator->alloc_frame();
256                 if (audio_frame.data != nullptr) {
257                         assert(audio_frame.size >= 2 * sizeof(uint32_t) * audio_frequency / fps);
258                         audio_frame.len = 2 * sizeof(uint32_t) * audio_frequency / fps;
259                         memset(audio_frame.data, 0, audio_frame.len);
260                 }
261
262                 frame_callback(timecode++,
263                                video_frame, 0, video_format,
264                                audio_frame, 0, audio_format);
265         }
266         if (has_dequeue_callbacks) {
267                 dequeue_cleanup_callback();
268         }
269 }
270
271 }  // namespace bmusb