static void show_tree(obs_source_t parent, obs_source_t child, void *param)
{
if (os_atomic_inc_long(&child->show_refs) == 1)
show_source(child);
UNUSED_PARAMETER(parent);
UNUSED_PARAMETER(param);
}
void obs_source_activate(obs_source_t source, enum view_type type)
{
if (!source) return;
if (os_atomic_inc_long(&source->show_refs) == 1) {
show_source(source);
obs_source_enum_tree(source, show_tree, NULL);
}
if (type == MAIN_VIEW) {
if (os_atomic_inc_long(&source->activate_refs) == 1) {
activate_source(source);
obs_source_enum_tree(source, activate_tree, NULL);
obs_source_set_present_volume(source, 1.0f);
}
}
}
static bool new_frame_ready(obs_source_t source, uint64_t sys_time)
{
struct source_frame *next_frame = source->video_frames.array[0];
struct source_frame *frame = NULL;
uint64_t sys_offset = sys_time - source->last_sys_timestamp;
uint64_t frame_time = next_frame->timestamp;
uint64_t frame_offset = 0;
/* account for timestamp invalidation */
if (frame_out_of_bounds(source, frame_time)) {
source->last_frame_ts = next_frame->timestamp;
os_atomic_inc_long(&source->av_sync_ref);
} else {
frame_offset = frame_time - source->last_frame_ts;
source->last_frame_ts += frame_offset;
}
while (frame_offset <= sys_offset) {
source_frame_destroy(frame);
if (source->video_frames.num == 1)
return true;
frame = next_frame;
da_erase(source->video_frames, 0);
next_frame = source->video_frames.array[0];
/* more timestamp checking and compensating */
if ((next_frame->timestamp - frame_time) > MAX_TIMESTAMP_JUMP) {
source->last_frame_ts =
next_frame->timestamp - frame_offset;
os_atomic_inc_long(&source->av_sync_ref);
}
frame_time = next_frame->timestamp;
frame_offset = frame_time - source->last_frame_ts;
}
return frame != NULL;
}
void obs_source_enum_sources(obs_source_t source,
obs_source_enum_proc_t enum_callback,
void *param)
{
if (!source || !source->info.enum_sources || source->enum_refs)
return;
obs_source_addref(source);
os_atomic_inc_long(&source->enum_refs);
source->info.enum_sources(source->context.data, enum_callback, param);
os_atomic_dec_long(&source->enum_refs);
obs_source_release(source);
}
static void enum_source_tree_callback(obs_source_t parent, obs_source_t child,
void *param)
{
struct source_enum_data *data = param;
if (child->info.enum_sources && !child->enum_refs) {
os_atomic_inc_long(&child->enum_refs);
child->info.enum_sources(child->context.data,
enum_source_tree_callback, data);
os_atomic_dec_long(&child->enum_refs);
}
data->enum_callback(parent, child, data->param);
}
static inline struct obs_source_frame *get_prev_frame(obs_source_t *source,
bool *updated)
{
struct obs_source_frame *frame = NULL;
pthread_mutex_lock(&source->async_mutex);
*updated = source->cur_async_frame != NULL;
frame = source->prev_async_frame;
source->prev_async_frame = NULL;
if (frame)
os_atomic_inc_long(&frame->refs);
pthread_mutex_unlock(&source->async_mutex);
return frame;
}
void gs_entercontext(graphics_t graphics)
{
if (!graphics) return;
bool is_current = thread_graphics == graphics;
if (thread_graphics && !is_current) {
while (thread_graphics)
gs_leavecontext();
}
if (!is_current) {
pthread_mutex_lock(&graphics->mutex);
graphics->exports.device_entercontext(graphics->device);
thread_graphics = graphics;
}
os_atomic_inc_long(&graphics->ref);
}
void obs_output_signal_stop(obs_output_t *output, int code)
{
if (!obs_output_valid(output, "obs_output_signal_stop"))
return;
output->stop_code = code;
if (can_reconnect(output, code)) {
if (delay_active(output))
os_atomic_inc_long(&output->delay_restart_refs);
obs_output_end_data_capture_internal(output, false);
output_reconnect(output);
} else {
if (delay_active(output))
os_atomic_set_bool(&output->delay_active, false);
obs_output_end_data_capture(output);
}
}
bool DeckLinkOutput::Activate(DeckLinkDevice *device, long long modeId)
{
std::lock_guard<std::recursive_mutex> lock(deviceMutex);
DeckLinkDevice *curDevice = GetDevice();
const bool same = device == curDevice;
const bool isActive = instance != nullptr;
if (same) {
if (!isActive)
return false;
if (instance->GetActiveModeId() == modeId &&
instance->GetActivePixelFormat() == pixelFormat &&
instance->GetActiveColorSpace() == colorSpace &&
instance->GetActiveColorRange() == colorRange &&
instance->GetActiveChannelFormat() == channelFormat)
return false;
}
if (isActive)
instance->StopOutput();
if (!same)
instance.Set(new DeckLinkDeviceInstance(this, device));
if (instance == nullptr)
return false;
DeckLinkDeviceMode *mode = GetDevice()->FindOutputMode(modeId);
if (mode == nullptr) {
instance = nullptr;
return false;
}
if (!instance->StartOutput(mode)) {
instance = nullptr;
return false;
}
os_atomic_inc_long(&activateRefs);
return true;
}
void obs_source_addref(obs_source_t source)
{
if (source)
os_atomic_inc_long(&source->refs);
}
ULONG DeckLinkDevice::AddRef()
{
return os_atomic_inc_long(&refCount);
}
ULONG STDMETHODCALLTYPE DeckLinkDeviceInstance::AddRef(void)
{
return os_atomic_inc_long(&refCount);
}
