-
-
Notifications
You must be signed in to change notification settings - Fork 7.7k
/
obs.h
2779 lines (2221 loc) · 98.2 KB
/
obs.h
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
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
/******************************************************************************
Copyright (C) 2023 by Lain Bailey <lain@obsproject.com>
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
******************************************************************************/
#pragma once
#include "util/c99defs.h"
#include "util/bmem.h"
#include "util/profiler.h"
#include "util/text-lookup.h"
#include "graphics/graphics.h"
#include "graphics/vec2.h"
#include "graphics/vec3.h"
#include "media-io/audio-io.h"
#include "media-io/video-io.h"
#include "callback/signal.h"
#include "callback/proc.h"
#include "obs-config.h"
#include "obs-defs.h"
#include "obs-data.h"
#include "obs-properties.h"
#include "obs-interaction.h"
struct matrix4;
/* opaque types */
struct obs_context_data;
struct obs_display;
struct obs_view;
struct obs_source;
struct obs_scene;
struct obs_scene_item;
struct obs_output;
struct obs_encoder;
struct obs_encoder_group;
struct obs_service;
struct obs_module;
struct obs_fader;
struct obs_volmeter;
typedef struct obs_context_data obs_object_t;
typedef struct obs_display obs_display_t;
typedef struct obs_view obs_view_t;
typedef struct obs_source obs_source_t;
typedef struct obs_scene obs_scene_t;
typedef struct obs_scene_item obs_sceneitem_t;
typedef struct obs_output obs_output_t;
typedef struct obs_encoder obs_encoder_t;
typedef struct obs_encoder_group obs_encoder_group_t;
typedef struct obs_service obs_service_t;
typedef struct obs_module obs_module_t;
typedef struct obs_fader obs_fader_t;
typedef struct obs_volmeter obs_volmeter_t;
typedef struct obs_weak_object obs_weak_object_t;
typedef struct obs_weak_source obs_weak_source_t;
typedef struct obs_weak_output obs_weak_output_t;
typedef struct obs_weak_encoder obs_weak_encoder_t;
typedef struct obs_weak_service obs_weak_service_t;
#include "obs-missing-files.h"
#include "obs-source.h"
#include "obs-encoder.h"
#include "obs-output.h"
#include "obs-service.h"
#include "obs-audio-controls.h"
#include "obs-hotkey.h"
/**
* @file
* @brief Main libobs header used by applications.
*
* @mainpage
*
* @section intro_sec Introduction
*
* This document describes the api for libobs to be used by applications as well
* as @ref modules_page implementing some kind of functionality.
*
*/
#ifdef __cplusplus
extern "C" {
#endif
/** Used for changing the order of items (for example, filters in a source,
* or items in a scene) */
enum obs_order_movement {
OBS_ORDER_MOVE_UP,
OBS_ORDER_MOVE_DOWN,
OBS_ORDER_MOVE_TOP,
OBS_ORDER_MOVE_BOTTOM,
};
/**
* Used with obs_source_process_filter to specify whether the filter should
* render the source directly with the specified effect, or whether it should
* render it to a texture
*/
enum obs_allow_direct_render {
OBS_NO_DIRECT_RENDERING,
OBS_ALLOW_DIRECT_RENDERING,
};
enum obs_scale_type {
OBS_SCALE_DISABLE,
OBS_SCALE_POINT,
OBS_SCALE_BICUBIC,
OBS_SCALE_BILINEAR,
OBS_SCALE_LANCZOS,
OBS_SCALE_AREA,
};
enum obs_blending_method {
OBS_BLEND_METHOD_DEFAULT,
OBS_BLEND_METHOD_SRGB_OFF,
};
enum obs_blending_type {
OBS_BLEND_NORMAL,
OBS_BLEND_ADDITIVE,
OBS_BLEND_SUBTRACT,
OBS_BLEND_SCREEN,
OBS_BLEND_MULTIPLY,
OBS_BLEND_LIGHTEN,
OBS_BLEND_DARKEN,
};
/**
* Used with scene items to indicate the type of bounds to use for scene items.
* Mostly determines how the image will be scaled within those bounds, or
* whether to use bounds at all.
*/
enum obs_bounds_type {
OBS_BOUNDS_NONE, /**< no bounds */
OBS_BOUNDS_STRETCH, /**< stretch (ignores base scale) */
OBS_BOUNDS_SCALE_INNER, /**< scales to inner rectangle */
OBS_BOUNDS_SCALE_OUTER, /**< scales to outer rectangle */
OBS_BOUNDS_SCALE_TO_WIDTH, /**< scales to the width */
OBS_BOUNDS_SCALE_TO_HEIGHT, /**< scales to the height */
OBS_BOUNDS_MAX_ONLY, /**< no scaling, maximum size only */
};
struct obs_transform_info {
struct vec2 pos;
float rot;
struct vec2 scale;
uint32_t alignment;
enum obs_bounds_type bounds_type;
uint32_t bounds_alignment;
struct vec2 bounds;
bool crop_to_bounds;
};
/**
* Video initialization structure
*/
struct obs_video_info {
#ifndef SWIG
/**
* Graphics module to use (usually "libobs-opengl" or "libobs-d3d11")
*/
const char *graphics_module;
#endif
uint32_t fps_num; /**< Output FPS numerator */
uint32_t fps_den; /**< Output FPS denominator */
uint32_t base_width; /**< Base compositing width */
uint32_t base_height; /**< Base compositing height */
uint32_t output_width; /**< Output width */
uint32_t output_height; /**< Output height */
enum video_format output_format; /**< Output format */
/** Video adapter index to use (NOTE: avoid for optimus laptops) */
uint32_t adapter;
/** Use shaders to convert to different color formats */
bool gpu_conversion;
enum video_colorspace colorspace; /**< YUV type (if YUV) */
enum video_range_type range; /**< YUV range (if YUV) */
enum obs_scale_type scale_type; /**< How to scale if scaling */
};
/**
* Audio initialization structure
*/
struct obs_audio_info {
uint32_t samples_per_sec;
enum speaker_layout speakers;
};
struct obs_audio_info2 {
uint32_t samples_per_sec;
enum speaker_layout speakers;
uint32_t max_buffering_ms;
bool fixed_buffering;
};
/**
* Sent to source filters via the filter_audio callback to allow filtering of
* audio data
*/
struct obs_audio_data {
uint8_t *data[MAX_AV_PLANES];
uint32_t frames;
uint64_t timestamp;
};
/**
* Source audio output structure. Used with obs_source_output_audio to output
* source audio. Audio is automatically resampled and remixed as necessary.
*/
struct obs_source_audio {
const uint8_t *data[MAX_AV_PLANES];
uint32_t frames;
enum speaker_layout speakers;
enum audio_format format;
uint32_t samples_per_sec;
uint64_t timestamp;
};
struct obs_source_cea_708 {
const uint8_t *data;
uint32_t packets;
uint64_t timestamp;
};
#define OBS_SOURCE_FRAME_LINEAR_ALPHA (1 << 0)
/**
* Source asynchronous video output structure. Used with
* obs_source_output_video to output asynchronous video. Video is buffered as
* necessary to play according to timestamps. When used with audio output,
* audio is synced to video as it is played.
*
* If a YUV format is specified, it will be automatically upsampled and
* converted to RGB via shader on the graphics processor.
*
* NOTE: Non-YUV formats will always be treated as full range with this
* structure! Use obs_source_frame2 along with obs_source_output_video2
* instead if partial range support is desired for non-YUV video formats.
*/
struct obs_source_frame {
uint8_t *data[MAX_AV_PLANES];
uint32_t linesize[MAX_AV_PLANES];
uint32_t width;
uint32_t height;
uint64_t timestamp;
enum video_format format;
float color_matrix[16];
bool full_range;
uint16_t max_luminance;
float color_range_min[3];
float color_range_max[3];
bool flip;
uint8_t flags;
uint8_t trc; /* enum video_trc */
/* used internally by libobs */
volatile long refs;
bool prev_frame;
};
struct obs_source_frame2 {
uint8_t *data[MAX_AV_PLANES];
uint32_t linesize[MAX_AV_PLANES];
uint32_t width;
uint32_t height;
uint64_t timestamp;
enum video_format format;
enum video_range_type range;
float color_matrix[16];
float color_range_min[3];
float color_range_max[3];
bool flip;
uint8_t flags;
uint8_t trc; /* enum video_trc */
};
/** Access to the argc/argv used to start OBS. What you see is what you get. */
struct obs_cmdline_args {
int argc;
char **argv;
};
/* ------------------------------------------------------------------------- */
/* OBS context */
/**
* Find a core libobs data file
* @param path name of the base file
* @return A string containing the full path to the file.
* Use bfree after use.
*/
EXPORT char *obs_find_data_file(const char *file);
/**
* Add a path to search libobs data files in.
* @param path Full path to directory to look in.
* The string is copied.
*/
EXPORT void obs_add_data_path(const char *path);
/**
* Remove a path from libobs core data paths.
* @param path The path to compare to currently set paths.
* It does not need to be the same pointer, but
* the path string must match an entry fully.
* @return Whether or not the path was successfully removed.
* If false, the path could not be found.
*/
EXPORT bool obs_remove_data_path(const char *path);
/**
* Initializes OBS
*
* @param locale The locale to use for modules
* @param module_config_path Path to module config storage directory
* (or NULL if none)
* @param store The profiler name store for OBS to use or NULL
*/
EXPORT bool obs_startup(const char *locale, const char *module_config_path,
profiler_name_store_t *store);
/** Releases all data associated with OBS and terminates the OBS context */
EXPORT void obs_shutdown(void);
/** @return true if the main OBS context has been initialized */
EXPORT bool obs_initialized(void);
/** @return The current core version */
EXPORT uint32_t obs_get_version(void);
/** @return The current core version string */
EXPORT const char *obs_get_version_string(void);
/**
* Sets things up for calls to obs_get_cmdline_args. Called only once at startup
* and safely copies argv/argc from main(). Subsequent calls do nothing.
*
* @param argc The count of command line arguments, from main()
* @param argv An array of command line arguments, copied from main() and ends
* with NULL.
*/
EXPORT void obs_set_cmdline_args(int argc, const char *const *argv);
/**
* Get the argc/argv used to start OBS
*
* @return The command line arguments used for main(). Don't modify this or
* you'll mess things up for other callers.
*/
EXPORT struct obs_cmdline_args obs_get_cmdline_args(void);
/**
* Sets a new locale to use for modules. This will call obs_module_set_locale
* for each module with the new locale.
*
* @param locale The locale to use for modules
*/
EXPORT void obs_set_locale(const char *locale);
/** @return the current locale */
EXPORT const char *obs_get_locale(void);
/** Initialize the Windows-specific crash handler */
#ifdef _WIN32
EXPORT void obs_init_win32_crash_handler(void);
#endif
/**
* Returns the profiler name store (see util/profiler.h) used by OBS, which is
* either a name store passed to obs_startup, an internal name store, or NULL
* in case obs_initialized() returns false.
*/
EXPORT profiler_name_store_t *obs_get_profiler_name_store(void);
/**
* Sets base video output base resolution/fps/format.
*
* @note This data cannot be changed if an output is currently active.
* @note The graphics module cannot be changed without fully destroying the
* OBS context.
*
* @param ovi Pointer to an obs_video_info structure containing the
* specification of the graphics subsystem,
* @return OBS_VIDEO_SUCCESS if successful
* OBS_VIDEO_NOT_SUPPORTED if the adapter lacks capabilities
* OBS_VIDEO_INVALID_PARAM if a parameter is invalid
* OBS_VIDEO_CURRENTLY_ACTIVE if video is currently active
* OBS_VIDEO_MODULE_NOT_FOUND if the graphics module is not found
* OBS_VIDEO_FAIL for generic failure
*/
EXPORT int obs_reset_video(struct obs_video_info *ovi);
/**
* Sets base audio output format/channels/samples/etc
*
* @note Cannot reset base audio if an output is currently active.
*/
EXPORT bool obs_reset_audio(const struct obs_audio_info *oai);
EXPORT bool obs_reset_audio2(const struct obs_audio_info2 *oai);
/** Gets the current video settings, returns false if no video */
EXPORT bool obs_get_video_info(struct obs_video_info *ovi);
/** Gets the SDR white level, returns 300.f if no video */
EXPORT float obs_get_video_sdr_white_level(void);
/** Gets the HDR nominal peak level, returns 1000.f if no video */
EXPORT float obs_get_video_hdr_nominal_peak_level(void);
/** Sets the video levels */
EXPORT void obs_set_video_levels(float sdr_white_level,
float hdr_nominal_peak_level);
/** Gets the current audio settings, returns false if no audio */
EXPORT bool obs_get_audio_info(struct obs_audio_info *oai);
/**
* Opens a plugin module directly from a specific path.
*
* If the module already exists then the function will return successful, and
* the module parameter will be given the pointer to the existing module.
*
* This does not initialize the module, it only loads the module image. To
* initialize the module, call obs_init_module.
*
* @param module The pointer to the created module.
* @param path Specifies the path to the module library file. If the
* extension is not specified, it will use the extension
* appropriate to the operating system.
* @param data_path Specifies the path to the directory where the module's
* data files are stored.
* @returns MODULE_SUCCESS if successful
* MODULE_ERROR if a generic error occurred
* MODULE_FILE_NOT_FOUND if the module was not found
* MODULE_MISSING_EXPORTS if required exports are missing
* MODULE_INCOMPATIBLE_VER if incompatible version
*/
EXPORT int obs_open_module(obs_module_t **module, const char *path,
const char *data_path);
/**
* Initializes the module, which calls its obs_module_load export. If the
* module is already loaded, then this function does nothing and returns
* successful.
*/
EXPORT bool obs_init_module(obs_module_t *module);
/** Returns a module based upon its name, or NULL if not found */
EXPORT obs_module_t *obs_get_module(const char *name);
/** Gets library of module */
EXPORT void *obs_get_module_lib(obs_module_t *module);
/** Returns locale text from a specific module */
EXPORT bool obs_module_get_locale_string(const obs_module_t *mod,
const char *lookup_string,
const char **translated_string);
EXPORT const char *obs_module_get_locale_text(const obs_module_t *mod,
const char *text);
/** Logs loaded modules */
EXPORT void obs_log_loaded_modules(void);
/** Returns the module file name */
EXPORT const char *obs_get_module_file_name(obs_module_t *module);
/** Returns the module full name */
EXPORT const char *obs_get_module_name(obs_module_t *module);
/** Returns the module author(s) */
EXPORT const char *obs_get_module_author(obs_module_t *module);
/** Returns the module description */
EXPORT const char *obs_get_module_description(obs_module_t *module);
/** Returns the module binary path */
EXPORT const char *obs_get_module_binary_path(obs_module_t *module);
/** Returns the module data path */
EXPORT const char *obs_get_module_data_path(obs_module_t *module);
#ifndef SWIG
/**
* Adds a module search path to be used with obs_find_modules. If the search
* path strings contain %module%, that text will be replaced with the module
* name when used.
*
* @param bin Specifies the module's binary directory search path.
* @param data Specifies the module's data directory search path.
*/
EXPORT void obs_add_module_path(const char *bin, const char *data);
/**
* Adds a module to the list of modules allowed to load in Safe Mode.
* If the list is empty, all modules are allowed.
*
* @param name Specifies the module's name (filename sans extension).
*/
EXPORT void obs_add_safe_module(const char *name);
/** Automatically loads all modules from module paths (convenience function) */
EXPORT void obs_load_all_modules(void);
struct obs_module_failure_info {
char **failed_modules;
size_t count;
};
EXPORT void obs_module_failure_info_free(struct obs_module_failure_info *mfi);
EXPORT void obs_load_all_modules2(struct obs_module_failure_info *mfi);
/** Notifies modules that all modules have been loaded. This function should
* be called after all modules have been loaded. */
EXPORT void obs_post_load_modules(void);
struct obs_module_info {
const char *bin_path;
const char *data_path;
};
typedef void (*obs_find_module_callback_t)(void *param,
const struct obs_module_info *info);
/** Finds all modules within the search paths added by obs_add_module_path. */
EXPORT void obs_find_modules(obs_find_module_callback_t callback, void *param);
struct obs_module_info2 {
const char *bin_path;
const char *data_path;
const char *name;
};
typedef void (*obs_find_module_callback2_t)(
void *param, const struct obs_module_info2 *info);
/** Finds all modules within the search paths added by obs_add_module_path. */
EXPORT void obs_find_modules2(obs_find_module_callback2_t callback,
void *param);
#endif
typedef void (*obs_enum_module_callback_t)(void *param, obs_module_t *module);
/** Enumerates all loaded modules */
EXPORT void obs_enum_modules(obs_enum_module_callback_t callback, void *param);
/** Helper function for using default module locale */
EXPORT lookup_t *obs_module_load_locale(obs_module_t *module,
const char *default_locale,
const char *locale);
/**
* Returns the location of a plugin module data file.
*
* @note Modules should use obs_module_file function defined in obs-module.h
* as a more elegant means of getting their files without having to
* specify the module parameter.
*
* @param module The module associated with the file to locate
* @param file The file to locate
* @return Path string, or NULL if not found. Use bfree to free string.
*/
EXPORT char *obs_find_module_file(obs_module_t *module, const char *file);
/**
* Returns the path of a plugin module config file (whether it exists or not)
*
* @note Modules should use obs_module_config_path function defined in
* obs-module.h as a more elegant means of getting their files without
* having to specify the module parameter.
*
* @param module The module associated with the path
* @param file The file to get a path to
* @return Path string, or NULL if not found. Use bfree to free string.
*/
EXPORT char *obs_module_get_config_path(obs_module_t *module, const char *file);
/** Enumerates all source types (inputs, filters, transitions, etc). */
EXPORT bool obs_enum_source_types(size_t idx, const char **id);
/**
* Enumerates all available inputs source types.
*
* Inputs are general source inputs (such as capture sources, device sources,
* etc).
*/
EXPORT bool obs_enum_input_types(size_t idx, const char **id);
EXPORT bool obs_enum_input_types2(size_t idx, const char **id,
const char **unversioned_id);
EXPORT const char *obs_get_latest_input_type_id(const char *unversioned_id);
/**
* Enumerates all available filter source types.
*
* Filters are sources that are used to modify the video/audio output of
* other sources.
*/
EXPORT bool obs_enum_filter_types(size_t idx, const char **id);
/**
* Enumerates all available transition source types.
*
* Transitions are sources used to transition between two or more other
* sources.
*/
EXPORT bool obs_enum_transition_types(size_t idx, const char **id);
/** Enumerates all available output types. */
EXPORT bool obs_enum_output_types(size_t idx, const char **id);
/** Enumerates all available encoder types. */
EXPORT bool obs_enum_encoder_types(size_t idx, const char **id);
/** Enumerates all available service types. */
EXPORT bool obs_enum_service_types(size_t idx, const char **id);
/** Helper function for entering the OBS graphics context */
EXPORT void obs_enter_graphics(void);
/** Helper function for leaving the OBS graphics context */
EXPORT void obs_leave_graphics(void);
/** Gets the main audio output handler for this OBS context */
EXPORT audio_t *obs_get_audio(void);
/** Gets the main video output handler for this OBS context */
EXPORT video_t *obs_get_video(void);
/** Returns true if video is active, false otherwise */
EXPORT bool obs_video_active(void);
/** Sets the primary output source for a channel. */
EXPORT void obs_set_output_source(uint32_t channel, obs_source_t *source);
/**
* Gets the primary output source for a channel and increments the reference
* counter for that source. Use obs_source_release to release.
*/
EXPORT obs_source_t *obs_get_output_source(uint32_t channel);
/**
* Enumerates all input sources
*
* Callback function returns true to continue enumeration, or false to end
* enumeration.
*
* Use obs_source_get_ref or obs_source_get_weak_source if you want to retain
* a reference after obs_enum_sources finishes
*/
EXPORT void obs_enum_sources(bool (*enum_proc)(void *, obs_source_t *),
void *param);
/** Enumerates scenes */
EXPORT void obs_enum_scenes(bool (*enum_proc)(void *, obs_source_t *),
void *param);
/** Enumerates all sources (regardless of type) */
EXPORT void obs_enum_all_sources(bool (*enum_proc)(void *, obs_source_t *),
void *param);
/** Enumerates outputs */
EXPORT void obs_enum_outputs(bool (*enum_proc)(void *, obs_output_t *),
void *param);
/** Enumerates encoders */
EXPORT void obs_enum_encoders(bool (*enum_proc)(void *, obs_encoder_t *),
void *param);
/** Enumerates encoders */
EXPORT void obs_enum_services(bool (*enum_proc)(void *, obs_service_t *),
void *param);
/**
* Gets a source by its name.
*
* Increments the source reference counter, use obs_source_release to
* release it when complete.
*/
EXPORT obs_source_t *obs_get_source_by_name(const char *name);
/**
* Gets a source by its UUID.
*
* Increments the source reference counter, use obs_source_release to
* release it when complete.
*/
EXPORT obs_source_t *obs_get_source_by_uuid(const char *uuid);
/** Get a transition source by its name. */
EXPORT obs_source_t *obs_get_transition_by_name(const char *name);
/** Get a transition source by its UUID. */
EXPORT obs_source_t *obs_get_transition_by_uuid(const char *uuid);
/** Gets an output by its name. */
EXPORT obs_output_t *obs_get_output_by_name(const char *name);
/** Gets an encoder by its name. */
EXPORT obs_encoder_t *obs_get_encoder_by_name(const char *name);
/** Gets an service by its name. */
EXPORT obs_service_t *obs_get_service_by_name(const char *name);
enum obs_base_effect {
OBS_EFFECT_DEFAULT, /**< RGB/YUV */
OBS_EFFECT_DEFAULT_RECT, /**< RGB/YUV (using texture_rect) */
OBS_EFFECT_OPAQUE, /**< RGB/YUV (alpha set to 1.0) */
OBS_EFFECT_SOLID, /**< RGB/YUV (solid color only) */
OBS_EFFECT_BICUBIC, /**< Bicubic downscale */
OBS_EFFECT_LANCZOS, /**< Lanczos downscale */
OBS_EFFECT_BILINEAR_LOWRES, /**< Bilinear low resolution downscale */
OBS_EFFECT_PREMULTIPLIED_ALPHA, /**< Premultiplied alpha */
OBS_EFFECT_REPEAT, /**< RGB/YUV (repeating) */
OBS_EFFECT_AREA, /**< Area rescale */
};
/** Returns a commonly used base effect */
EXPORT gs_effect_t *obs_get_base_effect(enum obs_base_effect effect);
#ifndef SWIG
/* DEPRECATED: gets texture_rect default effect */
OBS_DEPRECATED
EXPORT gs_effect_t *obs_get_default_rect_effect(void);
#endif
/** Returns the primary obs signal handler */
EXPORT signal_handler_t *obs_get_signal_handler(void);
/** Returns the primary obs procedure handler */
EXPORT proc_handler_t *obs_get_proc_handler(void);
#ifndef SWIG
/** Renders the main view */
OBS_DEPRECATED
EXPORT void obs_render_main_view(void);
#endif
/** Renders the last main output texture */
EXPORT void obs_render_main_texture(void);
/** Renders the last main output texture ignoring background color */
EXPORT void obs_render_main_texture_src_color_only(void);
/** Returns the last main output texture. This can return NULL if the texture
* is unavailable. */
EXPORT gs_texture_t *obs_get_main_texture(void);
/** Sets the master user volume */
OBS_DEPRECATED EXPORT void obs_set_master_volume(float volume);
/** Gets the master user volume */
OBS_DEPRECATED EXPORT float obs_get_master_volume(void);
/** Saves a source to settings data */
EXPORT obs_data_t *obs_save_source(obs_source_t *source);
/** Loads a source from settings data */
EXPORT obs_source_t *obs_load_source(obs_data_t *data);
/** Loads a private source from settings data */
EXPORT obs_source_t *obs_load_private_source(obs_data_t *data);
/** Send a save signal to sources */
EXPORT void obs_source_save(obs_source_t *source);
/** Send a load signal to sources (soft deprecated; does not load filters) */
EXPORT void obs_source_load(obs_source_t *source);
/** Send a load signal to sources */
EXPORT void obs_source_load2(obs_source_t *source);
typedef void (*obs_load_source_cb)(void *private_data, obs_source_t *source);
/** Loads sources from a data array */
EXPORT void obs_load_sources(obs_data_array_t *array, obs_load_source_cb cb,
void *private_data);
/** Saves sources to a data array */
EXPORT obs_data_array_t *obs_save_sources(void);
typedef bool (*obs_save_source_filter_cb)(void *data, obs_source_t *source);
EXPORT obs_data_array_t *obs_save_sources_filtered(obs_save_source_filter_cb cb,
void *data);
/** Reset source UUIDs. NOTE: this function is only to be used by the UI and
* will be removed in a future version! */
EXPORT void obs_reset_source_uuids(void);
enum obs_obj_type {
OBS_OBJ_TYPE_INVALID,
OBS_OBJ_TYPE_SOURCE,
OBS_OBJ_TYPE_OUTPUT,
OBS_OBJ_TYPE_ENCODER,
OBS_OBJ_TYPE_SERVICE,
};
EXPORT enum obs_obj_type obs_obj_get_type(void *obj);
EXPORT const char *obs_obj_get_id(void *obj);
EXPORT bool obs_obj_invalid(void *obj);
EXPORT void *obs_obj_get_data(void *obj);
EXPORT bool obs_obj_is_private(void *obj);
typedef bool (*obs_enum_audio_device_cb)(void *data, const char *name,
const char *id);
EXPORT bool obs_audio_monitoring_available(void);
EXPORT void obs_reset_audio_monitoring(void);
EXPORT void obs_enum_audio_monitoring_devices(obs_enum_audio_device_cb cb,
void *data);
EXPORT bool obs_set_audio_monitoring_device(const char *name, const char *id);
EXPORT void obs_get_audio_monitoring_device(const char **name, const char **id);
EXPORT void obs_add_tick_callback(void (*tick)(void *param, float seconds),
void *param);
EXPORT void obs_remove_tick_callback(void (*tick)(void *param, float seconds),
void *param);
EXPORT void obs_add_main_render_callback(void (*draw)(void *param, uint32_t cx,
uint32_t cy),
void *param);
EXPORT void obs_remove_main_render_callback(
void (*draw)(void *param, uint32_t cx, uint32_t cy), void *param);
EXPORT void obs_add_main_rendered_callback(void (*rendered)(void *param),
void *param);
EXPORT void obs_remove_main_rendered_callback(void (*rendered)(void *param),
void *param);
EXPORT void obs_add_raw_video_callback(
const struct video_scale_info *conversion,
void (*callback)(void *param, struct video_data *frame), void *param);
EXPORT void obs_add_raw_video_callback2(
const struct video_scale_info *conversion, uint32_t frame_rate_divisor,
void (*callback)(void *param, struct video_data *frame), void *param);
EXPORT void obs_remove_raw_video_callback(
void (*callback)(void *param, struct video_data *frame), void *param);
EXPORT void
obs_add_raw_audio_callback(size_t mix_idx,
const struct audio_convert_info *conversion,
audio_output_callback_t callback, void *param);
EXPORT void obs_remove_raw_audio_callback(size_t mix_idx,
audio_output_callback_t callback,
void *param);
EXPORT uint64_t obs_get_video_frame_time(void);
EXPORT double obs_get_active_fps(void);
EXPORT uint64_t obs_get_average_frame_time_ns(void);
EXPORT uint64_t obs_get_frame_interval_ns(void);
EXPORT uint32_t obs_get_total_frames(void);
EXPORT uint32_t obs_get_lagged_frames(void);
EXPORT bool obs_nv12_tex_active(void);
EXPORT bool obs_p010_tex_active(void);
EXPORT void obs_apply_private_data(obs_data_t *settings);
EXPORT void obs_set_private_data(obs_data_t *settings);
EXPORT obs_data_t *obs_get_private_data(void);
typedef void (*obs_task_t)(void *param);
enum obs_task_type {
OBS_TASK_UI,
OBS_TASK_GRAPHICS,
OBS_TASK_AUDIO,
OBS_TASK_DESTROY,
};
EXPORT void obs_queue_task(enum obs_task_type type, obs_task_t task,
void *param, bool wait);
EXPORT bool obs_in_task_thread(enum obs_task_type type);
EXPORT bool obs_wait_for_destroy_queue(void);
typedef void (*obs_task_handler_t)(obs_task_t task, void *param, bool wait);
EXPORT void obs_set_ui_task_handler(obs_task_handler_t handler);
EXPORT obs_object_t *obs_object_get_ref(obs_object_t *object);
EXPORT void obs_object_release(obs_object_t *object);
EXPORT void obs_weak_object_addref(obs_weak_object_t *weak);
EXPORT void obs_weak_object_release(obs_weak_object_t *weak);
EXPORT obs_weak_object_t *obs_object_get_weak_object(obs_object_t *object);
EXPORT obs_object_t *obs_weak_object_get_object(obs_weak_object_t *weak);
EXPORT bool obs_weak_object_expired(obs_weak_object_t *weak);
EXPORT bool obs_weak_object_references_object(obs_weak_object_t *weak,
obs_object_t *object);
/* ------------------------------------------------------------------------- */
/* View context */
/**
* Creates a view context.
*
* A view can be used for things like separate previews, or drawing
* sources separately.
*/
EXPORT obs_view_t *obs_view_create(void);
/** Destroys this view context */
EXPORT void obs_view_destroy(obs_view_t *view);
/** Sets the source to be used for this view context. */
EXPORT void obs_view_set_source(obs_view_t *view, uint32_t channel,
obs_source_t *source);
/** Gets the source currently in use for this view context */
EXPORT obs_source_t *obs_view_get_source(obs_view_t *view, uint32_t channel);
/** Renders the sources of this view context */
EXPORT void obs_view_render(obs_view_t *view);
/** Adds a view to the main render loop, with current obs_get_video_info state */
EXPORT video_t *obs_view_add(obs_view_t *view);
/** Adds a view to the main render loop, with custom video settings */
EXPORT video_t *obs_view_add2(obs_view_t *view, struct obs_video_info *ovi);
/** Removes a view from the main render loop */
EXPORT void obs_view_remove(obs_view_t *view);
/** Gets the video settings currently in use for this view context, returns false if no video */
OBS_DEPRECATED EXPORT bool obs_view_get_video_info(obs_view_t *view,
struct obs_video_info *ovi);
/** Enumerate the video info of all mixes using the specified view context */
EXPORT void obs_view_enum_video_info(obs_view_t *view,
bool (*enum_proc)(void *,
struct obs_video_info *),
void *param);
/* ------------------------------------------------------------------------- */
/* Display context */
/**
* Adds a new window display linked to the main render pipeline. This creates
* a new swap chain which updates every frame.
*
* @param graphics_data The swap chain initialization data.
* @return The new display context, or NULL if failed.
*/
EXPORT obs_display_t *
obs_display_create(const struct gs_init_data *graphics_data,
uint32_t backround_color);
/** Destroys a display context */
EXPORT void obs_display_destroy(obs_display_t *display);
/** Changes the size of this display */
EXPORT void obs_display_resize(obs_display_t *display, uint32_t cx,
uint32_t cy);
/** Updates the color space of this display */
EXPORT void obs_display_update_color_space(obs_display_t *display);
/**
* Adds a draw callback for this display context
*
* @param display The display context.
* @param draw The draw callback which is called each time a frame
* updates.
* @param param The user data to be associated with this draw callback.
*/
EXPORT void obs_display_add_draw_callback(obs_display_t *display,
void (*draw)(void *param, uint32_t cx,
uint32_t cy),