rs4a-vapix 0.1.0

Utilities for working with VAPIX
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
72
73
74
75
76
77
78

//! Bindings for the [JPEG image snapsnot API](https://developer.axis.com/vapix/network-video/video-streaming/#jpeg-image-snapshot).
use anyhow::{bail, Context};

use crate::Client;

pub struct Request {
    resolution: Option<String>,
    compression: Option<u8>,
}

impl Request {
    /// The image resolution in the format `"{width}x{height}"`.
    ///
    /// Example: `"640x360"`.
    ///
    /// Valid values are product-dependent.
    // TODO: Document how to retrieve valid values.
    pub fn resolution(mut self, resolution: &str) -> Self {
        self.resolution = Some(resolution.to_string());
        self
    }

    /// Image compressions expressed as a number in `0..=100`.
    ///
    /// Example: `80`.
    ///
    /// A compression value yields lower image quality.
    pub fn compression(mut self, compression: u8) -> Self {
        self.compression = Some(compression);
        self
    }
}

impl Request {
    pub async fn send(self, client: &Client) -> anyhow::Result<Vec<u8>> {
        let Self {
            resolution,
            compression,
        } = self;
        let mut query = Vec::new();
        if let Some(resolution) = resolution.as_deref() {
            query.push(("resolution", resolution));
        }
        let compression = compression.map(|c| c.to_string());
        if let Some(compression) = compression.as_deref() {
            query.push(("compression", compression));
        }
        let resp = client
            .get("axis-cgi/jpg/image.cgi")?
            .query(&query)
            .send()
            .await?;

        let resp = resp.error_for_status()?;

        let status = resp.status();
        let bytes = resp
            .bytes()
            .await
            .map(|b| b.to_vec())
            .with_context(|| format!("Failed to get image; status: {status}"))?;

        let magic = b"\xFF\xD8\xFF";
        if !bytes.starts_with(magic) {
            bail!("Expected magic bytes {magic:?}, but got {:?}", &bytes[..3])
        }

        Ok(bytes)
    }
}

/// Get a jpg encoded snapshot.
pub fn get_image() -> Request {
    Request {
        resolution: None,
        compression: None,
    }
}