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 void rtmp_stream_destroy(void *data) { struct rtmp_stream *stream = data; if (stopping(stream) && !connecting(stream)) { pthread_join(stream->send_thread, NULL); } else if (connecting(stream) || active(stream)) { if (stream->connecting) pthread_join(stream->connect_thread, NULL); os_event_signal(stream->stop_event); if (active(stream)) { os_sem_post(stream->send_sem); obs_output_end_data_capture(stream->output); pthread_join(stream->send_thread, NULL); } } if (stream) { free_packets(stream); dstr_free(&stream->path); dstr_free(&stream->key); dstr_free(&stream->username); dstr_free(&stream->password); dstr_free(&stream->encoder_name); os_event_destroy(stream->stop_event); os_sem_destroy(stream->send_sem); pthread_mutex_destroy(&stream->packets_mutex); circlebuf_free(&stream->packets); bfree(stream); } }
void obs_output_destroy(obs_output_t output) { if (output) { obs_context_data_remove(&output->context); if (output->valid && output->active) obs_output_stop(output); if (output->service) output->service->output = NULL; free_packets(output); if (output->context.data) output->info.destroy(output->context.data); if (output->video_encoder) { obs_encoder_remove_output(output->video_encoder, output); } if (output->audio_encoder) { obs_encoder_remove_output(output->audio_encoder, output); } pthread_mutex_destroy(&output->interleaved_mutex); os_event_destroy(output->reconnect_stop_event); obs_context_data_free(&output->context); bfree(output); } }
void audio_output_close(audio_t audio) { void *thread_ret; struct audio_line *line; if (!audio) return; if (audio->initialized) { os_event_signal(audio->stop_event); pthread_join(audio->thread, &thread_ret); } line = audio->first_line; while (line) { struct audio_line *next = line->next; audio_line_destroy_data(line); line = next; } for (size_t i = 0; i < audio->inputs.num; i++) audio_input_free(audio->inputs.array+i); for (size_t i = 0; i < MAX_AV_PLANES; i++) da_free(audio->mix_buffers[i]); da_free(audio->inputs); os_event_destroy(audio->stop_event); pthread_mutex_destroy(&audio->line_mutex); bfree(audio); }
static void rtmp_stream_destroy(void *data) { struct rtmp_stream *stream = data; if (stopping(stream) && !connecting(stream)) { pthread_join(stream->send_thread, NULL); } else if (connecting(stream) || active(stream)) { if (stream->connecting) pthread_join(stream->connect_thread, NULL); stream->stop_ts = 0; os_event_signal(stream->stop_event); if (active(stream)) { os_sem_post(stream->send_sem); obs_output_end_data_capture(stream->output); pthread_join(stream->send_thread, NULL); } } free_packets(stream); dstr_free(&stream->path); dstr_free(&stream->key); dstr_free(&stream->username); dstr_free(&stream->password); dstr_free(&stream->encoder_name); dstr_free(&stream->bind_ip); os_event_destroy(stream->stop_event); os_sem_destroy(stream->send_sem); pthread_mutex_destroy(&stream->packets_mutex); circlebuf_free(&stream->packets); #ifdef TEST_FRAMEDROPS circlebuf_free(&stream->droptest_info); #endif os_event_destroy(stream->buffer_space_available_event); os_event_destroy(stream->buffer_has_data_event); os_event_destroy(stream->socket_available_event); os_event_destroy(stream->send_thread_signaled_exit); pthread_mutex_destroy(&stream->write_buf_mutex); if (stream->write_buf) bfree(stream->write_buf); bfree(stream); }
void video_output_close(video_t video) { if (!video) return; video_output_stop(video); for (size_t i = 0; i < video->inputs.num; i++) video_input_free(&video->inputs.array[i]); da_free(video->inputs); os_event_destroy(video->update_event); os_event_destroy(video->stop_event); pthread_mutex_destroy(&video->data_mutex); pthread_mutex_destroy(&video->input_mutex); bfree(video); }
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); } }
static void sinewave_destroy(void *data) { struct sinewave_data *swd = data; if (swd) { if (swd->initialized_thread) { void *ret; os_event_signal(swd->event); pthread_join(swd->thread, &ret); } os_event_destroy(swd->event); bfree(swd); } }
static void v4l2_terminate(struct v4l2_data *data) { if (data->thread) { os_event_signal(data->event); pthread_join(data->thread, NULL); os_event_destroy(data->event); data->thread = 0; } v4l2_destroy_mmap(&data->buffers); if (data->dev != -1) { v4l2_close(data->dev); data->dev = -1; } }
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); } }
static void rtmp_stream_destroy(void *data) { struct rtmp_stream *stream = data; if (stream->active) rtmp_stream_stop(data); if (stream) { free_packets(stream); dstr_free(&stream->path); dstr_free(&stream->key); dstr_free(&stream->username); dstr_free(&stream->password); os_event_destroy(stream->stop_event); os_sem_destroy(stream->send_sem); pthread_mutex_destroy(&stream->packets_mutex); circlebuf_free(&stream->packets); bfree(stream); } }
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; }
/* * Destroy the plugin object and free all memory */ static void pulse_destroy(void *vptr) { PULSE_DATA(vptr); if (!data) return; if (data->thread) { void *ret; os_event_signal(data->event); pthread_join(data->thread, &ret); } os_event_destroy(data->event); pa_proplist_free(data->props); blog(LOG_DEBUG, "pulse-input: Input destroyed"); bfree(data); }
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); } } }
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 && output->active) obs_output_stop(output); if (output->service) output->service->output = NULL; free_packets(output); if (output->context.data) output->info.destroy(output->context.data); 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); } } pthread_mutex_destroy(&output->interleaved_mutex); os_event_destroy(output->reconnect_stop_event); obs_context_data_free(&output->context); bfree(output); } }
void audio_output_close(audio_t *audio) { void *thread_ret; if (!audio) return; if (audio->initialized) { os_event_signal(audio->stop_event); pthread_join(audio->thread, &thread_ret); } for (size_t mix_idx = 0; mix_idx < MAX_AUDIO_MIXES; mix_idx++) { struct audio_mix *mix = &audio->mixes[mix_idx]; for (size_t i = 0; i < mix->inputs.num; i++) audio_input_free(mix->inputs.array+i); da_free(mix->inputs); } os_event_destroy(audio->stop_event); bfree(audio); }