rsmpeg

https://docs.rs/rsmpeg/0.18.0
Admin
rsmpeg is a Rust binding for the FFmpeg libraries, providing access to functionalities like avcodec,...
Tokens:4,363,870
Snippets:45,557
Trust Score:9.7
Update:10 months ago
Show doc for...
Tokens:
Raw
### Rust: SwrContext Configuration and Initialization

Source: https://docs.rs/rsmpeg/0.18.0/%2Bffmpeg.8.0/rsmpeg/swresample/struct.SwrContext_search=u32+-%3E+bool

Methods to initialize an already allocated SwrContext and to get the number of output samples expected for a given number of input samples. `init` finalizes the context setup, while `get_out_samples` helps manage buffer sizes.

```rust
pub fn init(&mut self) -> Result<()>
pub fn get_out_samples(&self, in_samples: i32) -> i32
```

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

### AVFormatContextInput Builder Example

Source: https://docs.rs/rsmpeg/0.18.0/%2Bffmpeg.8.0/rsmpeg/avformat/struct.AVFormatContextInput_search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

An example demonstrating the advanced configuration capabilities of `AVFormatContextInput::builder`. It shows how to set URL, input format, and options before opening the context.

```rust
use rsmpeg::avformat::{AVInputFormat, AVFormatContextInput};
use rsmpeg::avutil::AVDictionary;

let mjpeg_options = AVDictionary::new(c"framerate", c"10", 0);
let mut mjpeg_options = Some(mjpeg_options);

let input_context = AVFormatContextInput::builder()
    .url(c"assets/mountain.jpg")
    .format(&AVInputFormat::find(c"mjpeg").unwrap())
    .options(&mut mjpeg_options)
    .open().unwrap();

assert!(mjpeg_options.is_none(), "unconsumed format options: {mjpeg_options:?}");
```

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

### FFmpeg: Get RIFF video tag mapping with example

Source: https://docs.rs/rsmpeg/0.18.0/%2Bffmpeg.8.0/rsmpeg/ffi/index_search=std%3A%3Avec

Returns a table mapping RIFF FourCC codes for video to AVCodecID. The example demonstrates how to use this table with av_codec_get_id() to find a codec ID from a FourCC tag.

```c
/**
 * @defgroup riff_fourcc RIFF FourCCs @{
 * Get the tables mapping RIFF FourCCs to libavcodec AVCodecIDs.
 * The tables are meant to be passed to av_codec_get_id()/av_codec_get_tag() as in the following code:
 * @code
 * uint32_t tag = MKTAG('H', '2', '6', '4');
 * const struct AVCodecTag _table[] = { avformat_get_riff_video_tags(), NULL };
 * enum AVCodecID id = av_codec_get_id(table, tag);
 * @endcode
 * /  * @return the table mapping RIFF FourCCs for video to libavcodec AVCodecID.
 */
const struct AVCodecTag *_avformat_get_riff_video_tags(void);
```

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

### AVFormatContextInput Initialization Methods

Source: https://docs.rs/rsmpeg/0.18.0/%2Bffmpeg.8.0/rsmpeg/avformat/struct.AVFormatContextInput_search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Demonstrates methods for creating AVFormatContextInput instances. `open` creates from a URL, `from_io_context` uses an existing AVIOContext, and `builder` allows for advanced configuration before opening.

```rust
pub fn open(url: &CStr) -> Result<Self>
pub fn from_io_context(io_context: AVIOContextContainer) -> Result<Self>
pub fn builder<'f1, 'f2, 'f3>() -> AVFormatContextInputBuilder<'f1, 'f2, 'f3>
```

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

### AV Output Video Device Iterator

Source: https://docs.rs/rsmpeg/0.18.0/%2Bffmpeg.8.0/rsmpeg/ffi/fn.av_output_video_device_next

The `av_output_video_device_next` function allows you to iterate through registered video output devices. You can start by passing NULL to get the first device, and then pass the previous device to get the next one in the sequence.

```APIDOC
## av_output_video_device_next

### Description

Iterates through registered video output devices. If the input device pointer `d` is NULL, it returns the first registered output device. If `d` is not NULL, it returns the next registered output device after `d`. If `d` is the last device, it returns NULL.

### Method

`unsafe extern "C" fn`

### Endpoint

`rsmpeg::ffi::av_output_video_device_next`

### Parameters

#### Path Parameters

None

#### Query Parameters

None

#### Request Body

- **d** (*const AVOutputFormat*) - Required - A pointer to the current AVOutputFormat, or NULL to get the first device.

### Request Example

```c
AVOutputFormat *first_device = av_output_video_device_next(NULL);
AVOutputFormat *next_device = NULL;

if (first_device) {
    next_device = av_output_video_device_next(first_device);
}
```

### Response

#### Success Response (200)

- ***const AVOutputFormat*** - A pointer to the next registered output device, or NULL if it's the end of the list.

#### Response Example

```json
{
  "output_device_ptr": "0x..."
}
```

### Error Handling

- Returns NULL if no devices are found or if the last device has been reached.
```

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

### Demonstrate AVHashContext Hashing API Usage in C

Source: https://docs.rs/rsmpeg/0.18.0/%2Bffmpeg.8.0/rsmpeg/ffi/struct.AVHashContext_search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

An example demonstrating the typical usage of the hashing API with `AVHashContext`. It covers allocation, initialization, updating, and finalizing the hash context, presented as a command-line application.

```c
/* This example is a simple command line application that takes one or more arguments. It demonstrates a typical use of the hashing API with allocation, initialization, updating, and finalizing. */
// In ffhash.c
```

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

### AVDictionary Creation and Initialization

Source: https://docs.rs/rsmpeg/0.18.0/%2Bffmpeg.8.0/rsmpeg/avutil/struct.AVDictionary_search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Methods for creating and initializing AVDictionary instances.

```APIDOC
## AVDictionary Creation and Initialization

### `new(key: &CStr, value: &CStr, flags: u32) -> Self`

Creates a new dictionary entry using `set()`.

### `new_int(key: &CStr, value: i64, flags: u32) -> Self`

Creates a new dictionary entry with an integer value using `set_int()`.

### `from_string(str: &CStr, key_val_sep: &CStr, pairs_sep: &CStr, flags: u32) -> Option<Self>`

Creates a dictionary from a string representation of key-value pairs.

### `parse_string(self, str: &CStr, key_val_sep: &CStr, pairs_sep: &CStr, flags: u32) -> Result<Self>`

Parses a string containing key/value pairs and adds them to the dictionary. This method consumes the dictionary and returns a `Result`.

```

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

### Relative Time (Microseconds)

Source: https://docs.rs/rsmpeg/0.18.0/%2Bffmpeg.8.0/rsmpeg/ffi/index

Gets the current time in microseconds since some unspecified starting point. This time source is ideal for measuring relative time differences.

```APIDOC
## GET /time/relative

### Description
Get the current time in microseconds since some unspecified starting point. On platforms that support it, the time comes from a monotonic clock This property makes this time source ideal for measuring relative time. The returned values may not be monotonic on platforms where a monotonic clock is not available.

### Method
GET

### Endpoint
/time/relative

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

### Response Example
```json
{
  "timestamp_us": 5000000
}
```
```

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

### Example Usage of avcodec_open2 with AVDictionary (C)

Source: https://docs.rs/rsmpeg/0.18.0/%2Bffmpeg.8.0/rsmpeg/ffi/fn.avcodec_open2

Demonstrates how to set options for a codec using av_dict_set and then open the codec context with avcodec_open2. This example shows finding an H.264 decoder, allocating a context, setting a bitrate option, and opening the context. It includes error handling for finding the codec and opening the context.

```c
av_dict_set(&opts, "b", "2.5M", 0);
codec = avcodec_find_decoder(AV_CODEC_ID_H264);
if (!codec) exit(1);
context = avcodec_alloc_context3(codec);
if (avcodec_open2(context, codec, opts) < 0) exit(1);
```

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

### Get RIFF Video Tags - avformat_get_riff_video_tags

Source: https://docs.rs/rsmpeg/0.18.0/%2Bffmpeg.8.0/rsmpeg/ffi/index_search=

Returns a table mapping RIFF FourCC codes to AVCodecIDs for video streams. An example demonstrates its usage with av_codec_get_id().

```c
#define MKTAG(a, b, c, d) ((uint32_t)(a) | ((uint32_t)(b) << 8) | ((uint32_t)(c) << 16) | ((uint32_t)(d) << 24))

// ... inside a function ...
uint32_t tag = MKTAG('H', '2', '6', '4');
const struct AVCodecTag table[] = { avformat_get_riff_video_tags(), { 0, 0 } }; // Terminate with {0, 0}
AVCodecID id = av_codec_get_id(table, tag);
// Use id ...
```

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

### Get Raw Pointer to Vec Buffer in Rust

Source: https://docs.rs/rsmpeg/0.18.0/%2Bffmpeg.8.0/rsmpeg/avutil/struct.AVImage_search=std%3A%3Avec

Shows how to get a raw pointer to the underlying buffer of a Rust Vec. It includes safety considerations regarding the lifetime of the Vec and memory access. The example demonstrates safe iteration and modification using pointers, respecting aliasing rules.

```rust
let x = vec![1, 2, 4];
let x_ptr = x.as_ptr();

unsafe {
    for i in 0..x.len() {
        assert_eq!(*x_ptr.add(i), 1 << i);
    }
}
```

```rust
unsafe {
    let mut v = vec![0, 1, 2];
    let ptr1 = v.as_ptr();
    let _ = ptr1.read();
    let ptr2 = v.as_mut_ptr().offset(2);
    ptr2.write(2);
    // Notably, the write to `ptr2` did *not* invalidate `ptr1`
    // because it mutated a different element:
    let _ = ptr1.read();
}
```

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

### AVHWDeviceContext Allocation and Initialization

Source: https://docs.rs/rsmpeg/0.18.0/%2Bffmpeg.8.0/rsmpeg/avutil/struct.AVHWDeviceContext

Provides functions for allocating and initializing AVHWDeviceContext. `alloc` creates a context for a specific hardware type, while `init` finalizes it before use. These are fundamental steps for setting up hardware acceleration.

```rust
pub fn alloc(type: AVHWDeviceType) -> Self

pub fn init(&mut self) -> Result<()>
```

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

### Initialization and Configuration

Source: https://docs.rs/rsmpeg/0.18.0/%2Bffmpeg.8.0/rsmpeg/ffi/index_search=

Functions for initializing and configuring various components within libavcodec, including transform contexts, codec contexts, and DCT contexts.

```APIDOC
## POST /avcodec/initialize_transform_context

### Description
Initializes a transform context with the given configuration. Note: MDCTs with an odd length are currently not supported.

### Method
POST

### Endpoint
/avcodec/initialize_transform_context

### Parameters
#### Request Body
- **configuration** (object) - Required - The configuration for the transform context.

### Response
#### Success Response (200)
- **context_id** (string) - The identifier for the initialized transform context.

#### Response Example
{
  "context_id": "tx_ctx_123"
}
```

```APIDOC
## POST /avcodec/alloc_codec_context

### Description
Allocates an AVCodecContext and sets its fields to default values. The resulting struct should be freed with avcodec_free_context().

### Method
POST

### Endpoint
/avcodec/alloc_codec_context

### Parameters
#### Request Body
- **codec_type** (string) - Required - The type of codec context to allocate (e.g., 'video', 'audio').

### Response
#### Success Response (200)
- **context_id** (string) - The identifier for the allocated codec context.

#### Response Example
{
  "context_id": "codec_ctx_456"
}
```

```APIDOC
## POST /avcodec/dct_alloc

### Description
Allocates a AVDCT context. This needs to be initialized with avcodec_dct_init() after optionally configuring it with AVOptions.

### Method
POST

### Endpoint
/avcodec/dct_alloc

### Response
#### Success Response (200)
- **dct_context_id** (string) - The identifier for the allocated DCT context.

#### Response Example
{
  "dct_context_id": "dct_ctx_789"
}
```

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

### Get Planar Sample Format - Rust

Source: https://docs.rs/rsmpeg/0.18.0/%2Bffmpeg.8.0/rsmpeg/avutil/fn.get_planar_sample_fmt_search=

Converts a given AVSampleFormat to its planar alternative. Returns None if an error occurs. For example, AV_SAMPLE_FMT_S16 is converted to AV_SAMPLE_FMT_S16P.

```Rust
pub fn get_planar_sample_fmt(
    sample_fmt: AVSampleFormat,
) -> Option<AVSampleFormat>
```

```Rust
assert_eq!(
    Some(AV_SAMPLE_FMT_S16P),
    get_planar_sample_fmt(AV_SAMPLE_FMT_S16)
);
```

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

### Vector Capacity and Slice Extraction

Source: https://docs.rs/rsmpeg/0.18.0/%2Bffmpeg.8.0/rsmpeg/avutil/struct.AVImage_search=

Demonstrates how to get the total capacity of a vector and extract a slice representing its entire contents. Includes examples for standard vectors and vectors with zero-sized elements.

```rust
pub fn capacity(&self) -> usize
Returns the total number of elements the vector can hold without reallocating.
##### §Examples
```
let mut vec: Vec<i32> = Vec::with_capacity(10);
vec.push(42);
assert!(vec.capacity() >= 10);
```

A vector with zero-sized elements will always have a capacity of usize::MAX:
```
#[derive(Clone)]
struct ZeroSized;

fn main() {
    assert_eq!(std::mem::size_of::<ZeroSized>(), 0);
    let v = vec![ZeroSized; 0];
    assert_eq!(v.capacity(), usize::MAX);
}
```
```

```rust
pub fn as_slice(&self) -> &[T]
Extracts a slice containing the entire vector.
Equivalent to `&s[..]`.
##### §Examples
```
use std::io::{self, Write};
let buffer = vec![1, 2, 3, 5, 8];
io::sink().write(buffer.as_slice()).unwrap();
```
```

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

### av_xtea_init

Source: https://docs.rs/rsmpeg/0.18.0/%2Bffmpeg.8.0/rsmpeg/ffi/fn.av_xtea_init_search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Initializes an AVXTEA context for encryption and decryption using a provided key.

```APIDOC
## POST /av_xtea_init

### Description
Initializes an AVXTEA context. This function is part of the rsmpeg::ffi module and is declared as unsafe.

### Method
POST

### Endpoint
/av_xtea_init

### Parameters
#### Request Body
- **ctx** (*AVXTEA) - Required - A pointer to an AVXTEA context to be initialized.
- **key** (*u8) - Required - A pointer to a 16-byte key used for encryption/decryption. This key is interpreted as big-endian 32-bit numbers.

### Request Example
```json
{
  "ctx": "pointer_to_avxtea_context",
  "key": "pointer_to_16_byte_key"
}
```

### Response
#### Success Response (200)
This function does not explicitly return a value, but its success is indicated by the proper initialization of the AVXTEA context.

#### Response Example
(No specific response body for success, context is modified in place.)
```

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

### AVFormatContextInput Initialization

Source: https://docs.rs/rsmpeg/0.18.0/%2Bffmpeg.8.0/rsmpeg/avformat/struct.AVFormatContextInput_search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Methods for creating and initializing AVFormatContextInput instances from various sources like URLs or existing IO contexts.

```APIDOC
## AVFormatContextInput Initialization

### Description
Methods for initializing `AVFormatContextInput` from different sources, including file URLs and existing IO contexts.

### Methods
- **`open(url: &CStr) -> Result<Self>`**: Creates an `AVFormatContextInput` instance by opening a file from the given URL and retrieving stream information.
- **`from_io_context(io_context: AVIOContextContainer) -> Result<Self>`**: Creates an `AVFormatContextInput` instance from an existing `AVIOContextContainer` and finds stream information.
- **`builder() -> AVFormatContextInputBuilder<'f1, 'f2, 'f3>`**: Returns a builder for advanced configuration options when creating an `AVFormatContextInput`.

### Example Usage (Builder)
```rust
use rsmpeg::avformat::{AVInputFormat, AVFormatContextInput};
use rsmpeg::avutil::AVDictionary;

let mjpeg_options = AVDictionary::new(c"framerate", c"10", 0);
let mut mjpeg_options = Some(mjpeg_options);

let input_context = AVFormatContextInput::builder()
    .url(c"assets/mountain.jpg")
    .format(&AVInputFormat::find(c"mjpeg").unwrap())
    .options(&mut mjpeg_options)
    .open().unwrap();

assert!(mjpeg_options.is_none(), "unconsumed format options: {mjpeg_options:?}");
```
```

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

### Get Dictionary Entry by Key

Source: https://docs.rs/rsmpeg/0.18.0/%2Bffmpeg.8.0/src/rsmpeg/avutil/dict.rs

Retrieves a dictionary entry based on a key, with options to start from a previous entry and apply flags. It utilizes the `av_dict_get` C function and returns an `Option<AVDictionaryEntryRef>`.

```rust
pub fn get(
        &'dict self,
        key: &CStr,
        prev: Option<AVDictionaryEntryRef>,
        flags: u32,
    ) -> Option<AVDictionaryEntryRef<'dict>> {
        let prev_ptr = match prev {
            Some(entry) => entry.as_ptr(),
            None => ptr::null(),
        };
        unsafe { ffi::av_dict_get(self.as_ptr(), key.as_ptr(), prev_ptr, flags as i32) }
            .upgrade()
            .map(|ptr| unsafe { AVDictionaryEntryRef::from_raw(ptr) })
    }
```

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

### Get Packed Sample Format in Rust

Source: https://docs.rs/rsmpeg/0.18.0/%2Bffmpeg.8.0/src/rsmpeg/avutil/samplefmt.rs

Converts a planar `AVSampleFormat` to its packed equivalent. For example, `AV_SAMPLE_FMT_S16P` (planar) would be converted to `AV_SAMPLE_FMT_S16` (packed). Returns `None` if the conversion is not possible or results in an error.

```rust
/// Get the packed alternative form of the given sample format, return `None` on
/// error.
///
/// i.e. [`AV_SAMPLE_FMT_S16P`](ffi::AV_SAMPLE_FMT_S16P) => [`AV_SAMPLE_FMT_S16`](ffi::AV_SAMPLE_FMT_S16)
/// ```rust
/// # use rsmpeg::avutil::get_packed_sample_fmt;
/// # use rsmpeg::ffi::{AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S16P};
/// # fn main() {
/// assert_eq!(
///     Some(AV_SAMPLE_FMT_S16),
///     get_packed_sample_fmt(AV_SAMPLE_FMT_S16P)
/// );
/// # }
/// ```
pub fn get_packed_sample_fmt(sample_fmt: AVSampleFormat) -> Option<AVSampleFormat> {
    let sample_fmt = unsafe { ffi::av_get_packed_sample_fmt(sample_fmt) };
    match sample_fmt {
        ffi::AV_SAMPLE_FMT_NONE => None,
        _ => Some(sample_fmt),
    }
}
```

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

### SwrContext Initialization and State

Source: https://docs.rs/rsmpeg/0.18.0/%2Bffmpeg.8.0/rsmpeg/swresample/struct.SwrContext_search=

Methods for checking the initialization status of the SwrContext and for creating and initializing new contexts.

```APIDOC
## impl SwrContext (Initialization and State)

### `is_initialized(&self) -> bool`

Check whether an `SwrContext` has been initialized or not.

### `new(out_ch_layout: &AVChannelLayout, out_sample_fmt: AVSampleFormat, out_sample_rate: i32, in_ch_layout: &AVChannelLayout, in_sample_fmt: AVSampleFormat, in_sample_rate: i32) -> Result<Self>`

Allocate `SwrContext` if needed and set/reset common parameters. This function does not require `s` to be allocated with `swr_alloc()`. On the other hand, `swr_alloc()` can use `swr_alloc_set_opts()` to set the parameters on the allocated context.

- `out_ch_layout`: Output channel layout (AV_CH_LAYOUT__)
- `out_sample_fmt`: Output sample format (AV_SAMPLE_FMT__)
- `out_sample_rate`: Output sample rate (frequency in Hz)
- `in_ch_layout`: Input channel layout (AV_CH_LAYOUT__)
- `in_sample_fmt`: Input sample format (AV_SAMPLE_FMT__)
- `in_sample_rate`: Input sample rate (frequency in Hz)

Returns `None` on invalid parameters or insufficient parameters.

### `init(&mut self) -> Result<()>`

Initialize context after user parameters have been set.
```

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

### Get libavutil License (Rust)

Source: https://docs.rs/rsmpeg/0.18.0/%2Bffmpeg.8.0/rsmpeg/avutil/fn.license

Retrieves the license of the linked libavutil library, whether static or dynamic. It returns a static CStr representing the license. The example demonstrates how to obtain and print the license string.

```rust
use rsmpeg::avutil;

let license = avutil::license();
let license = license.to_string_lossy();
assert_ne!(license.len(), 0);
// prints e.g. "GPL version 3 or later"
println!("{license}");
```

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

### av_xtea_init

Source: https://docs.rs/rsmpeg/0.18.0/%2Bffmpeg.8.0/rsmpeg/ffi/fn.av_xtea_init_search=

Initializes an AVXTEA context for encryption/decryption using a provided key.

```APIDOC
## av_xtea_init

### Description
Initializes an AVXTEA context.

### Method
Not applicable (FFI function).

### Endpoint
Not applicable (FFI function).

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```c
// This is a C function signature, not a typical JSON request.
// Example usage would involve calling this function from C or a Rust FFI binding.
```

### Response
#### Success Response (200)
None (This is a void function in C terms, indicating success by not returning an error).

#### Response Example
None

### Notes
- `@param ctx`: an AVXTEA context.
- `@param key`: a key of 16 bytes used for encryption/decryption, interpreted as big endian 32 bit numbers.
```

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

### Get libavutil Version (Rust)

Source: https://docs.rs/rsmpeg/0.18.0/%2Bffmpeg.8.0/rsmpeg/avutil/fn.version_search=std%3A%3Avec

Retrieves the semver version of the linked `libavutil` library. This function returns an `AvVersion` struct. The example demonstrates asserting the version is non-zero and printing it.

```Rust
use rsmpeg::avutil;

let version = avutil::version();
assert_ne!(version.to_av_int(), 0);
// prints e.g. "59.39.100"
println!("{version}");
```

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

### swr_init

Source: https://docs.rs/rsmpeg/0.18.0/%2Bffmpeg.8.0/rsmpeg/ffi/fn.swr_init_search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Initializes the SwrContext after user parameters have been set. The context must be configured using the AVOption API.

```APIDOC
## pub unsafe extern "C" fn swr_init(s: *mut SwrContext) -> i32

### Description
Initialize context after user parameters have been set. The context must be configured using the AVOption API.

### Method
C Function (FFI)

### Endpoint
N/A (FFI Function)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```c
// This is a C-style function call, not a typical HTTP request.
// Example requires context setup not shown here.
// swr_init(swr_context_pointer);
```

### Response
#### Success Response
Returns 0 on success.

#### Response Example
```c
0
```

#### Error Response
Returns an AVERROR error code in case of failure.
```

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

### Get libswscale License - Rust

Source: https://docs.rs/rsmpeg/0.18.0/%2Bffmpeg.8.0/rsmpeg/swscale/fn.license

Retrieves the license string of the linked libswscale library. This function returns a static C-String. The example demonstrates how to convert this C-String to a Rust String and print it, ensuring the license string is not empty.

```rust
use rsmpeg::swscale;

let license = swscale::license();
let license = license.to_string_lossy();
assert_ne!(license.len(), 0);
// prints e.g. "GPL version 3 or later"
println!("{license}");
```

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

### AVImage Constructors and Utility Methods

Source: https://docs.rs/rsmpeg/0.18.0/%2Bffmpeg.8.0/rsmpeg/avutil/struct.AVImage_search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Provides methods for creating AVImage instances, calculating buffer sizes, and managing image data pointers.

```APIDOC
## Implementations: AVImage

### Public Methods

#### `new(pix_fmt: AVPixelFormat, width: i32, height: i32, align: i32) -> Option<Self>`

Creates a new `AVImage`. Returns `None` if parameters are invalid. Panics if memory allocation fails.

#### `get_buffer_size(fmt: AVPixelFormat, width: i32, height: i32, align: i32) -> Option<i32>`

Calculates the required buffer size in bytes for an image with the given parameters. Returns `None` if parameters are invalid.

#### `data(&self) -> &[*mut u8; 8]`

Returns a reference to the image data pointers.

#### `linesizes(&self) -> &[i32; 8]`

Returns a reference to the linesizes array.
```

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

### SwrContext Initialization and Configuration

Source: https://docs.rs/rsmpeg/0.18.0/%2Bffmpeg.8.0/rsmpeg/swresample/struct.SwrContext

Provides methods for creating, initializing, and configuring SwrContext for audio resampling operations.

```APIDOC
## SwrContext

### Description
Represents an audio resampling context that manages the process of converting audio data from one format to another.

### Methods

#### `new(
    out_ch_layout: &AVChannelLayout,
    out_sample_fmt: AVSampleFormat,
    out_sample_rate: i32,
    in_ch_layout: &AVChannelLayout,
    in_sample_fmt: AVSampleFormat,
    in_sample_rate: i32,
) -> Result<Self>`

*   **Description**: Allocates and initializes a new `SwrContext` with the specified output and input audio parameters. This function sets common parameters and can be used to prepare for resampling. It returns `None` if parameters are invalid or insufficient.
*   **Parameters**:
    *   `out_ch_layout` (AVChannelLayout) - Output channel layout.
    *   `out_sample_fmt` (AVSampleFormat) - Output sample format.
    *   `out_sample_rate` (i32) - Output sample rate in Hz.
    *   `in_ch_layout` (AVChannelLayout) - Input channel layout.
    *   `in_sample_fmt` (AVSampleFormat) - Input sample format.
    *   `in_sample_rate` (i32) - Input sample rate in Hz.
*   **Returns**: `Result<Self>` - A new `SwrContext` instance or an error.

#### `init(&mut self) -> Result<()>`

*   **Description**: Initializes the `SwrContext` after user parameters have been set. This is a crucial step before performing any conversion.
*   **Returns**: `Result<()>` - Ok if initialization is successful, otherwise an error.

#### `is_initialized(&self) -> bool`

*   **Description**: Checks whether the `SwrContext` has been successfully initialized.
*   **Returns**: `bool` - `true` if initialized, `false` otherwise.
```

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

### Get Packed Sample Format - Rust

Source: https://docs.rs/rsmpeg/0.18.0/%2Bffmpeg.8.0/rsmpeg/avutil/fn.get_packed_sample_fmt_search=

The get_packed_sample_fmt function converts a planar sample format to its packed equivalent. It returns None if the conversion is not possible. For example, it maps AVSampleFormat::AV_SAMPLE_FMT_S16P to AVSampleFormat::AV_SAMPLE_FMT_S16.

```rust
pub fn get_packed_sample_fmt(
    sample_fmt: AVSampleFormat,
) -> Option<AVSampleFormat>
```

```rust
assert_eq!(
    Some(AV_SAMPLE_FMT_S16),
    get_packed_sample_fmt(AV_SAMPLE_FMT_S16P)
);
```

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

### sws_context Initialization and Configuration

Source: https://docs.rs/rsmpeg/0.18.0/%2Bffmpeg.8.0/rsmpeg/ffi/index_search=u32+-%3E+bool

Functions related to initializing, configuring, and retrieving information about the swscaler context.

```APIDOC
## sws_init_context

### Description
Initializes the swscaler context.

### Method
N/A (This appears to be a function call description, not an HTTP endpoint)

### Endpoint
N/A

### Parameters
No specific parameters are detailed in the provided text for initialization itself, but subsequent functions rely on an initialized context.

### Request Example
N/A

### Response
N/A

## sws_setColorspaceDetails

### Description
Sets the colorspace details for the scaling context, including range, coefficients, brightness, contrast, and saturation.

### Method
N/A (Function call description)

### Endpoint
N/A

### Parameters
- **c** (pointer) - The scaling context.
- **dstRange** (int) - Flag indicating the white-black range of the output (1=jpeg / 0=mpeg).
- **srcRange** (int) - Flag indicating the white-black range of the input (1=jpeg / 0=mpeg).
- **table** (pointer) - The yuv2rgb coefficients describing the output yuv space.
- **inv_table** (pointer) - The yuv2rgb coefficients describing the input yuv space.
- **brightness** (int) - 16.16 fixed point brightness correction.
- **contrast** (int) - 16.16 fixed point contrast correction.
- **saturation** (int) - 16.16 fixed point saturation correction.

### Request Example
N/A

### Response
N/A

## sws_isSupportedEndiannessConversion

### Description
Checks if an endianness conversion for a given pixel format is supported.

### Method
N/A (Function call description)

### Endpoint
N/A

### Parameters
- **pix_fmt** (enum) - The pixel format.

### Request Example
N/A

### Response
- **return value** (int) - A positive value if conversion is supported, 0 otherwise.

## sws_isSupportedInput

### Description
Checks if a given pixel format is a supported input format.

### Method
N/A (Function call description)

### Endpoint
N/A

### Parameters
- **pix_fmt** (enum) - The pixel format.

### Request Example
N/A

### Response
- **return value** (int) - A positive value if supported, 0 otherwise.

## sws_isSupportedOutput

### Description
Checks if a given pixel format is a supported output format.

### Method
N/A (Function call description)

### Endpoint
N/A

### Parameters
- **pix_fmt** (enum) - The pixel format.

### Request Example
N/A

### Response
- **return value** (int) - A positive value if supported, 0 otherwise.

## sws_test_colorspace

### Description
Tests if a given color space is supported.

### Method
N/A (Function call description)

### Endpoint
N/A

### Parameters
N/A

### Request Example
N/A

### Response
N/A

## sws_test_format

### Description
Tests if a given pixel format is supported.

### Method
N/A (Function call description)

### Endpoint
N/A

### Parameters
N/A

### Request Example
N/A

### Response
N/A

## sws_test_primaries

### Description
Tests if a given set of color primaries is supported.

### Method
N/A (Function call description)

### Endpoint
N/A

### Parameters
N/A

### Request Example
N/A

### Response
N/A

## sws_test_transfer

### Description
Tests if a given color transfer function is supported.

### Method
N/A (Function call description)

### Endpoint
N/A

### Parameters
N/A

### Request Example
N/A

### Response
N/A

## sws_test_frame

### Description
Helper function to run all sws_test_* checks against a frame, and basic frame properties.

### Method
N/A (Function call description)

### Endpoint
N/A

### Parameters
N/A

### Request Example
N/A

### Response
N/A

## swscale_configuration

### Description
Returns the libswscale build-time configuration.

### Method
N/A (Function call description)

### Endpoint
N/A

### Parameters
N/A

### Request Example
N/A

### Response
- **return value** (string) - The build-time configuration string.

## swscale_license

### Description
Returns the libswscale license.

### Method
N/A (Function call description)

### Endpoint
N/A

### Parameters
N/A

### Request Example
N/A

### Response
- **return value** (string) - The license string.

## swscale_version

### Description
Returns the libswscale version.

### Method
N/A (Function call description)

### Endpoint
N/A

### Parameters
N/A

### Request Example
N/A

### Response
- **return value** (int) - The version number.
```

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

### Get libavdevice License (Rust)

Source: https://docs.rs/rsmpeg/0.18.0/%2Bffmpeg.8.0/rsmpeg/avdevice/fn.license

Retrieves the license of the linked libavdevice library (static or dynamic). This function returns a CStr representing the license. The example shows how to call the function and convert the result to a displayable string.

```Rust
use rsmpeg::avdevice;

let license = avdevice::license();
let license = license.to_string_lossy();
assert_ne!(license.len(), 0);
// prints e.g. "GPL version 3 or later"
println!("{license}");
```

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

### av_blowfish_init

Source: https://docs.rs/rsmpeg/0.18.0/%2Bffmpeg.8.0/rsmpeg/ffi/fn.av_blowfish_init_search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Initializes an AVBlowfish context with a given key.

```APIDOC
## av_blowfish_init

### Description
Initialize an AVBlowfish context.

### Method
This is a function signature, typically called from Rust code.

### Endpoint
N/A (FFI function)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None (function parameters are used instead)

### Request Example
```rust
// Assuming ctx, key, and key_len are defined elsewhere
// let mut blowfish_ctx: AVBlowfish = /* ... */;
// let key_data: [u8; 16] = [0u8; 16];
// let key_len = 16;
// unsafe { av_blowfish_init(&mut blowfish_ctx, key_data.as_ptr(), key_len) };
```

### Response
#### Success Response (200)
This function does not return a value; it operates via side effects on the `ctx` parameter.

#### Response Example
N/A
```

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

### Get libswresample Version (Rust)

Source: https://docs.rs/rsmpeg/0.18.0/%2Bffmpeg.8.0/rsmpeg/swresample/fn.version_search=

Retrieves the semver version of the `libswresample` library linked to the rsmpeg crate. This function does not return the FFmpeg version. It takes no arguments and returns an `AvVersion` type. An example demonstrates its usage and assertion.

```rust
pub fn version() -> AvVersion
```

```rust
use rsmpeg::swresample;

let version = swresample::version();
assert_ne!(version.to_av_int(), 0);
// prints e.g. "59.39.100"
println!("{version}");
```

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

### Get Planar Sample Format in Rust

Source: https://docs.rs/rsmpeg/0.18.0/%2Bffmpeg.8.0/rsmpeg/avutil/fn.get_planar_sample_fmt

The get_planar_sample_fmt function in rsmpeg::avutil takes an AVSampleFormat and returns its planar equivalent. It returns None if an error occurs. For example, it converts AVSampleFormat::AV_SAMPLE_FMT_S16 to AVSampleFormat::AV_SAMPLE_FMT_S16P.

```rust
pub fn get_planar_sample_fmt(
    sample_fmt: AVSampleFormat,
) -> Option<AVSampleFormat>

assert_eq!(
    Some(AV_SAMPLE_FMT_S16P),
    get_planar_sample_fmt(AV_SAMPLE_FMT_S16)
);
```

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

### Image and Sample Format Handling

Source: https://docs.rs/rsmpeg/0.18.0/%2Bffmpeg.8.0/rsmpeg/avutil/index_search=std%3A%3Avec

Functions for setting up image data pointers and linesizes, and for retrieving information about media types, pixel formats, and sample formats.

```APIDOC
## Image and Sample Format Handling

### `av_image_fill_arrays(dst_data, dst_linesizes, src, pix_fmt, width, height, alignment)`

Sets up the data pointers and linesizes based on the specified image parameters and the provided array.

### `get_bytes_per_sample(fmt)`

Returns the number of bytes per sample. Returns `None` when the sample format is unknown.

### `get_media_type_string(media_type)`

Returns a string describing the `media_type` enum, or `NULL` if `media_type` is unknown.

### `get_packed_sample_fmt(fmt)`

Gets the packed alternative form of the given sample format. Returns `None` on error.

### `get_pix_fmt_name(pix_fmt)`

Returns the name of the given pixel format, or `None` if `pix_fmt` is not recognized.

### `get_planar_sample_fmt(fmt)`

Gets the planar alternative form of the given sample format. Returns `None` on error.

### `get_sample_fmt(name)`

Returns a sample format corresponding to the given name, or `None` on error.

### `get_sample_fmt_name(sample_fmt)`

Returns the name of the given `sample_fmt`, or `None` if `sample_fmt` is not recognized.

### `sample_fmt_is_planar(fmt)`

Checks if the sample format is planar.

```

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

### Image and Sample Format Handling

Source: https://docs.rs/rsmpeg/0.18.0/%2Bffmpeg.8.0/rsmpeg/avutil/index_search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Functions for managing image data pointers, linesizes, pixel formats, and audio sample formats.

```APIDOC
## Image and Sample Format Handling

### Description
Utility functions for working with image data structures and audio sample formats.

### Functions

- **av_image_fill_arrays(dst_data, dst_linesizes, src, pix_fmt, w, h, align)**: Sets up the data pointers and linesizes for an image based on specified parameters and a provided array.
- **get_pix_fmt_name(pix_fmt)**: Returns the string name of a given pixel format `pix_fmt`, or `None` if unrecognized.
- **get_sample_fmt_name(sample_fmt)**: Returns the string name of a given sample format `sample_fmt`, or `None` if unrecognized.
- **get_sample_fmt(name)**: Returns the `AVSampleFormat` corresponding to the given `name`, or `None` on error.
- **get_packed_sample_fmt(sample_fmt)**: Returns the packed alternative form of the given sample format, or `None` on error.
- **get_planar_sample_fmt(sample_fmt)**: Returns the planar alternative form of the given sample format, or `None` on error.
- **get_bytes_per_sample(sample_fmt)**: Returns the number of bytes per sample for a given `sample_fmt`, or `None` if the format is unknown.
- **sample_fmt_is_planar(sample_fmt)**: Checks if the given sample format is planar.
- **av_rescale_rnd(a, b, c, rnd)**: Rescales a 64-bit integer `a` by a rational number (`b/c`) with specified rounding `rnd`.
```

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

### Get swscale Version (Rust)

Source: https://docs.rs/rsmpeg/0.18.0/%2Bffmpeg.8.0/rsmpeg/swscale/fn.version

Retrieves the semver version of the linked libswscale library. This function returns an AvVersion struct. Note that this is not the FFmpeg version. The example demonstrates calling the function and asserting that the version is not zero, then printing the version string.

```rust
use rsmpeg::swscale;

let version = swscale::version();
assert_ne!(version.to_av_int(), 0);
// prints e.g. "59.39.100"
println!("{version}");
```

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

### AVAudioFifo - Initialization and Reallocation

Source: https://docs.rs/rsmpeg/0.18.0/%2Bffmpeg.8.0/rsmpeg/avutil/struct.AVAudioFifo

Methods for creating and resizing an AVAudioFifo buffer.

```APIDOC
## AVAudioFifo - Initialization and Reallocation

### Description
Methods for creating and resizing an AVAudioFifo buffer.

### Methods

#### `new(sample_fmt: AVSampleFormat, channels: i32, nb_samples: i32) -> Self`
Allocate an AVAudioFifo.

**Parameters:**
- `sample_fmt` (AVSampleFormat) - The desired sample format.
- `channels` (i32) - The number of audio channels.
- `nb_samples` (i32) - The initial number of samples the buffer should hold.

#### `realloc(&mut self, nb_samples: i32)`
Reallocate an AVAudioFifo to a new size.

**Parameters:**
- `nb_samples` (i32) - The new number of samples the buffer should hold.
```

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

### Get libavdevice License - Rust

Source: https://docs.rs/rsmpeg/0.18.0/%2Bffmpeg.8.0/rsmpeg/avdevice/fn.license_search=

Retrieves the license of the linked libavdevice (static or dynamic). This function is part of the rsmpeg::avdevice module. It returns a static CStr representing the license. Example usage shows how to call the function and print the license as a string.

```Rust
pub fn license() -> &'static CStr
```
use rsmpeg::avdevice;

let license = avdevice::license();
let license = license.to_string_lossy();
assert_ne!(license.len(), 0);
// prints e.g. "GPL version 3 or later"
println!("{license}");
```

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

### AVAudioFifo - Initialization and Reallocation

Source: https://docs.rs/rsmpeg/0.18.0/%2Bffmpeg.8.0/rsmpeg/avutil/struct.AVAudioFifo_search=

This section covers the initialization and reallocation of an AVAudioFifo buffer.

```APIDOC
## AVAudioFifo - Initialization and Reallocation

### Description
Methods for creating and resizing an audio FIFO buffer.

### Methods

#### `new(sample_fmt: AVSampleFormat, channels: i32, nb_samples: i32) -> Self`
Allocate an AVAudioFifo with the specified format, number of channels, and sample count.

#### `realloc(&mut self, nb_samples: i32)`
Reallocate an existing AVAudioFifo to hold a new number of samples.
```

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

### Initialize SwrContext with Options

Source: https://docs.rs/rsmpeg/0.18.0/%2Bffmpeg.8.0/src/rsmpeg/swresample/swresample.rs

Creates and initializes a new SwrContext with specified input and output audio parameters. It handles allocation and setting of parameters like channel layout, sample format, and sample rate. Returns an error if parameters are invalid or insufficient.

```Rust
pub fn new(
        out_ch_layout: &ffi::AVChannelLayout,
        out_sample_fmt: ffi::AVSampleFormat,
        out_sample_rate: i32,
        in_ch_layout: &ffi::AVChannelLayout,
        in_sample_fmt: ffi::AVSampleFormat,
        in_sample_rate: i32,
    ) -> Result<Self> {
        let mut context = ptr::null_mut();
        unsafe {
            ffi::swr_alloc_set_opts2(
                &mut context,
                out_ch_layout,
                out_sample_fmt,
                out_sample_rate,
                in_ch_layout,
                in_sample_fmt,
                in_sample_rate,
                0,
                ptr::null_mut(),
            )
        }
        .upgrade()?;
        Ok(unsafe { Self::from_raw(NonNull::new(context).unwrap()) })
    }
```

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

### Get Bitfield Value from __BindgenBitfieldUnit in Rust

Source: https://docs.rs/rsmpeg/0.18.0/%2Bffmpeg.8.0/rsmpeg/ffi/struct.__BindgenBitfieldUnit_search=std%3A%3Avec

Provides methods to extract a sequence of bits (a bitfield) from the storage, starting at a specified offset and with a given width. Returns the value as a u64. Includes safe and unsafe raw access.

```Rust
pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64

pub unsafe fn raw_get(
    this: *const __BindgenBitfieldUnit<Storage>,
    bit_offset: usize,
    bit_width: u8,
) -> u64
```

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

### Get Element Offset (Rust - Nightly)

Source: https://docs.rs/rsmpeg/0.18.0/%2Bffmpeg.8.0/rsmpeg/avutil/struct.AVMmap_search=u32+-%3E+bool

Calculates the byte offset of an element reference within a slice. Returns `Some(index)` if the element reference points to the start of an element, and `None` otherwise. This API is experimental and requires the `substr_range` feature. Panics if `T` is zero-sized.

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

let nums: &[u32] = &[1, 7, 1, 1];
let num = &nums[2];

assert_eq!(num, &1);
assert_eq!(nums.element_offset(num), Some(2));

// Example: Returning None with an unaligned element
let arr: &[[u32; 2]] = &[[0, 1], [2, 3]];
let flat_arr: &[u32] = arr.as_flattened();

let ok_elm: &[u32; 2] = flat_arr[0..2].try_into().unwrap();
let weird_elm: &[u32; 2] = flat_arr[1..3].try_into().unwrap();

assert_eq!(ok_elm, &[0, 1]);
assert_eq!(weird_elm, &[1, 2]);

assert_eq!(arr.element_offset(ok_elm), Some(0)); // Points to element 0
assert_eq!(arr.element_offset(weird_elm), None); // Points between element 0 and 1
```

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

### avdevice_register_all

Source: https://docs.rs/rsmpeg/0.18.0/%2Bffmpeg.8.0/rsmpeg/ffi/fn.avdevice_register_all_search=std%3A%3Avec

Initializes the libavdevice library and registers all available input and output devices.

```APIDOC
## avdevice_register_all

### Description
Initialize libavdevice and register all the input and output devices.

### Method
`pub unsafe extern "C" fn`

### Endpoint
N/A (This is a function call, not a REST endpoint)

### Parameters
None

### Request Example
N/A

### Response
#### Success Response (void)
This function does not return a value.

#### Response Example
N/A
```

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

### Initialization and Configuration

Source: https://docs.rs/rsmpeg/0.18.0/%2Bffmpeg.8.0/rsmpeg/ffi/index_search=u32+-%3E+bool

Functions related to initializing, freeing, and configuring codec contexts and related structures.

```APIDOC
## av_tx_uninit

### Description
Frees a context and sets *ctx to NULL, does nothing when *ctx == NULL.

### Method
N/A (Function Signature)

### Endpoint
N/A

### Parameters
N/A

### Request Example
N/A

### Response
N/A

## avcodec_alloc_context3

### Description
Allocates an AVCodecContext and sets its fields to default values. The resulting struct should be freed with avcodec_free_context().

### Method
N/A (Function Signature)

### Endpoint
N/A

### Parameters
N/A

### Request Example
N/A

### Response
N/A

## avcodec_dct_alloc

### Description
Allocates a AVDCT context. This needs to be initialized with avcodec_dct_init() after optionally configuring it with AVOptions.

### Method
N/A (Function Signature)

### Endpoint
N/A

### Parameters
N/A

### Request Example
N/A

### Response
N/A

## avcodec_dct_init

### Description
Initializes a DCT context.

### Method
N/A (Function Signature)

### Endpoint
N/A

### Parameters
N/A

### Request Example
N/A

### Response
N/A

## avcodec_align_dimensions

### Description
Modify width and height values so that they will result in a memory buffer that is acceptable for the codec if you do not use any horizontal padding.

### Method
N/A (Function Signature)

### Endpoint
N/A

### Parameters
N/A

### Request Example
N/A

### Response
N/A

## avcodec_align_dimensions2

### Description
Modify width and height values so that they will result in a memory buffer that is acceptable for the codec if you also ensure that all line sizes are a multiple of the respective linesize_align[i].

### Method
N/A (Function Signature)

### Endpoint
N/A

### Parameters
N/A

### Request Example
N/A

### Response
N/A

## avcodec_configuration

### Description
Return the libavcodec build-time configuration.

### Method
N/A (Function Signature)

### Endpoint
N/A

### Parameters
N/A

### Request Example
N/A

### Response
N/A

## avcodec_dct_get_class

### Description
Get the AVClass for AVDCT.

### Method
N/A (Function Signature)

### Endpoint
N/A

### Parameters
N/A

### Request Example
N/A

### Response
N/A

## avcodec_decode_subtitle2

### Description
Decode subtitle data from a packet.

### Method
N/A (Function Signature)

### Endpoint
N/A

### Parameters
N/A

### Request Example
N/A

### Response
N/A
```

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

### Get swresample license in Rust

Source: https://docs.rs/rsmpeg/0.18.0/%2Bffmpeg.8.0/rsmpeg/swresample/fn.license_search=std%3A%3Avec

Retrieves the license of the linked libswresample library. This function returns a static C-string slice representing the license, which could be static or dynamic. The example demonstrates how to convert this to a Rust string and assert that it is not empty.

```rust
pub fn license() -> &'static CStr

use rsmpeg::swresample;

let license = swresample::license();
let license = license.to_string_lossy();
assert_ne!(license.len(), 0);
// prints e.g. "GPL version 3 or later"
println!("{license}");
```
Tokens:
Raw