libmpv2

https://docs.rs/libmpv2/5.0.3/libmpv2/
Admin
libmpv2 is a Rust crate that provides abstractions for libmpv of the mpv media player, enabling...
Tokens:50,616
Snippets:409
Trust Score:9.1
Update:6 months ago
Show doc for...
Tokens:
Raw
### Split and Get Substring Ranges

Source: https://docs.rs/libmpv2/5.0.3/libmpv2/struct.MpvStr.html

This example demonstrates splitting a string and obtaining the byte range of substrings using the `substr_range` method, which is an unstable feature.

```rust
#![feature(substr_range)]

let data = "a, b, b, a";
let mut iter = data.split(", ").map(|s| data.substr_range(s).unwrap());

assert_eq!(iter.next(), Some(0..1));
assert_eq!(iter.next(), Some(3..4));
assert_eq!(iter.next(), Some(6..7));
assert_eq!(iter.next(), Some(9..10));

```

--------------------------------

### pub fn starts_with<P>(&self, pat: P) -> bool

Source: https://docs.rs/libmpv2/5.0.3/libmpv2/struct.MpvStr.html

Checks if the string slice starts with a given pattern.

```APIDOC
## starts_with

### Description
Returns true if the given pattern matches a prefix of this string slice.

### Parameters
- **pat** (Pattern) - Required - The pattern to check as a prefix.

### Response
- **result** (bool) - Returns true if the string starts with the pattern.
```

--------------------------------

### Writing mpv Property with Node

Source: https://docs.rs/libmpv2/5.0.3/libmpv2/mpv_format/constant.Node.html

Example demonstrating how to set an mpv property using an mpv_node. The API handles copying, so you can manage memory as you see fit.

```c
mpv_node value;
value.format = MPV_FORMAT_STRING;
value.u.string = "hello";
mpv_set_property(ctx, "property", MPV_FORMAT_NODE, &value);
```

--------------------------------

### Trim Prefix Example

Source: https://docs.rs/libmpv2/5.0.3/libmpv2/struct.MpvStr.html

Demonstrates removing a prefix from a string slice. This is a nightly-only experimental API.

```rust
#![feature(trim_prefix_suffix)]

// Prefix present - removes it
assert_eq!("foo:bar".trim_prefix("foo:"), "bar");
assert_eq!("foofoo".trim_prefix("foo"), "foo");

// Prefix absent - returns original string
assert_eq!("foo:bar".trim_prefix("bar"), "foo:bar");

// Method chaining example
assert_eq!("<https://example.com/>".trim_prefix('<').trim_suffix('>'), "https://example.com/");
```

--------------------------------

### Command and Property Management

Source: https://docs.rs/libmpv2/5.0.3/libmpv2/struct.Mpv.html

APIs for sending commands, setting, and getting properties of the MPV instance.

```APIDOC
## POST /mpv/{mpv_instance_id}/command

### Description
Send a command to the player. Commands are the same as those used in input.conf.

### Method
POST

### Endpoint
/mpv/{mpv_instance_id}/command

### Parameters
#### Path Parameters
- **mpv_instance_id** (string) - Required - The identifier of the MPV instance.

#### Request Body
- **name** (string) - Required - The name of the command to send.
- **args** (array of strings) - Required - The arguments for the command.

### Response
#### Success Response (200)
Indicates the command was successfully sent.

#### Response Example
```json
{
  "status": "success"
}
```

## POST /mpv/{mpv_instance_id}/set_property

### Description
Set a property to a given value. Properties are essentially variables which can be queried or set at runtime. For example, writing to the pause property will actually pause or unpause playback.
Will return `Err` If the format `T` doesn’t match with the internal format of the property and it also fails to convert to `T`.

### Method
POST

### Endpoint
/mpv/{mpv_instance_id}/set_property

### Parameters
#### Path Parameters
- **mpv_instance_id** (string) - Required - The identifier of the MPV instance.

#### Request Body
- **name** (string) - Required - The name of the property to set.
- **data** (any) - Required - The value to set the property to. The type `T` should match the expected property type.

### Response
#### Success Response (200)
Indicates the property was successfully set.

#### Response Example
```json
{
  "status": "success"
}
```

## GET /mpv/{mpv_instance_id}/get_property

### Description
Read the value of the given property. Tries to convert the value to the given format `T` if it does not match.
Will return `Err` If the format `T` doesn’t match with the internal format of the property and it also fails to convert to `T`.

### Method
GET

### Endpoint
/mpv/{mpv_instance_id}/get_property

### Parameters
#### Path Parameters
- **mpv_instance_id** (string) - Required - The identifier of the MPV instance.

#### Query Parameters
- **name** (string) - Required - The name of the property to retrieve.
- **type** (string) - Required - The expected type `T` to convert the property value to.

### Response
#### Success Response (200)
- **value** (any) - The retrieved property value, converted to the specified type `T`.

#### Response Example
```json
{
  "value": "<property_value>"
}
```
```

--------------------------------

### Trim Suffix Example

Source: https://docs.rs/libmpv2/5.0.3/libmpv2/struct.MpvStr.html

Demonstrates removing a suffix from a string slice. This is a nightly-only experimental API.

```rust
#![feature(trim_prefix_suffix)]

// Suffix present - removes it
assert_eq!("bar:foo".trim_suffix(":foo"), "bar");
assert_eq!("foofoo".trim_suffix("foo"), "foo");

// Suffix absent - returns original string
assert_eq!("bar:foo".trim_suffix("bar"), "bar:foo");

// Method chaining example
assert_eq!("<https://example.com/>".trim_prefix('<').trim_suffix('>'), "https://example.com/");
```

--------------------------------

### Trim start matching characters from strings

Source: https://docs.rs/libmpv2/5.0.3/libmpv2/struct.MpvStr.html

Removes all prefixes that match a pattern repeatedly from the start of the string.

```rust
assert_eq!("11foo1bar11".trim_start_matches('1'), "foo1bar11");
assert_eq!("123foo1bar123".trim_start_matches(char::is_numeric), "foo1bar123");

let x: &[_] = &['1', '2'];
assert_eq!("12foo1bar12".trim_start_matches(x), "foo1bar12");
```

--------------------------------

### Reading mpv Property with Node

Source: https://docs.rs/libmpv2/5.0.3/libmpv2/mpv_format/constant.Node.html

Example demonstrating how to read an mpv property into an mpv_node. Always check the format member after reading and free node contents when done.

```c
mpv_node result;
if (mpv_get_property(ctx, "property", MPV_FORMAT_NODE, &result) < 0)
    goto error;
printf("format=%d\n", (int)result.format);
mpv_free_node_contents(&result).
```

--------------------------------

### Write Flag Property in C

Source: https://docs.rs/libmpv2/5.0.3/libmpv2/mpv_format/constant.Flag.html

Example demonstrating how to write a flag property using `mpv_set_property`. The flag is set to 1, representing 'yes' or 'true'.

```c
int flag = 1;
mpv_set_property(ctx, "property", MPV_FORMAT_FLAG, &flag);
```

--------------------------------

### Checking if String Starts With a Pattern

Source: https://docs.rs/libmpv2/5.0.3/libmpv2/struct.MpvStr.html

Illustrates the `starts_with` method to verify if a string slice begins with a specified pattern. Supports string slices and character slices for prefix matching.

```rust
let bananas = "bananas";

assert!(bananas.starts_with("bana"));
assert!(!bananas.starts_with("nana"));
```

```rust
let bananas = "bananas";

// Note that both of these assert successfully.
assert!(bananas.starts_with(&['b', 'a', 'n', 'a']));
assert!(bananas.starts_with(&['a', 'b', 'c', 'd']));
```

--------------------------------

### Trim Left Matches Example (Deprecated)

Source: https://docs.rs/libmpv2/5.0.3/libmpv2/struct.MpvStr.html

Removes all prefixes that match a pattern. This method is deprecated and superseded by `trim_start_matches`.

```rust
assert_eq!("11foo1bar11".trim_left_matches('1'), "foo1bar11");
assert_eq!("123foo1bar123".trim_left_matches(char::is_numeric), "foo1bar123");

let x: &[_] = &['1', '2'];
assert_eq!("12foo1bar12".trim_left_matches(x), "foo1bar12");
```

--------------------------------

### GET /property (String Format)

Source: https://docs.rs/libmpv2/5.0.3/libmpv2/mpv_format/constant.String.html

Retrieves a property value as a raw string using the MPV_FORMAT_STRING format.

```APIDOC
## GET /property (String Format)

### Description
Retrieves the raw property string. Note that while usually UTF-8, encoding may vary depending on the source (e.g., file tags).

### Method
GET

### Request Example
char *result = NULL;
if (mpv_get_property(ctx, "property", MPV_FORMAT_STRING, &result) < 0)
    goto error;
printf("%s\n", result);
mpv_free(result);
```

--------------------------------

### Read Flag Property in C

Source: https://docs.rs/libmpv2/5.0.3/libmpv2/mpv_format/constant.Flag.html

Example demonstrating how to read a flag property using `mpv_get_property`. The property is expected to be a boolean value, printed as 'true' or 'false'.

```c
int result;
if (mpv_get_property(ctx, "property", MPV_FORMAT_FLAG, &result) < 0)
    goto error;
printf("%s\n", result ? "true" : "false");
```

--------------------------------

### rsplitn with closure: Split string using a closure as a delimiter

Source: https://docs.rs/libmpv2/5.0.3/libmpv2/struct.MpvStr.html

This example demonstrates using a closure with `rsplitn` to define a more complex splitting logic based on character properties.

```rust
let v: Vec<&str> = "abc1defXghi".rsplitn(2, |c| c == '1' || c == 'X').collect();
assert_eq!(v, ["ghi", "abc1def"]);
```

--------------------------------

### Trim Right Matches Example (Deprecated)

Source: https://docs.rs/libmpv2/5.0.3/libmpv2/struct.MpvStr.html

Removes all suffixes that match a pattern. This method is deprecated and superseded by `trim_end_matches`.

```rust
assert_eq!("11foo1bar11".trim_right_matches('1'), "11foo1bar");
assert_eq!("123foo1bar123".trim_right_matches(char::is_numeric), "123foo1bar");

let x: &[_] = &['1', '2'];
assert_eq!("12foo1bar12".trim_right_matches(x), "12foo1bar");
```

```rust
assert_eq!("1fooX".trim_right_matches(|c| c == '1' || c == 'X'), "1foo");
```

--------------------------------

### Trim End Matches Example

Source: https://docs.rs/libmpv2/5.0.3/libmpv2/struct.MpvStr.html

Removes all suffixes that match a pattern. The pattern can be a &str, char, slice of chars, or a closure.

```rust
assert_eq!("11foo1bar11".trim_end_matches('1'), "11foo1bar");
assert_eq!("123foo1bar123".trim_end_matches(char::is_numeric), "123foo1bar");

let x: &[_] = &['1', '2'];
assert_eq!("12foo1bar12".trim_end_matches(x), "12foo1bar");
```

```rust
assert_eq!("1fooX".trim_end_matches(|c| c == '1' || c == 'X'), "1foo");
```

--------------------------------

### Mpv Initialization

Source: https://docs.rs/libmpv2/5.0.3/libmpv2/struct.Mpv.html

Provides methods for creating and initializing new `Mpv` instances with different configuration approaches.

```APIDOC
## POST /mpv/new

### Description
Create and initialize a new `Mpv` instance with default options. Use `with_initializer` instead if you want to set options. Unlike the command line player, this will have initial settings suitable for embedding in applications. The following settings are different:
  * stdin/stdout/stderr and the terminal will never be accessed. This is equivalent to setting the –no-terminal option. (Technically, this also suppresses C signal handling.)
  * No config files will be loaded. This is roughly equivalent to using –config=no. You can re-enable this option, which will make libmpv load config files during mpv_initialize(). If you do this, you are strongly encouraged to set the “config-dir” option too. (Otherwise it will load the mpv command line player’s config.)
  * Idle mode is enabled, which means the playback core will enter idle mode if there are no more files to play on the internal playlist, instead of exiting. This is equivalent to the –idle option.
  * Disable parts of input handling.
  * Most of the different settings can be viewed with the command line player by running “mpv –show-profile=libmpv”.

All this assumes that API users want a mpv instance that is strictly isolated from the command line player’s configuration, user settings, and so on. You can re-enable disabled features by setting the appropriate options.
The mpv command line parser is not available through this API, but you can set individual options with `set_property`. Files for playback must be loaded with `command` or others.
Note that you should avoid doing concurrent accesses on the uninitialized `Mpv` instance. (Whether concurrent access is definitely allowed or not has yet to be decided.)
Will return `Err` if out of memory or LC_NUMERIC is not set to "C".

### Method
POST

### Endpoint
/mpv/new

### Response
#### Success Response (200)
- **Mpv** (object) - A new Mpv instance.

#### Response Example
```json
{
  "mpv_instance": "<mpv_instance_id>"
}
```

## POST /mpv/with_initializer

### Description
Create and initialize a new `Mpv` instance with options set by the `initializer`. The following options can’t be set after initialization:
  1. options which are only read at initialization time: 
     * config
     * config-dir
     * input-conf
     * load-scripts
     * script
     * player-operation-mode
     * input-app-events (OSX)
  2. all encoding mode options

Will return `Err` if out of memory or LC_NUMERIC is not set to "C" or `initializer` fails.

### Method
POST

### Endpoint
/mpv/with_initializer

### Request Body
- **initializer** (function) - A closure that takes an `MpvInitializer` and returns a `Result<()>`.

### Request Example
```json
{
  "initializer": "fn(init) -> Result<()> { init.set_option(\"config-dir\", \"test-data\")?; init.set_option(\"config\", \"mpv.conf\")?; Ok(()) }"
}
```

### Response
#### Success Response (200)
- **Mpv** (object) - A new Mpv instance.

#### Response Example
```json
{
  "mpv_instance": "<mpv_instance_id>"
}
```
```

--------------------------------

### Create a New Protocol

Source: https://docs.rs/libmpv2/5.0.3/libmpv2/protocol/struct.Protocol.html

Constructs a new Protocol instance. The `name` parameter is a URI prefix like `name://path`. `user_data` is passed to `open_fn`. Do not call libmpv functions within supplied callbacks; panics are caught and returned as errors.

```rust
pub unsafe fn new( mpv: &'parent Mpv, name: String, user_data: U, open_fn: StreamOpen<T, U>, close_fn: StreamClose<T>, read_fn: StreamRead<T>, seek_fn: Option<StreamSeek<T>>, size_fn: Option<StreamSize<T>>, ) -> Protocol<'parent, T, U>
```

--------------------------------

### match_indices

Source: https://docs.rs/libmpv2/5.0.3/libmpv2/struct.MpvStr.html

Returns an iterator over the disjoint matches of a pattern and their starting indices.

```APIDOC
## match_indices

### Description
Returns an iterator over the disjoint matches of a pattern within this string slice as well as the index that the match starts at.

### Method
`match_indices`

### Endpoint
N/A (String method)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```rust
let v: Vec<_> = "abcXXXabcYYYabc".match_indices("abc").collect();
```

### Response
#### Success Response (200)
Returns a `MatchIndices` iterator.

#### Response Example
```rust
assert_eq!(v, [(0, "abc"), (6, "abc"), (12, "abc")]);
```
```

--------------------------------

### Initialize Mpv with custom options

Source: https://docs.rs/libmpv2/5.0.3/libmpv2/struct.Mpv.html

Use with_initializer to configure specific mpv options like config directories before the player instance is fully initialized.

```rust
Mpv::with_initializer(|init| {
    init.set_option("config-dir", "test-data")?;
    init.set_option("config", "mpv.conf")?;
    Ok(())
});
```

--------------------------------

### Time Retrieval

Source: https://docs.rs/libmpv2/5.0.3/libmpv2/struct.Mpv.html

Provides functions to get the current time in nanoseconds and microseconds.

```APIDOC
## GET /mpv/{mpv_instance_id}/get_time_ns

### Description
Return the internal time in nanoseconds. This has an arbitrary start offset, but will never wrap or go backwards. Note that this is always the real time, and doesn’t necessarily have to do with playback time. For example, playback could go faster or slower due to playback speed, or due to playback being paused. Use the “time-pos” property instead to get the playback status. Unlike other libmpv APIs, this can be called at absolutely any time (even within wakeup callbacks), as long as the context is valid. Safe to be called from mpv render API threads.

### Method
GET

### Endpoint
/mpv/{mpv_instance_id}/get_time_ns

### Parameters
#### Path Parameters
- **mpv_instance_id** (string) - Required - The identifier of the MPV instance.

### Response
#### Success Response (200)
- **time_ns** (integer) - The current time in nanoseconds.

#### Response Example
```json
{
  "time_ns": 1678886400000000000
}
```

## GET /mpv/{mpv_instance_id}/get_time_us

### Description
Same as get_time_ns but in microseconds.

### Method
GET

### Endpoint
/mpv/{mpv_instance_id}/get_time_us

### Parameters
#### Path Parameters
- **mpv_instance_id** (string) - Required - The identifier of the MPV instance.

### Response
#### Success Response (200)
- **time_us** (integer) - The current time in microseconds.

#### Response Example
```json
{
  "time_us": 1678886400000000
}
```
```

--------------------------------

### Protocol::new

Source: https://docs.rs/libmpv2/5.0.3/libmpv2/protocol/struct.Protocol.html

Constructs a new Protocol instance.

```APIDOC
## pub unsafe fn new(
    mpv: &'parent Mpv,
    name: String,
    user_data: U,
    open_fn: StreamOpen<T, U>,
    close_fn: StreamClose<T>,
    read_fn: StreamRead<T>,
    seek_fn: Option<StreamSeek<T>>,
    size_fn: Option<StreamSize<T>>,
) -> Protocol<'parent, T, U>

### Description
Creates a new `Protocol` instance.

`name` is the prefix of the protocol, e.g. `name://path`.
`user_data` is data that will be passed to `open_fn`.

### Safety
Do not call libmpv functions in any supplied function. All panics of the provided functions are catched and can be used as generic error returns.
```

--------------------------------

### rsplitn

Source: https://docs.rs/libmpv2/5.0.3/libmpv2/struct.MpvStr.html

Splits a string into a specified number of subslices using a delimiter, starting from the end.

```APIDOC
## rsplitn

### Description
Splits a string into a specified number of subslices using a delimiter, starting from the end.

### Method
`rsplitn`

### Endpoint
N/A (String method)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```rust
let v: Vec<&str> = "Mary had a little lamb".rsplitn(3, ' ').collect();
```

### Response
#### Success Response (200)
Returns a `Vec<&str>` containing the subslices.

#### Response Example
```rust
assert_eq!(v, ["lamb", "little", "Mary had a"]);
```
```

--------------------------------

### FileLoaded Event Constant

Source: https://docs.rs/libmpv2/5.0.3/libmpv2/events/mpv_event_id/constant.FileLoaded.html

Represents the event ID for when a file is loaded and decoding starts.

```rust
pub const FileLoaded: u32 = 8; // 8u32
```

--------------------------------

### Type ID Implementation

Source: https://docs.rs/libmpv2/5.0.3/libmpv2/render/enum.RenderFrameInfoFlag.html

Gets the `TypeId` of the `RenderFrameInfoFlag` type. This is part of the `Any` trait implementation.

```rust
impl<T> Any for T where T: 'static + ?Sized {
    fn type_id(&self) -> TypeId {
        // ... implementation details ...
    }
}
```

--------------------------------

### CloneToUninit Implementation (Nightly)

Source: https://docs.rs/libmpv2/5.0.3/libmpv2/render/enum.RenderFrameInfoFlag.html

An experimental nightly-only API for copying `RenderFrameInfoFlag` to uninitialized memory. Use with caution.

```rust
impl<T> CloneToUninit for T where T: Clone {
    unsafe fn clone_to_uninit(&self, dest: *mut u8) {
        // ... implementation details ...
    }
}
```

--------------------------------

### Constant: StartFile

Source: https://docs.rs/libmpv2/5.0.3/libmpv2/events/mpv_event_id/constant.StartFile.html

Documentation for the StartFile event identifier constant in libmpv2.

```APIDOC
## CONSTANT StartFile

### Description
Notification before playback start of a file (before the file is loaded). See also mpv_event and mpv_event_start_file.

### Value
6 (u32)
```

--------------------------------

### Define PropertyError constant

Source: https://docs.rs/libmpv2/5.0.3/libmpv2/mpv_error/constant.PropertyError.html

Represents an error state when setting or getting a property in libmpv2.

```rust
pub const PropertyError: i32 = -11;
```

--------------------------------

### Load Config File with MpvInitializer

Source: https://docs.rs/libmpv2/5.0.3/libmpv2/struct.MpvInitializer.html

Loads and parses a configuration file, setting options from its default section. The path should be absolute; otherwise, the path used is unspecified. Returns an error if the file is not found or parsing fails.

```rust
pub fn load_config(&self, path: &str) -> Result<()>
```

--------------------------------

### PropertyFormat Constant

Source: https://docs.rs/libmpv2/5.0.3/libmpv2/mpv_error/constant.PropertyFormat.html

The PropertyFormat constant indicates an unsupported MPV_FORMAT when attempting to set or get a property.

```APIDOC
## PropertyFormat Constant

### Description
This constant, `PropertyFormat`, is used within the `libmpv2` library to signify an error condition. Specifically, it is returned or used when an attempt is made to set or get a property using an MPV_FORMAT that is not supported by the MPV player.

### Constant Value
```rust
pub const PropertyFormat: i32 = -9;
```

### Usage Context
This constant is relevant in scenarios involving direct interaction with MPV properties, such as through the `mpv_set_property` or `mpv_get_property` functions (or their equivalents in the `libmpv2` Rust bindings). If an operation fails due to an invalid format specifier, this constant might be involved in error reporting or checking.
```

--------------------------------

### MpvInitializer Methods

Source: https://docs.rs/libmpv2/5.0.3/libmpv2/struct.MpvInitializer.html

Methods available on the MpvInitializer struct for configuring MPV settings.

```APIDOC
## set_property

### Description
Set a property to a given value. Properties are variables which can be queried or set at runtime.

### Parameters
- **name** (str) - Required - The name of the property.
- **data** (T) - Required - The value to set.

### Response
- **Result<()>** - Returns Ok if successful, or Err if the format T doesn't match or conversion fails.

## set_option

### Description
Set the value of an option.

### Parameters
- **name** (str) - Required - The name of the option.
- **data** (T) - Required - The value to set.

## load_config

### Description
Load a config file. This loads and parses the file, and sets every entry in the config file's default section.

### Parameters
- **path** (str) - Required - The absolute path to the config file.

### Response
- **Result<()>** - Returns Ok if successful, or Err if the file is not found or parsing fails.
```

--------------------------------

### Define StartFile constant

Source: https://docs.rs/libmpv2/5.0.3/libmpv2/events/mpv_event_id/constant.StartFile.html

Represents the notification event ID triggered before a file begins playback.

```rust
pub const StartFile: u32 = 6; // 6u32
```

--------------------------------

### rsplitn

Source: https://docs.rs/libmpv2/5.0.3/libmpv2/struct.MpvStr.html

Returns an iterator over substrings separated by a pattern, starting from the end, restricted to returning at most n items.

```APIDOC
## rsplitn(n: usize, pat: P)

### Description
Returns an iterator over substrings of this string slice, separated by a pattern, starting from the end of the string, restricted to returning at most n items.

### Parameters
- **n** (usize) - Required - Maximum number of items to return.
- **pat** (Pattern) - Required - The pattern to split by (must support reverse search).
```

--------------------------------

### Get string length in bytes

Source: https://docs.rs/libmpv2/5.0.3/libmpv2/struct.MpvStr.html

Returns the length of the string in bytes. This may differ from the human-perceived character count.

```rust
let len = "foo".len();
assert_eq!(3, len);

assert_eq!("ƒoo".len(), 4); // fancy f!
assert_eq!("ƒoo".chars().count(), 3);
```

--------------------------------

### Mpv Client Creation

Source: https://docs.rs/libmpv2/5.0.3/libmpv2/struct.Mpv.html

Allows creating a new client associated with an existing MPV instance.

```APIDOC
## POST /mpv/{mpv_instance_id}/create_client

### Description
Creates a new client associated with the given MPV instance.

### Method
POST

### Endpoint
/mpv/{mpv_instance_id}/create_client

### Parameters
#### Path Parameters
- **mpv_instance_id** (string) - Required - The identifier of the MPV instance.

#### Request Body
- **name** (string) - Optional - The name for the new client.

### Response
#### Success Response (200)
- **Mpv** (object) - A new Mpv client instance.

#### Response Example
```json
{
  "mpv_instance": "<new_client_instance_id>"
}
```
```

--------------------------------

### Constant: None

Source: https://docs.rs/libmpv2/5.0.3/libmpv2/mpv_format/constant.None.html

Documentation for the mpv_format::None constant.

```APIDOC
## Constant: None

### Description
Represents an invalid or empty value for mpv_format. This constant is defined as 0, ensuring that zero-initialized structures (like mpv_node) default to MPV_FORMAT_NONE.

### Value
0 (u32)
```

--------------------------------

### Safely get string subslice

Source: https://docs.rs/libmpv2/5.0.3/libmpv2/struct.MpvStr.html

Returns an `Option` containing a subslice of the string, or `None` if the indices are invalid or not on UTF-8 boundaries.

```rust
let v = String::from("🗻∈🌏");

assert_eq!(Some("🗻"), v.get(0..4));

// indices not on UTF-8 sequence boundaries
assert!(v.get(1..).is_none());
assert!(v.get(..8).is_none());

// out of bounds
assert!(v.get(..42).is_none());
```

--------------------------------

### Event Handling Overview

Source: https://docs.rs/libmpv2/5.0.3/libmpv2/events/index.html

Provides an overview of the event handling capabilities in libmpv2.

```APIDOC
## Module events

libmpv2 provides mechanisms for handling events.

### Enums

#### Event

Represents different types of events that can occur.

### Type Aliases

#### EventId

An alias for an `Event`’s ID, used for identifying specific events.
```

--------------------------------

### Get raw pointer to string bytes

Source: https://docs.rs/libmpv2/5.0.3/libmpv2/struct.MpvStr.html

Converts a string slice to a raw pointer to its first byte. The pointer must not be written to.

```rust
let s = "Hello";
let ptr = s.as_ptr();
```

--------------------------------

### libmpv2::mpv_error::Unsupported

Source: https://docs.rs/libmpv2/5.0.3/libmpv2/mpv_error/constant.Unsupported.html

Constant for signaling unsupported system requirements.

```APIDOC
## Constant Unsupported

### Description
Generic error for signaling that certain system requirements are not fulfilled.

### Summary
```
pub const Unsupported: i32 = -18;
```
```

--------------------------------

### Iterate Over Bytes

Source: https://docs.rs/libmpv2/5.0.3/libmpv2/struct.MpvStr.html

Use `bytes()` to get an iterator over the individual bytes of a string slice. This is a low-level view of the string's UTF-8 representation.

```rust
let mut bytes = "bors".bytes();

assert_eq!(Some(b'b'), bytes.next());
assert_eq!(Some(b'o'), bytes.next());
assert_eq!(Some(b'r'), bytes.next());
assert_eq!(Some(b's'), bytes.next());

assert_eq!(None, bytes.next());
```

--------------------------------

### Constants

Source: https://docs.rs/libmpv2/5.0.3/libmpv2/mpv_error/constant.Uninitialized.html

Documentation for constants within the libmpv2 library.

```APIDOC
## Constant Uninitialized

### Description
The mpv core wasn’t configured and initialized yet. See the notes in mpv_create().

### Value
`pub const Uninitialized: i32 = -3;`
```

--------------------------------

### Check for character boundary

Source: https://docs.rs/libmpv2/5.0.3/libmpv2/struct.MpvStr.html

Checks if a given byte index is the start of a UTF-8 code point or the end of the string. Returns false if the index is out of bounds.

```rust
let s = "Löwe 老虎 Léopard";
assert!(s.is_char_boundary(0));
// start of `老`
assert!(s.is_char_boundary(6));
assert!(s.is_char_boundary(s.len()));

// second byte of `ö`
assert!(!s.is_char_boundary(2));

// third byte of `老`
assert!(!s.is_char_boundary(8));
```

--------------------------------

### From and Into Traits

Source: https://docs.rs/libmpv2/5.0.3/libmpv2/render/struct.RenderContext.html

Documentation for the From and Into traits, which facilitate type conversions.

```APIDOC
## From<T> for T

### Description
Returns the argument unchanged.

### Method
`from(t: T) -> T`

## Into<U> for T

### Description
Calls `U::from(self)`. This conversion is whatever the implementation of `From<T> for U` chooses to do.

### Method
`into(self) -> U`
```

--------------------------------

### Iterate Over Characters with Indices

Source: https://docs.rs/libmpv2/5.0.3/libmpv2/struct.MpvStr.html

Use `char_indices()` to get an iterator over the Unicode scalar values and their byte indices. This is useful for correctly handling multi-byte characters.

```rust
let word = "goodbye";

let count = word.char_indices().count();
assert_eq!(7, count);

let mut char_indices = word.char_indices();

assert_eq!(Some((0, 'g')), char_indices.next());
assert_eq!(Some((1, 'o')), char_indices.next());
assert_eq!(Some((2, 'o')), char_indices.next());
assert_eq!(Some((3, 'd')), char_indices.next());
assert_eq!(Some((4, 'b')), char_indices.next());
assert_eq!(Some((5, 'y')), char_indices.next());
assert_eq!(Some((6, 'e')), char_indices.next());

assert_eq!(None, char_indices.next());
```

```rust
let yes = "y̆es";

let mut char_indices = yes.char_indices();

assert_eq!(Some((0, 'y')), char_indices.next()); // not (0, 'y̆')
assert_eq!(Some((1, '\u{0306}')), char_indices.next());

// note the 3 here - the previous character took up two bytes
assert_eq!(Some((3, 'e')), char_indices.next());
assert_eq!(Some((4, 's')), char_indices.next());

assert_eq!(None, char_indices.next());
```

--------------------------------

### trim_start

Source: https://docs.rs/libmpv2/5.0.3/libmpv2/struct.MpvStr.html

Returns a string slice with leading whitespace removed.

```APIDOC
## trim_start

### Description
Returns a string slice with leading whitespace removed. In this context, 'start' refers to the first position of the byte string.
```

--------------------------------

### Unsafely get string subslice

Source: https://docs.rs/libmpv2/5.0.3/libmpv2/struct.MpvStr.html

Returns an unchecked subslice of the string. Callers must ensure indices are valid, within bounds, and on UTF-8 boundaries.

```rust
let v = "🗻∈🌏";
unsafe {
    assert_eq!("🗻", v.get_unchecked(0..4));
    assert_eq!("∈", v.get_unchecked(4..7));
    assert_eq!("🌏", v.get_unchecked(7..11));
}
```

--------------------------------

### libmpv2::mpv_error::UnknownFormat

Source: https://docs.rs/libmpv2/5.0.3/libmpv2/mpv_error/constant.UnknownFormat.html

Represents an error where the file format could not be determined or the file was too broken to open.

```APIDOC
## Constant UnknownFormat

### Description
When trying to load the file, the file format could not be determined, or the file was too broken to open it.

### Value
```
pub const UnknownFormat: i32 = -17;
```
```

--------------------------------

### PropertyUnavailable Constant Definition

Source: https://docs.rs/libmpv2/5.0.3/libmpv2/mpv_error/constant.PropertyUnavailable.html

This constant signifies that a property is not available, typically because the associated subsystem is inactive. For example, querying audio parameters when audio is disabled.

```rust
pub const PropertyUnavailable: i32 = -10;
```

--------------------------------

### Module render

Source: https://docs.rs/libmpv2/5.0.3/libmpv2/render/index.html

Provides functionalities for custom rendering using libmpv2.

```APIDOC
## Module render

Provides functionalities for custom rendering using libmpv2.

### Structs

*   **FBO**
    For RenderParam::FBO
*   **OpenGLInitParams**
    For initializing the mpv OpenGL state via RenderParam::OpenGLInitParams
*   **RenderContext**

### Enums

*   **RenderFrameInfoFlag**
*   **RenderParam**
*   **RenderParamApiType**

### Type Aliases

*   **MpvRenderUpdate**
    Flags returned by mpv_render_context_update(). Each value represents a bit in the function’s return value.
```

--------------------------------

### Register a Protocol

Source: https://docs.rs/libmpv2/5.0.3/libmpv2/protocol/struct.Protocol.html

Registers the Protocol with libmpv. Callbacks are invoked when a URI with a matching prefix is opened. Returns an error if a protocol with the same name is already registered.

```rust
pub fn register(&self) -> Result<()>
```

--------------------------------

### Constant: OptionFormat

Source: https://docs.rs/libmpv2/5.0.3/libmpv2/mpv_error/constant.OptionFormat.html

Represents an error occurring when attempting to set an option using an unsupported MPV_FORMAT.

```APIDOC
## Constant: OptionFormat

### Description
Represents an error state returned by libmpv2 when an attempt is made to set an option using an unsupported MPV_FORMAT.

### Value
- **Value**: -6
- **Type**: i32
```

--------------------------------

### Perform reverse string splitting with rsplit

Source: https://docs.rs/libmpv2/5.0.3/libmpv2/struct.MpvStr.html

Demonstrates splitting a string into substrings in reverse order using characters, strings, or closures as patterns.

```rust
let v: Vec<&str> = "Mary had a little lamb".rsplit(' ').collect();
assert_eq!(v, ["lamb", "little", "a", "had", "Mary"]);

let v: Vec<&str> = "".rsplit('X').collect();
assert_eq!(v, [""]);

let v: Vec<&str> = "lionXXtigerXleopard".rsplit('X').collect();
assert_eq!(v, ["leopard", "tiger", "", "lion"]);

let v: Vec<&str> = "lion::tiger::leopard".rsplit("::").collect();
assert_eq!(v, ["leopard", "tiger", "lion"]);
```

```rust
let v: Vec<&str> = "abc1defXghi".rsplit(|c| c == '1' || c == 'X').collect();
assert_eq!(v, ["ghi", "def", "abc"]);
```

--------------------------------

### match_indices: Find indices and values of all disjoint matches

Source: https://docs.rs/libmpv2/5.0.3/libmpv2/struct.MpvStr.html

The `match_indices` method returns an iterator yielding tuples of the starting index and the matched substring for each non-overlapping occurrence of a pattern.

```rust
let v: Vec<_> = "abcXXXabcYYYabc".match_indices("abc").collect();
assert_eq!(v, [(0, "abc"), (6, "abc"), (12, "abc")]);
```

```rust
let v: Vec<_> = "1abcabc2".match_indices("abc").collect();
assert_eq!(v, [(1, "abc"), (4, "abc")]);
```

```rust
let v: Vec<_> = "ababa".match_indices("aba").collect();
assert_eq!(v, [(0, "aba")]); // only the first `aba`
```

--------------------------------

### Constant: NothingToPlay

Source: https://docs.rs/libmpv2/5.0.3/libmpv2/mpv_error/constant.NothingToPlay.html

Documentation for the NothingToPlay error constant in libmpv2.

```APIDOC
## Constant: NothingToPlay

### Description
Indicates that there was no audio or video data to play. This occurs if the file was recognized but contained no audio or video streams, or if no streams were selected.

### Value
- **NothingToPlay** (i32) - -16
```

--------------------------------

### Parse String Slice Example

Source: https://docs.rs/libmpv2/5.0.3/libmpv2/struct.MpvStr.html

Parses a string slice into another type that implements the `FromStr` trait. Requires explicit type annotation using the turbofish syntax.

```rust
pub fn parse<F>(&self) -> Result<F, <F as FromStr>::Err>
where F: FromStr,
```

--------------------------------

### libmpv2::mpv_log_level::Warn Constant

Source: https://docs.rs/libmpv2/5.0.3/libmpv2/mpv_log_level/constant.Warn.html

Documentation for the `Warn` constant within the `mpv_log_level` module.

```APIDOC
## Constant Warn

### Description
Represents a log level for simple errors.

### Value
`30` (u32)
```

--------------------------------

### libmpv2::mpv_end_file_reason::Redirect Constant

Source: https://docs.rs/libmpv2/5.0.3/libmpv2/mpv_end_file_reason/constant.Redirect.html

Documentation for the Redirect constant within the mpv_end_file_reason enum.

```APIDOC
## Constant libmpv2::mpv_end_file_reason::Redirect

### Description
The file was a playlist or similar. When the playlist is read, its entries will be appended to the playlist after the entry of the current file, the entry of the current file is removed, and a MPV_EVENT_END_FILE event is sent with reason set to MPV_END_FILE_REASON_REDIRECT. Then playback continues with the playlist contents. Since API version 1.18.

### Summary
```rust
pub const Redirect: u32 = 5; // 5u32
```

### Type
u32
```

--------------------------------

### Constants in libmpv2

Source: https://docs.rs/libmpv2/5.0.3/libmpv2/all.html

Lists the constants defined in the libmpv2 crate, including API version information and specific event/error/format codes.

```APIDOC
## Constants

### MPV_CLIENT_API_MAJOR
Major version of the MPV client API.

### MPV_CLIENT_API_MINOR
Minor version of the MPV client API.

### MPV_CLIENT_API_VERSION
Full version of the MPV client API.

### events::mpv_event_id::*
Constants representing various MPV event IDs (e.g., AudioReconfig, ClientMessage, EndFile).

### mpv_end_file_reason::*
Constants indicating the reason for ending file playback (e.g., Eof, Error, Quit).

### mpv_error::*
Constants representing MPV error codes (e.g., AoInitFailed, Command, Generic).

### mpv_format::*
Constants defining MPV data formats (e.g., Array, Double, Int64).

### mpv_log_level::*
Constants for MPV logging levels (e.g., Debug, Error, Info).

### render::mpv_render_update::Frame
Constant related to frame updates in rendering.
```

--------------------------------

### char_indices() - Iterate over characters with their byte indices

Source: https://docs.rs/libmpv2/5.0.3/libmpv2/struct.MpvStr.html

Provides an iterator over the characters of a string slice along with their starting byte indices. This is useful for understanding character boundaries and their byte representations, especially with Unicode.

```APIDOC
## char_indices()

### Description
Returns an iterator over the characters of a string slice along with their starting byte indices.

### Method
`char_indices()`

### Endpoint
N/A (Method on string slices)

### Parameters
None

### Request Body
None

### Request Example
```rust
let word = "goodbye";
let mut char_indices = word.char_indices();
assert_eq!(char_indices.next(), Some((0, 'g')));
```

### Response
#### Success Response (Iterator)
- **Tuple** (usize, char) - The byte index and the character.

#### Response Example
```json
{
  "example": "Some((0, 'g'))"
}
```
```

--------------------------------

### Generic Blanket Implementations for FBO

Source: https://docs.rs/libmpv2/5.0.3/libmpv2/render/struct.FBO.html

Illustrates common blanket implementations for generic types, including Any, Borrow, BorrowMut, From, Into, TryFrom, and TryInto, which are available for the FBO struct.

```rust
impl<T> Any for T
where T: 'static + ?Sized,
```

```rust
impl<T> Borrow<T> for T
where T: ?Sized,
```

```rust
impl<T> BorrowMut<T> for T
where T: ?Sized,
```

```rust
impl<T> From<T> for T
```

```rust
impl<T, U>
Into<U> for T
where U: From<T>,
```

```rust
impl<T, U>
TryFrom<U> for T
where U: Into<T>,
```

```rust
impl<T, U>
TryInto<U> for T
where U: TryFrom<T>,
```

--------------------------------

### rsplitn: Split string into at most N pieces from the right

Source: https://docs.rs/libmpv2/5.0.3/libmpv2/struct.MpvStr.html

Use `rsplitn` to split a string into a specified maximum number of pieces, starting from the right. The last element will contain the remainder if the split count is reached.

```rust
let v: Vec<&str> = "Mary had a little lamb".rsplitn(3, ' ').collect();
assert_eq!(v, ["lamb", "little", "Mary had a"]);
```

```rust
let v: Vec<&str> = "lionXXtigerXleopard".rsplitn(3, 'X').collect();
assert_eq!(v, ["leopard", "tiger", "lionX"]);
```

```rust
let v: Vec<&str> = "lion::tiger::leopard".rsplitn(2, "::").collect();
assert_eq!(v, ["leopard", "lion::tiger"]);
```

--------------------------------

### split_at

Source: https://docs.rs/libmpv2/5.0.3/libmpv2/struct.MpvStr.html

Divides a string slice into two at a specified byte offset. The offset must be on a UTF-8 code point boundary. Returns two slices: from the start to the offset, and from the offset to the end. Panics if the offset is invalid.

```APIDOC
## POST /split_at

### Description
Divides a string slice into two at a specified byte offset. The offset must be on a UTF-8 code point boundary. Returns two slices: from the start to the offset, and from the offset to the end. Panics if the offset is invalid.

### Method
POST

### Endpoint
/split_at

### Parameters
#### Request Body
- **mid** (usize) - Required - The byte offset at which to split the string slice.

### Request Example
```json
{
  "mid": 3
}
```

### Response
#### Success Response (200)
- **first** (str) - The first string slice (from start to `mid`).
- **last** (str) - The second string slice (from `mid` to end).

#### Response Example
```json
{
  "first": "Per",
  "last": " Martin-Löf"
}
```
```

--------------------------------

### Find Disjoint Matches in Reverse Order

Source: https://docs.rs/libmpv2/5.0.3/libmpv2/struct.MpvStr.html

Use `rmatch_indices` to find all occurrences of a pattern in a string slice, returning their start indices and the matched substrings in reverse order. Overlapping matches are handled by returning only the last occurrence.

```Rust
let v: Vec<_> = "abcXXXabcYYYabc".rmatch_indices("abc").collect();
assert_eq!(v, [(12, "abc"), (6, "abc"), (0, "abc")]);
```

```Rust
let v: Vec<_> = "1abcabc2".rmatch_indices("abc").collect();
assert_eq!(v, [(4, "abc"), (1, "abc")]);
```

```Rust
let v: Vec<_> = "ababa".rmatch_indices("aba").collect();
assert_eq!(v, [(2, "aba")]); // only the last `aba`
```

--------------------------------

### Constant: libmpv2::mpv_log_level::None

Source: https://docs.rs/libmpv2/5.0.3/libmpv2/mpv_log_level/constant.None.html

Represents the None log level constant within the libmpv2 crate.

```APIDOC
## Constant: libmpv2::mpv_log_level::None

### Description
Represents the 'None' log level, which is defined as a 32-bit unsigned integer with a value of 0.

### Value
0 (0u32)
```

--------------------------------

### Structs in libmpv2

Source: https://docs.rs/libmpv2/5.0.3/libmpv2/all.html

Lists the available structs within the libmpv2 crate, which represent core data structures and objects for MPV interaction.

```APIDOC
## Structs

### Mpv
Represents the main MPV instance.

### MpvInitializer
Used for initializing the MPV instance.

### MpvStr
A string type specific to MPV.

### protocol::Protocol
Represents MPV protocol details.

### render::FBO
Frame Buffer Object for rendering.

### render::OpenGLInitParams
Parameters for OpenGL initialization.

### render::RenderContext
Context for rendering operations.

### render::RenderFrameInfo
Information about a rendered frame.
```

--------------------------------

### RenderContext Methods

Source: https://docs.rs/libmpv2/5.0.3/libmpv2/render/struct.RenderContext.html

API methods for managing the video rendering lifecycle, including initialization, parameter updates, and frame rendering.

```APIDOC
## RenderContext::new

### Description
Creates a new RenderContext instance.

### Parameters
- **mpv** (&mut mpv_handle) - Required - The mpv handle.
- **params** (impl IntoIterator<Item = RenderParam<C>>) - Required - Rendering parameters.

## RenderContext::set_parameter

### Description
Sets a specific rendering parameter.

### Parameters
- **param** (RenderParam<C>) - Required - The parameter to set.

## RenderContext::render

### Description
Renders the video to a target surface (e.g., FBO).

### Parameters
- **fbo** (i32) - Required - Framebuffer object ID.
- **width** (i32) - Required - Width in pixels.
- **height** (i32) - Required - Height in pixels.
- **flip** (bool) - Required - Whether to flip the image vertically.

## RenderContext::report_swap

### Description
Notifies the renderer that a frame was flipped, assisting with playback timing.

## RenderContext::set_update_callback

### Description
Registers a callback triggered when a new frame is available or a redraw is required.

### Parameters
- **callback** (F: Fn() + Send + 'static) - Required - The callback function.

## RenderContext::update

### Description
Processes pending updates. Required if MPV_RENDER_PARAM_ADVANCED_CONTROL is set.

### Response
- **MpvRenderUpdate** (bitset) - Flags indicating required actions (e.g., MPV_RENDER_UPDATE_FRAME).
```

--------------------------------

### libmpv2::mpv_error::NoMem

Source: https://docs.rs/libmpv2/5.0.3/libmpv2/mpv_error/constant.NoMem.html

Represents a memory allocation failure.

```APIDOC
## Constant libmpv2::mpv_error::NoMem

### Description
Memory allocation failed.

### Summary
`pub const NoMem: i32 = -2;`
```

--------------------------------

### Constant: LoadingFailed

Source: https://docs.rs/libmpv2/5.0.3/libmpv2/mpv_error/constant.LoadingFailed.html

Documentation for the LoadingFailed error constant in libmpv2.

```APIDOC
## Constant: LoadingFailed

### Description
Generic error on loading (usually used with mpv_event_end_file.error).

### Value
- **LoadingFailed** (i32) - -13
```

--------------------------------

### Type Aliases in libmpv2

Source: https://docs.rs/libmpv2/5.0.3/libmpv2/all.html

Provides a list of type aliases defined in the libmpv2 crate for convenience and clarity.

```APIDOC
## Type Aliases

### EndFileReason
Alias for the reason why a file playback ended.

### LogLevel
Alias for MPV log levels.

### MpvError
Alias for MPV-specific errors.

### MpvFormat
Alias for MPV data formats.

### Result
Standard result type for operations.

### events::EventId
Alias for MPV event identifiers.

### protocol::StreamClose
Alias for stream close operations.

### protocol::StreamOpen
Alias for stream open operations.

### protocol::StreamRead
Alias for stream read operations.

### protocol::StreamSeek
Alias for stream seek operations.

### protocol::StreamSize
Alias for stream size operations.

### render::MpvRenderUpdate
Alias for MPV render update notifications.
```
Tokens:
Raw