int BrowserManager::Impl::CreateBrowser(
const BrowserSettings &browserSettings,
const std::shared_ptr<BrowserListener> &browserListener)
{
int browserIdentifier = 0;
os_event_t *createdEvent;
os_event_init(&createdEvent, OS_EVENT_TYPE_AUTO);
CefPostTask(TID_UI, BrowserTask::newTask(
[&]
{
CefRefPtr<BrowserRenderHandler> renderHandler(
new BrowserRenderHandler(browserSettings.width,
browserSettings.height, browserListener));
CefRefPtr<BrowserLoadHandler> loadHandler(
new BrowserLoadHandler(browserSettings.css));
CefRefPtr<BrowserClient> browserClient(
new BrowserClient(renderHandler,loadHandler));
CefWindowInfo windowInfo;
windowInfo.transparent_painting_enabled = true;
windowInfo.width = browserSettings.width;
windowInfo.height = browserSettings.height;
windowInfo.windowless_rendering_enabled = true;
CefBrowserSettings cefBrowserSettings;
cefBrowserSettings.windowless_frame_rate = browserSettings.fps;
CefRefPtr<CefBrowser> browser =
CefBrowserHost::CreateBrowserSync(windowInfo,
browserClient, browserSettings.url,
cefBrowserSettings, nullptr);
if (browser != nullptr) {
browserIdentifier = browser->GetIdentifier();
browserMap[browserIdentifier] = browser;
}
os_event_signal(createdEvent);
}));
os_event_wait(createdEvent);
os_event_destroy(createdEvent);
return browserIdentifier;
}
static int socket_queue_data(RTMPSockBuf *sb, const char *data, int len, void *arg)
{
struct rtmp_stream *stream = arg;
retry_send:
if (!RTMP_IsConnected(&stream->rtmp))
return 0;
pthread_mutex_lock(&stream->write_buf_mutex);
if (stream->write_buf_len + len > stream->write_buf_size) {
pthread_mutex_unlock(&stream->write_buf_mutex);
if (os_event_wait(stream->buffer_space_available_event)) {
return 0;
}
goto retry_send;
}
memcpy(stream->write_buf + stream->write_buf_len, data, len);
stream->write_buf_len += len;
pthread_mutex_unlock(&stream->write_buf_mutex);
os_event_signal (stream->buffer_has_data_event);
return len;
}
bool video_output_wait(video_t video)
{
if (!video) return false;
os_event_wait(video->update_event);
return os_event_try(video->stop_event) == EAGAIN;
}
/****************************************************************//**
Wait for a work item to appear in the queue.
@return work item */
UNIV_INTERN
void*
ib_wqueue_wait(
/*===========*/
ib_wqueue_t* wq) /*!< in: work queue */
{
ib_list_node_t* node;
for (;;) {
os_event_wait(wq->event);
mutex_enter(&wq->mutex);
node = ib_list_get_first(wq->items);
if (node) {
ib_list_remove(wq->items, node);
if (!ib_list_get_first(wq->items)) {
/* We must reset the event when the list
gets emptied. */
os_event_reset(wq->event);
}
break;
}
mutex_exit(&wq->mutex);
}
mutex_exit(&wq->mutex);
return(node->data);
}
void
buf_flush_wait_batch_end(
/*=====================*/
ulint type) /* in: BUF_FLUSH_LRU or BUF_FLUSH_LIST */
{
ut_ad((type == BUF_FLUSH_LRU) || (type == BUF_FLUSH_LIST));
os_event_wait(buf_pool->no_flush[type]);
}
void gslog_task()
{
int i, y, loglines, linelength, winlines, lwin0, lwin1;
#define LINE_SIZE_MAX 128
char line[LINE_SIZE_MAX];
struct gs_win_t *win;
while (!gs_initialized())
os_wait_ms(10);
win = gs_win_create(GSLOG_WIN_POSX, GSLOG_WIN_POSY, GSLOG_WIN_WIDTH, GSLOG_WIN_HEIGHT);
if (!win)
{
dprint("sn", ERR_PREFIX "Failed to create log window");
os_wait(OS_WAIT_FOREVER);
}
gs_win_set_border(win, 1, GS_COLOR_WHITE);
gs_win_refresh(win);
winlines = (GSLOG_WIN_HEIGHT - (GSLOG_PADY * 2)) / GSLOG_FONT->height;
linelength = (GSLOG_WIN_WIDTH - (GSLOG_PADX * 2)) / GSLOG_FONT->width;
while (1)
{
os_event_wait(&slog_event, SLOG_EVENT_MASK_UPDATE, OS_FLAG_CLEAR, OS_WAIT_FOREVER);
loglines = slog_lines();
lwin0 = 0;
if (loglines > winlines)
lwin0 = loglines - winlines;
lwin1 = loglines - 1;
for (y = 0, i = lwin0; i <= lwin1; i++)
{
memset(line, ' ', linelength);
slog_get_line(line, LINE_SIZE_MAX, i);
line[strlen(line)] = ' ';
line[linelength] = 0;
gs_text_put(win, line, GSLOG_PADX, GSLOG_PADY + y, GSLOG_FONT_COLOR, win->bgcolor.value, GSLOG_FONT);
y += GSLOG_FONT->height;
}
gs_win_refresh(win);
}
}
void
BrowserManager::Impl::DestroyBrowser(int browserIdentifier)
{
if (browserMap.count(browserIdentifier) > 0) {
CefRefPtr<CefBrowser> browser = browserMap[browserIdentifier];
os_event_t *closeEvent;
os_event_init(&closeEvent, OS_EVENT_TYPE_AUTO);
CefPostTask(TID_UI, BrowserTask::newTask([&, browser]
{
browser->GetHost()->CloseBrowser(true);
os_event_signal(closeEvent);
}));
os_event_wait(closeEvent);
os_event_destroy(closeEvent);
browserMap.erase(browserIdentifier);
}
}
void obs_output_destroy(obs_output_t *output)
{
if (output) {
obs_context_data_remove(&output->context);
blog(LOG_INFO, "output '%s' destroyed", output->context.name);
if (output->valid && active(output))
obs_output_actual_stop(output, true, 0);
os_event_wait(output->stopping_event);
if (data_capture_ending(output))
pthread_join(output->end_data_capture_thread, NULL);
if (output->service)
output->service->output = NULL;
if (output->context.data)
output->info.destroy(output->context.data);
free_packets(output);
if (output->video_encoder) {
obs_encoder_remove_output(output->video_encoder,
output);
}
for (size_t i = 0; i < MAX_AUDIO_MIXES; i++) {
if (output->audio_encoders[i]) {
obs_encoder_remove_output(
output->audio_encoders[i],
output);
}
}
os_event_destroy(output->stopping_event);
pthread_mutex_destroy(&output->interleaved_mutex);
pthread_mutex_destroy(&output->delay_mutex);
os_event_destroy(output->reconnect_stop_event);
obs_context_data_free(&output->context);
circlebuf_free(&output->delay_data);
if (output->owns_info_id)
bfree((void*)output->info.id);
bfree(output);
}
}
void BrowserManager::Impl::Shutdown()
{
os_event_t *shutdown_event;
os_event_init(&shutdown_event, OS_EVENT_TYPE_AUTO);
// post the task
CefPostTask(TID_UI, BrowserTask::newTask([] {
CefQuitMessageLoop();
}));
// this event will then get processed and shut down the dispatcher loop
PushEvent([this, shutdown_event] {
threadAlive = false;
os_event_signal(shutdown_event);
});
os_event_wait(shutdown_event);
os_event_destroy(shutdown_event);
return;
}
void
rw_lock_debug_mutex_enter(void)
/*==========================*/
{
loop:
if (0 == mutex_enter_nowait(&rw_lock_debug_mutex)) {
return;
}
os_event_reset(rw_lock_debug_event);
rw_lock_debug_waiters = TRUE;
if (0 == mutex_enter_nowait(&rw_lock_debug_mutex)) {
return;
}
os_event_wait(rw_lock_debug_event);
goto loop;
}
/**********************************************************//**
Waits for an event object until it is in the signaled state or
a timeout is exceeded. In Unix the timeout is always infinite.
@return 0 if success, OS_SYNC_TIME_EXCEEDED if timeout was exceeded */
UNIV_INTERN
ulint
os_event_wait_time(
/*===============*/
os_event_t event, /*!< in: event to wait */
ulint time) /*!< in: timeout in microseconds, or
OS_SYNC_INFINITE_TIME */
{
#ifdef __WIN__
DWORD err;
ut_a(event);
if (time != OS_SYNC_INFINITE_TIME) {
err = WaitForSingleObject(event->handle, (DWORD) time / 1000);
} else {
err = WaitForSingleObject(event->handle, INFINITE);
}
if (err == WAIT_OBJECT_0) {
return(0);
} else if (err == WAIT_TIMEOUT) {
return(OS_SYNC_TIME_EXCEEDED);
} else {
ut_error;
return(1000000); /* dummy value to eliminate compiler warn. */
}
#else
UT_NOT_USED(time);
/* In Posix this is just an ordinary, infinite wait */
os_event_wait(event);
return(0);
#endif
}
void BrowserManager::Impl::ExecuteOnBrowser(int browserIdentifier,
std::function<void(CefRefPtr<CefBrowser>)> f,
bool async)
{
if (browserMap.count(browserIdentifier) > 0) {
CefRefPtr<CefBrowser> browser = browserMap[browserIdentifier];
if (async) {
CefPostTask(TID_UI, BrowserTask::newTask([&] {
f(browser);
}));
} else {
os_event_t *finishedEvent;
os_event_init(&finishedEvent, OS_EVENT_TYPE_AUTO);
CefPostTask(TID_UI, BrowserTask::newTask([&] {
f(browser);
os_event_signal(finishedEvent);
}));
os_event_wait(finishedEvent);
os_event_destroy(finishedEvent);
}
}
}
bool obs_output_actual_start(obs_output_t *output)
{
bool success = false;
os_event_wait(output->stopping_event);
output->stop_code = 0;
if (output->context.data)
success = output->info.start(output->context.data);
if (success && output->video) {
output->starting_frame_count =
video_output_get_total_frames(output->video);
output->starting_skipped_frame_count =
video_output_get_skipped_frames(output->video);
output->starting_drawn_count = obs->video.total_frames;
output->starting_lagged_count = obs->video.lagged_frames;
}
if (os_atomic_load_long(&output->delay_restart_refs))
os_atomic_dec_long(&output->delay_restart_refs);
return success;
}
// same in userspace as a normal wait
osal_result os_event_hardwait(os_event_t* p_event,
unsigned long wait_ms) //in milliseconds
{
return os_event_wait(p_event, wait_ms);
}
