gst-log-parser 0.5.0

Crate providing a convenient API to parse GStreamer logs
Documentation 
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

// Copyright (C) 2017-2019 Guillaume Desmottes <guillaume@desmottes.be>
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.

// Generate input logs with: GST_DEBUG="GST_TRACER:7" GST_TRACERS=latency

use gst_log_parser::parse;
use gstreamer::{ClockTime, DebugLevel};
use std::fs::File;
use std::path::PathBuf;
use structopt::StructOpt;

#[derive(StructOpt, Debug, PartialEq, Copy, Clone)]
#[structopt(name = "command")]
enum Command {
    #[structopt(
        name = "filter-higher",
        about = "Check for latency higher than a value"
    )]
    FilterHigher {
        #[structopt(help = "The minimum latency to display, in ms")]
        min: u64,
    },
}

#[derive(StructOpt, Debug)]
#[structopt(
    name = "check-latency",
    about = "Process logs generated by the 'latency' tracer"
)]
struct Opt {
    #[structopt(parse(from_os_str))]
    input: PathBuf,
    #[structopt(subcommand)]
    command: Command,
}

fn main() -> Result<(), anyhow::Error> {
    let opt = Opt::from_args();
    let input = File::open(opt.input)?;

    let parsed = parse(input)
        .filter(|entry| entry.category == "GST_TRACER" && entry.level == DebugLevel::Trace);

    for entry in parsed {
        let s = match entry.message_to_struct() {
            None => continue,
            Some(s) => s,
        };

        if s.name() != "latency" && s.name() != "element-latency" {
            continue;
        }

        let latency = s.get::<ClockTime>("time").unwrap();
        match opt.command {
            Command::FilterHigher { min } => {
                let min_time = ClockTime::from_mseconds(min);
                if latency >= min_time {
                    println!("{}", entry);
                }
            }
        }
    }

    Ok(())
}