libobs-sources 2.0.2

A helper crate to create sources for OBS
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

# libOBS Sources

This crate makes it really easy to create new sources for OBS Studio using the [libobs-wrapper](http://crates.io/crates/libobs-wrapper) crate.

## Example

```rust
let rec_file = ObsPath::from_relative("monitor_capture.mp4").build();
let path_out = PathBuf::from(rec_file.to_string());

// Start the OBS context
let startup_info = StartupInfo::default();

// You can also create use a logger to log to a file
// let _l = DebugLogger { f: File::create(current_dir().unwrap().join("obs.log")).unwrap() };
// startup_info = startup_info.set_logger(Box::new(_l));

let mut context = ObsContext::new(startup_info).unwrap();

// Set up output to ./recording.mp4
let mut output_settings = ObsData::new();
output_settings.set_string("path", rec_file);

let output_name = "output";
let output_info = OutputInfo::new("ffmpeg_muxer", output_name, Some(output_settings), None);

let mut output = context.output(output_info).unwrap();

// Register the video encoder
let mut video_settings = ObsData::new();
video_settings
    .set_int("bf", 0)
    .set_bool("psycho_aq", true)
    .set_bool("lookahead", true)
    .set_string("profile", "high")
    .set_string("preset", "fast")
    .set_string("rate_control", "cbr")
    .set_int("bitrate", 10000);

let encoders = ObsContext::get_available_video_encoders();

println!("Available encoders: {:?}", encoders);
let encoder =  encoders.iter().find(|e| **e == ObsVideoEncoderType::H264_TEXTURE_AMF || **e == ObsVideoEncoderType::AV1_TEXTURE_AMF).unwrap();

println!("Using encoder {:?}", encoder);
let video_info = VideoEncoderInfo::new(
    encoder.clone(),
    "video_encoder",
    Some(video_settings),
    None,
);

let video_handler = ObsContext::get_video_ptr().unwrap();
output.video_encoder(video_info, video_handler).unwrap();

// Register the audio encoder
let mut audio_settings = ObsData::new();
audio_settings.set_int("bitrate", 160);

let audio_info =
    AudioEncoderInfo::new("ffmpeg_aac", "audio_encoder", Some(audio_settings), None);

let audio_handler = ObsContext::get_audio_ptr().unwrap();
output.audio_encoder(audio_info, 0, audio_handler).unwrap();
let mut scene = context.scene("main");

let monitor = MonitorCaptureSourceBuilder::get_monitors().unwrap()[1].clone();
println!("Using monitor {:?}", monitor);
let mut capture_source = MonitorCaptureSourceBuilder::new("monitor_test")
    .set_monitor(&monitor)
    .add_to_scene(&mut scene)
    .unwrap();

scene.add_and_set(0);
output.start().unwrap();

println!("Recording started");
std::thread::sleep(Duration::from_secs(5));
println!("Recording stop");

output.stop().unwrap();
// And now your monitor is recorded to ./recording.mp4 !
```