Crate Rsmpeg

https://docs.rs/rsmpeg/latest/rsmpeg/
Admin
Crate rsmpeg provides Rust bindings for the FFmpeg libraries, enabling Rust applications to utilize...
Tokens:1,360,412
Snippets:13,889
Trust Score:9.1
Update:4 months ago
Show doc for...
Tokens:
Raw
### FromIterator Example (Ok)

Source: https://docs.rs/rsmpeg/latest/rsmpeg/error/type.Result.html

Demonstrates collecting an iterator of Results into a single Result, where all elements are Ok. This example increments integers and checks for overflow.

```rust
let v = vec![1, 2];
let res: Result<Vec<u32>, &'static str> = v.iter().map(|x: &u32| 
    x.checked_add(1).ok_or("Overflow!")
).collect();
assert_eq!(res, Ok(vec![2, 3]));
```

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

### Option::as_pin_ref Example

Source: https://docs.rs/rsmpeg/latest/rsmpeg/ffi/type.AVFifoCB.html

Demonstrates converting a Pin<&Option<T>> to an Option<Pin<&T>>.

```rust
pub const fn as_pin_ref(self: Pin<&Option<T>>) -> Option<Pin<&T>>

```

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

### Get Sample Format Name

Source: https://docs.rs/rsmpeg/latest/rsmpeg/avutil/fn.get_sample_fmt_name.html

Demonstrates how to get the string name for a known AVSampleFormat. It asserts that the name for `AV_SAMPLE_FMT_FLT` is indeed "flt".

```rust
assert_eq!(
    CString::new("flt").ok().as_deref(),
    get_sample_fmt_name(AV_SAMPLE_FMT_FLT)
);
```

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

### av_xtea_le_init

Source: https://docs.rs/rsmpeg/latest/rsmpeg/ffi/index.html

Initialize an AVXTEA context.

```APIDOC
## av_xtea_le_init

### Description
Initialize an AVXTEA context.

### Method
(Not specified, likely a function call)

### Parameters
(Not specified)
```

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

### get

Source: https://docs.rs/rsmpeg/latest/rsmpeg/ffi/struct.__BindgenBitfieldUnit.html

Safely retrieves a sequence of bits starting from a given offset.

```APIDOC
## `get` Method

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

Retrieves a value from the bitfield, starting at `bit_offset` and spanning `bit_width` bits. The result is returned as a `u64`. This is a safe method.
```

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

### Getting Metadata with and_then

Source: https://docs.rs/rsmpeg/latest/rsmpeg/error/type.Result.html

Shows how to use `and_then` to chain operations that might fail, such as getting file metadata. This example uses `Path::metadata` and `metadata.modified`.

```rust
use std::{io::ErrorKind, path::Path};

// Note: on Windows "/" maps to "C:\\"
let root_modified_time = Path::new("/").metadata().and_then(|md| md.modified());
assert!(root_modified_time.is_ok());

let should_fail = Path::new("/bad/path").metadata().and_then(|md| md.modified());
assert!(should_fail.is_err());
assert_eq!(should_fail.unwrap_err().kind(), ErrorKind::NotFound);
```

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

### av_xtea_init

Source: https://docs.rs/rsmpeg/latest/rsmpeg/ffi/index.html

Initialize an AVXTEA context.

```APIDOC
## av_xtea_init

### Description
Initialize an AVXTEA context.

### Method
(Not specified, likely a function call)

### Parameters
(Not specified)
```

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

### Rust Vec len Example

Source: https://docs.rs/rsmpeg/latest/rsmpeg/avutil/struct.AVImage.html

Demonstrates how to get the number of elements currently in a vector using the `len()` method.

```rust
let a = vec![1, 2, 3];
assert_eq!(a.len(), 3);
```

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

### Box::from_raw Example: Manual Allocation

Source: https://docs.rs/rsmpeg/latest/rsmpeg/avformat/type.WritePacketCallback.html

Shows how to manually create a Box from scratch using the global allocator and Box::from_raw. This requires careful memory management.

```rust
use std::alloc::{alloc, Layout};

unsafe {
    let ptr = alloc(Layout::new::<i32>()) as *mut i32;
    // In general .write is required to avoid attempting to destruct
    // the (uninitialized) previous contents of `ptr`, though for this
    // simple example `*ptr = 5` would have worked as well.
    ptr.write(5);
    let x = Box::from_raw(ptr);
}

```

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

### Opening a Decoder with Options

Source: https://docs.rs/rsmpeg/latest/rsmpeg/ffi/fn.avcodec_open2.html

Demonstrates how to set options for a decoder using av_dict_set and then open the codec context with avcodec_open2. Ensure the codec is found before proceeding.

```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);
```

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

### Rust Vec as_slice Example

Source: https://docs.rs/rsmpeg/latest/rsmpeg/avutil/struct.AVImage.html

Shows how to get a slice of the entire vector's contents using `as_slice()`.

```rust
use std::io::{self, Write};
let buffer = vec![1, 2, 3, 5, 8];
io::sink().write(buffer.as_slice()).unwrap();
```

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

### Filter Information and Linking

Source: https://docs.rs/rsmpeg/latest/rsmpeg/ffi/index.html

Functions to retrieve filter license, link filters, get hardware frames context from a link, and get pad information.

```APIDOC
## avfilter_license

### Description
Return the libavfilter license.

### Method
(Not specified, likely internal FFmpeg API)

### Endpoint
(Not applicable)

## avfilter_link

### Description
Link two filters together.

### Method
(Not specified, likely internal FFmpeg API)

### Endpoint
(Not applicable)

## avfilter_link_get_hw_frames_ctx

### Description
Get the hardware frames context of a filter link.

### Method
(Not specified, likely internal FFmpeg API)

### Endpoint
(Not applicable)

## avfilter_pad_get_name

### Description
Get the name of an AVFilterPad.

### Method
(Not specified, likely internal FFmpeg API)

### Endpoint
(Not applicable)

## avfilter_pad_get_type

### Description
Get the type of an AVFilterPad.

### Method
(Not specified, likely internal FFmpeg API)

### Endpoint
(Not applicable)
```

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

### Rust Option unwrap_or_default Example

Source: https://docs.rs/rsmpeg/latest/rsmpeg/ffi/type.av_format_control_message.html

Demonstrates using unwrap_or_default to get the contained value or the default value if the Option is None.

```rust
assert_eq!(x.unwrap_or_default(), 0);
assert_eq!(y.unwrap_or_default(), 12);
```

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

### Initialize libavdevice

Source: https://docs.rs/rsmpeg/latest/rsmpeg/ffi/fn.avdevice_register_all.html

Call this function to initialize libavdevice and register all devices. This is a low-level FFI call.

```rust
pub unsafe extern "C" fn avdevice_register_all()

```

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

### get_packed_sample_fmt

Source: https://docs.rs/rsmpeg/latest/rsmpeg/avutil/fn.get_packed_sample_fmt.html

Get the packed alternative form of the given sample format, return `None` on error. For example, `AV_SAMPLE_FMT_S16P` maps to `AV_SAMPLE_FMT_S16`.

```APIDOC
## get_packed_sample_fmt

### Description
Get the packed alternative form of the given sample format, return `None` on error.
i.e. `AV_SAMPLE_FMT_S16P` => `AV_SAMPLE_FMT_S16`

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

### Parameters
#### Path Parameters
- **sample_fmt** (AVSampleFormat) - The input sample format.

### Response
#### Success Response
- **AVSampleFormat** - The packed alternative sample format, or `None` if an error occurred.

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

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

### av_xtea_init

Source: https://docs.rs/rsmpeg/latest/rsmpeg/ffi/fn.av_xtea_init.html

Initializes an AVXTEA context with a provided key. The key is expected to be 16 bytes and is interpreted as big-endian 32-bit numbers.

```APIDOC
## Function av_xtea_init

### Description
Initialize an AVXTEA context.

### Parameters
#### Path Parameters
- **ctx** (*mut AVXTEA*) - Description: an AVXTEA context
- **key** (*const u8*) - Description: a key of 16 bytes used for encryption/decryption, interpreted as big endian 32 bit numbers

### Safety
This function is unsafe and should be called with care.
```

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

### get_planar_sample_fmt

Source: https://docs.rs/rsmpeg/latest/rsmpeg/avutil/fn.get_planar_sample_fmt.html

Get the planar alternative form of the given sample format. Returns `None` on error. For example, `AV_SAMPLE_FMT_S16` maps to `AV_SAMPLE_FMT_S16P`.

```APIDOC
## Function get_planar_sample_fmt

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

### Description
Gets the planar alternative sample format for a given `AVSampleFormat`. If the input format does not have a planar equivalent or an error occurs, `None` is returned.

### Example
```rust
assert_eq!(Some(AV_SAMPLE_FMT_S16P), get_planar_sample_fmt(AV_SAMPLE_FMT_S16));
```
```

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

### SwrContext::init

Source: https://docs.rs/rsmpeg/latest/rsmpeg/swresample/struct.SwrContext.html

Initializes the SwrContext after all user parameters have been set. This must be called before performing any conversion.

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

### Description
Initialize context after user parameters have been set.

### Returns
Returns `Ok(())` on success, or `Err` on initialization failure.
```

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

### Get libavfilter License

Source: https://docs.rs/rsmpeg/latest/rsmpeg/avfilter/fn.license.html

Retrieves the license of the linked libavfilter library. This example demonstrates how to call the function and print the license string. Ensure that libavfilter is correctly linked.

```rust
use rsmpeg::avfilter;

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

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

### Manually Create Box from Scratch with System Allocator

Source: https://docs.rs/rsmpeg/latest/rsmpeg/avformat/type.ReadPacketCallback.html

Demonstrates manually creating a `Box` from scratch using the system allocator. This involves allocating memory, writing the value, and then using `Box::from_raw_in` to manage it. Ensure proper initialization of the memory before creating the `Box`.

```rust
#![feature(allocator_api, slice_ptr_get)]

use std::alloc::{Allocator, Layout, System};

unsafe {
    let ptr = System.allocate(Layout::new::<i32>())?.as_mut_ptr() as *mut i32;
    // In general .write is required to avoid attempting to destruct
    // the (uninitialized) previous contents of `ptr`, though for this
    // simple example `*ptr = 5` would have worked as well.
    ptr.write(5);
    let x = Box::from_raw_in(ptr, System);
}

```

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

### Querying Multi-Component Option Ranges

Source: https://docs.rs/rsmpeg/latest/rsmpeg/ffi/struct.AVOptionRanges.html

Example demonstrating how to query and iterate through multi-component option ranges, such as for image sizes. This requires using AV_OPT_MULTI_COMPONENT_RANGE with av_opt_query_ranges.

```c
int range_index, component_index;
AVOptionRanges *ranges;
AVOptionRange *range[3]; //may require more than 3 in the future.
av_opt_query_ranges(&ranges, obj, key, AV_OPT_MULTI_COMPONENT_RANGE);
for (range_index = 0; range_index < ranges->nb_ranges; range_index++) {
    for (component_index = 0; component_index < ranges->nb_components; component_index++) 
        range[component_index] = ranges->range[ranges->nb_ranges * component_index + range_index]; //do something with range here.
}
av_opt_freep_ranges(&ranges);
```

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

### Rust Slice `strip_prefix` Examples

Source: https://docs.rs/rsmpeg/latest/rsmpeg/avutil/struct.AVMmap.html

Removes a prefix from a slice, returning the remainder. Returns `None` if the slice does not start with the prefix. An empty prefix returns the original slice.

```rust
let v = &[10, 40, 30];
assert_eq!(v.strip_prefix(&[10]), Some(&[40, 30][..]));
assert_eq!(v.strip_prefix(&[10, 40]), Some(&[30][..]));
assert_eq!(v.strip_prefix(&[10, 40, 30]), Some(&[][..]));
assert_eq!(v.strip_prefix(&[50]), None);
assert_eq!(v.strip_prefix(&[10, 50]), None);
```

```rust
let prefix : &str = "he";
assert_eq!(b"hello".strip_prefix(prefix.as_bytes()),
           Some(b"llo".as_ref()));
```

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

### avdevice_register_all

Source: https://docs.rs/rsmpeg/latest/rsmpeg/ffi/fn.avdevice_register_all.html

Initializes libavdevice and registers all input and output devices.

```APIDOC
## avdevice_register_all

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

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

### Endpoint
N/A (FFI function)

### Parameters
None

### Request Example
N/A (FFI function)

### Response
N/A (FFI function)
```

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

### Get libavdevice license

Source: https://docs.rs/rsmpeg/latest/rsmpeg/avdevice/fn.license.html

Call `avdevice::license()` to retrieve the license string of the linked `libavdevice`. This function returns a `&'static CStr`. The example demonstrates converting it to a displayable string and asserting that it is not empty.

```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}");
```

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

### Opening a Decoder using Codec Parameters

Source: https://docs.rs/rsmpeg/latest/rsmpeg/ffi/fn.avcodec_open2.html

Shows how to initialize a codec context using AVCodecParameters, typically obtained from a demuxer's AVStream. This is followed by opening the codec context with avcodec_open2.

```c
AVStream *stream = ...;
context = avcodec_alloc_context3(codec);
if (avcodec_parameters_to_context(context, stream->codecpar) < 0) exit(1);
if (avcodec_open2(context, codec, NULL) < 0) exit(1);
```

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

### av_strstart Function Signature

Source: https://docs.rs/rsmpeg/latest/rsmpeg/ffi/fn.av_strstart.html

This is the FFI signature for the av_strstart function. It is marked as unsafe because it deals with raw pointers and C-style string manipulation. Use this function to check if a string starts with a given prefix and to get a pointer to the rest of the string.

```rust
pub unsafe extern "C" fn av_strstart(
    str_: *const i8,
    pfx: *const i8,
    ptr: *mut *const i8,
) -> i32
```

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

### Get Element Offset in Slice

Source: https://docs.rs/rsmpeg/latest/rsmpeg/avutil/struct.AVMmap.html

The `element_offset` method returns the index of an element reference within a slice. It uses pointer arithmetic and returns `None` if the reference is not aligned to the start of an element. This is distinct from `iter().position()` which uses element comparison.

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

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

```rust
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
```

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

### Open AVFormatContextInput

Source: https://docs.rs/rsmpeg/latest/rsmpeg/avformat/struct.AVFormatContextInputBuilder.html

Finishes building the input configuration and opens the AVFormatContextInput. Requires the builder's state to be complete.

```rust
pub fn open(self) -> Result<AVFormatContextInput>
where S: IsComplete,
```

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

### Get Supported Sample Formats

Source: https://docs.rs/rsmpeg/latest/rsmpeg/avcodec/struct.AVCodecContextRef.html

Retrieves a list of all supported sample formats for a given codec or the current codec context. Returns Some(&[]) if all formats are supported.

```rust
pub fn get_supported_sample_fmts(
  &self,
  codec: Option<&AVCodec>,
) -> Result<&[AVSampleFormat]>
```

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

### Getting Raw Pointer from Box (Aliasing Guarantee with Mutation)

Source: https://docs.rs/rsmpeg/latest/rsmpeg/avformat/type.WritePacketCallback.html

Demonstrates obtaining a raw constant pointer to a Box's contents and how it remains valid as long as no writes occur. The example shows that after a write operation, the constant pointer becomes invalid.

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

unsafe {
    let mut v = Box::new(0);
    let ptr1 = Box::as_ptr(&v);
    let ptr2 = Box::as_mut_ptr(&mut v);
    let _val = ptr2.read();
    // No write to this memory has happened yet, so `ptr1` is still valid.
    let _val = ptr1.read();
    // However, once we do a write...
    ptr2.write(1);
    // ... `ptr1` is no longer valid.
    // This would be UB: let _val = ptr1.read();
}

```

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

### Getting Raw Mutable Pointer from Box (Aliasing Guarantee)

Source: https://docs.rs/rsmpeg/latest/rsmpeg/avformat/type.WritePacketCallback.html

Illustrates obtaining a raw mutable pointer to a Box's contents. The example highlights the aliasing guarantee, showing that multiple mutable pointers can be obtained and used for writing without invalidating each other.

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

unsafe {
    let mut b = Box::new(0);
    let ptr1 = Box::as_mut_ptr(&mut b);
    ptr1.write(1);
    let ptr2 = Box::as_mut_ptr(&mut b);
    ptr2.write(2);
    // Notably, the write to `ptr2` did *not* invalidate `ptr1`:
    ptr1.write(3);
}

```

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

### Any Implementation

Source: https://docs.rs/rsmpeg/latest/rsmpeg/avfilter/struct.AVFilterContextMut.html

Provides runtime type information.

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

### fn type_id(&self) -> TypeId

Description: Gets the `TypeId` of `self`. Read more
```

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

### av_gettime_relative

Source: https://docs.rs/rsmpeg/latest/rsmpeg/ffi/fn.av_gettime_relative.html

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.

```APIDOC
## Function av_gettime_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.

### Signature
```rust
pub unsafe extern "C" fn av_gettime_relative() -> i64
```
```

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

### swr_init

Source: https://docs.rs/rsmpeg/latest/rsmpeg/ffi/index.html

Initialize context after user parameters have been set. @note The context must be configured using the AVOption API. This function initializes the SwrContext with user-defined parameters.

```APIDOC
## swr_init

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

### Method
Not Applicable (FFI Function)

### Endpoint
Not Applicable (FFI Function)

### Parameters
None

### Request Example
None

### Response
#### Success Response
- **Initialization Status** (integer) - 0 on success, a negative value on error.

#### Response Example
None
```

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

### av_hwdevice_get_type_name

Source: https://docs.rs/rsmpeg/latest/rsmpeg/ffi/index.html

Gets the string name of an AVHWDeviceType.

```APIDOC
## av_hwdevice_get_type_name

### Description
Get the string name of an AVHWDeviceType.

### Method
N/A

### Endpoint
N/A
```

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

### Get first element as slice

Source: https://docs.rs/rsmpeg/latest/rsmpeg/ffi/type.avfilter_execute_func.html

Demonstrates getting the first element of an Option as a slice, which is the inverse of as_slice.

```rust
for i in [Some(1234_u16), None] {
    assert_eq!(i.as_ref(), i.as_slice().first());
}
```

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

### Box::from_non_null Example: Manual Allocation

Source: https://docs.rs/rsmpeg/latest/rsmpeg/avformat/type.WritePacketCallback.html

Demonstrates manually creating a Box from scratch using the global allocator and Box::from_non_null. This is an experimental nightly-only feature.

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

use std::alloc::{alloc, Layout};
use std::ptr::NonNull;

unsafe {
    let non_null = NonNull::new(alloc(Layout::new::<i32>()).cast::<i32>())
        .expect("allocation failed");
    // In general .write is required to avoid attempting to destruct
    // the (uninitialized) previous contents of `non_null`.
    non_null.write(5);
    let x = Box::from_non_null(non_null);
}

```

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

### av_hwdevice_ctx_create

Source: https://docs.rs/rsmpeg/latest/rsmpeg/ffi/index.html

Opens a device of the specified type and creates an AVHWDeviceContext for it.

```APIDOC
## av_hwdevice_ctx_create

### Description
Open a device of the specified type and create an AVHWDeviceContext for it.

### Method
N/A

### Endpoint
N/A
```

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

### Get Bit Range: get

Source: https://docs.rs/rsmpeg/latest/rsmpeg/ffi/struct.__BindgenBitfieldUnit.html

Retrieves a value from a specified range of bits within the bitfield, defined by offset and width.

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

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

### FromIterator Example (Err)

Source: https://docs.rs/rsmpeg/latest/rsmpeg/error/type.Result.html

Demonstrates collecting an iterator of Results into a single Result, where an Err is encountered. This example checks for underflow.

```rust
let v = vec![1, 2, 0];
let res: Result<Vec<u32>, &'static str> = v.iter().map(|x: &u32| 
    x.checked_sub(1).ok_or("Underflow!")
).collect();
assert_eq!(res, Err("Underflow!"));
```

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

### av_xtea_le_init

Source: https://docs.rs/rsmpeg/latest/rsmpeg/ffi/fn.av_xtea_le_init.html

Initializes an AVXTEA context. The key is interpreted as little-endian 32-bit numbers and is used for encryption/decryption.

```APIDOC
## Function av_xtea_le_init

### Summary

```
pub unsafe extern "C" fn av_xtea_le_init(
    ctx: *mut AVXTEA,
    key: *const u8,
)
```

### Description

Initialize an AVXTEA context.

@param ctx an AVXTEA context
@param key a key of 16 bytes used for encryption/decryption, interpreted as little endian 32 bit numbers
```

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

### Get mutable slice's first element

Source: https://docs.rs/rsmpeg/latest/rsmpeg/ffi/type.avfilter_execute_func.html

Demonstrates getting the first mutable element of a slice from an Option, which is the inverse of as_mut_slice.

```rust
assert_eq!(Some(123).as_mut_slice().first_mut(), Some(&mut 123))
```

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

### Function av_hwdevice_ctx_create

Source: https://docs.rs/rsmpeg/latest/rsmpeg/ffi/fn.av_hwdevice_ctx_create.html

Opens a device of the specified type and creates an AVHWDeviceContext for it. This is a convenience function for simple cases. For more complex scenarios, manual device opening and wrapping with av_hwdevice_ctx_alloc()/av_hwdevice_ctx_init() is recommended. The created context is already initialized.

```APIDOC
## Function av_hwdevice_ctx_create

### Description
Opens a device of the specified type and creates an AVHWDeviceContext for it. This is a convenience function intended to cover the simple cases. Callers who need to fine-tune device creation/management should open the device manually and then wrap it in an AVHWDeviceContext using av_hwdevice_ctx_alloc()/av_hwdevice_ctx_init(). The returned context is already initialized and ready for use; the caller should not call av_hwdevice_ctx_init() on it. The user_opaque/free fields of the created AVHWDeviceContext are set by this function and should not be touched by the caller.

### Parameters
#### Path Parameters
- **device_ctx** (*mut *mut AVBufferRef) - Output - On success, a reference to the newly-created device context will be written here. The reference is owned by the caller and must be released with av_buffer_unref() when no longer needed. On failure, NULL will be written to this pointer.
- **type_** (u32) - Input - The type of the device to create.
- **device** (*const i8) - Input - A type-specific string identifying the device to open.
- **opts** (*mut AVDictionary) - Input - A dictionary of additional (type-specific) options to use in opening the device. The dictionary remains owned by the caller.
- **flags** (i32) - Input - Currently unused.

### Return Value
- **i32** - 0 on success, a negative AVERROR code on failure.
```

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

### Get First Element of Option Slice

Source: https://docs.rs/rsmpeg/latest/rsmpeg/ffi/type.AVFifoCB.html

Demonstrates getting the first element of a slice derived from an Option, showing the inverse relationship with as_slice.

```rust
for i in [Some(1234_u16), None] {
    assert_eq!(i.as_ref(), i.as_slice().first());
}

```

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

### Get Hardware Configuration

Source: https://docs.rs/rsmpeg/latest/rsmpeg/avcodec/struct.AVCodecRef.html

Retrieves supported hardware configurations for a codec at a specific index.

```rust
pub fn hw_config(&self, index: usize) -> Option<AVCodecHWConfig>
```

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

### AVAudioFifo Initialization and Management

Source: https://docs.rs/rsmpeg/latest/rsmpeg/avutil/struct.AVAudioFifo.html

Methods for creating, reallocating, and managing the state of an AVAudioFifo buffer.

```APIDOC
## AVAudioFifo::new

### Description
Allocates and initializes a new AVAudioFifo buffer with the specified audio format, channel count, and sample capacity.

### Signature
`pub fn new(sample_fmt: AVSampleFormat, channels: i32, nb_samples: i32) -> Self`

## AVAudioFifo::realloc

### Description
Reallocates the AVAudioFifo buffer to a new capacity for samples.

### Signature
`pub fn realloc(&mut self, nb_samples: i32)`

## AVAudioFifo::reset

### Description
Resets the AVAudioFifo buffer, emptying all contained audio samples.

### Signature
`pub fn reset(&mut self)`
```

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

### Get AVFilter Pointer

Source: https://docs.rs/rsmpeg/latest/rsmpeg/avfilter/struct.AVFilter.html

Provides methods to get a constant or mutable pointer to the AVFilter struct. Use these when interacting with lower-level FFmpeg APIs.

```rust
pub fn as_ptr(&self) -> *const AVFilter
```

```rust
pub fn as_mut_ptr(&mut self) -> *mut AVFilter
```

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

### av_md5_init

Source: https://docs.rs/rsmpeg/latest/rsmpeg/ffi/index.html

Initializes the MD5 hashing context.

```APIDOC
## av_md5_init

### Description
Initialize MD5 hashing.
```

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

### Unwrap Panic Example

Source: https://docs.rs/rsmpeg/latest/rsmpeg/ffi/type.AVFifoCB.html

Demonstrates the panic that occurs when calling unwrap on a None Option.

```rust
let x: Option<&str> = None;
assert_eq!(x.unwrap(), "air"); // fails

```

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

### AVIO_DATA_MARKER_BOUNDARY_POINT

Source: https://docs.rs/rsmpeg/latest/rsmpeg/ffi/constant.AVIO_DATA_MARKER_BOUNDARY_POINT.html

A point in the output bytestream where a demuxer can start parsing (for non self synchronizing bytestream formats). That is, any non-keyframe packet start point.

```APIDOC
## Constant AVIO_DATA_MARKER_BOUNDARY_POINT

### Description
A point in the output bytestream where a demuxer can start parsing (for non self synchronizing bytestream formats). That is, any non-keyframe packet start point.

### Value
`2u32`
```

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

### swr_init

Source: https://docs.rs/rsmpeg/latest/rsmpeg/ffi/fn.swr_init.html

Initializes a SwrContext. The context must be configured using the AVOption API before calling this function. It returns an AVERROR error code in case of failure.

```APIDOC
## swr_init

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

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

### Parameters
* **s** (*mut SwrContext*) - Input/Output - Swr context to initialize.

### Return Value
* **i32** - AVERROR error code in case of failure.
```

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

### swr_alloc

Source: https://docs.rs/rsmpeg/latest/rsmpeg/ffi/fn.swr_alloc.html

Allocates a SwrContext. Parameters must be set before calling swr_init(). Returns NULL on error.

```APIDOC
## swr_alloc

### Description
Allocates a SwrContext. If you use this function, you will need to set the parameters (manually or with `swr_alloc_set_opts2()`) before calling `swr_init()`.

### Returns
- `*mut SwrContext`: A pointer to the allocated SwrContext, or NULL on error.

### See Also
- `swr_alloc_set_opts2()`
- `swr_init()`
- `swr_free()`
```

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

### av_aes_ctr_init

Source: https://docs.rs/rsmpeg/latest/rsmpeg/ffi/index.html

Initializes an AVAESCTR context.

```APIDOC
## av_aes_ctr_init

### Description
Initialize an AVAESCTR context.
```

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

### Manually Create Box from Scratch with NonNull and System Allocator

Source: https://docs.rs/rsmpeg/latest/rsmpeg/avformat/type.ReadPacketCallback.html

Shows how to manually create a `Box` from scratch using a `NonNull` pointer obtained from the system allocator. The memory must be initialized before creating the `Box`.

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

use std::alloc::{Allocator, Layout, System};

unsafe {
    let non_null = System.allocate(Layout::new::<i32>())?.cast::<i32>();
    // In general .write is required to avoid attempting to destruct
    // the (uninitialized) previous contents of `non_null`.
    non_null.write(5);
    let x = Box::from_non_null_in(non_null, System);
}

```

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

### Get Audio Channels from AVFilterContext

Source: https://docs.rs/rsmpeg/latest/rsmpeg/ffi/fn.av_buffersink_get_channels.html

Use this function to get the number of audio channels associated with an AVFilterContext. This function is unsafe and requires a valid pointer to AVFilterContext.

```rust
pub unsafe extern "C" fn av_buffersink_get_channels(
    ctx: *const AVFilterContext,
) -> i32
```

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

### avdevice_configuration

Source: https://docs.rs/rsmpeg/latest/rsmpeg/ffi/fn.avdevice_configuration.html

Returns the libavdevice build-time configuration as a C-style string.

```APIDOC
## Function avdevice_configuration

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

### Signature
```rust
pub unsafe extern "C" fn avdevice_configuration() -> *const i8
```

### Return Value
A pointer to a null-terminated C string containing the configuration details.
```

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

### Getting the Last N Elements of a Slice

Source: https://docs.rs/rsmpeg/latest/rsmpeg/avutil/struct.AVMmap.html

Use `last_chunk` to get a reference to the last `N` elements of a slice. Returns `None` if the slice is shorter than `N`.

```rust
let u = [10, 40, 30];
assert_eq!(Some(&[40, 30]), u.last_chunk::<2>());

let v: &[i32] = &[10];
assert_eq!(None, v.last_chunk::<2>());

let w: &[i32] = &[];
assert_eq!(Some(&[]), w.last_chunk::<0>());
```

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

### Get libavcodec license

Source: https://docs.rs/rsmpeg/latest/rsmpeg/avcodec/fn.license.html

Call the `license` function to get the license string of the linked `libavcodec`. The result is a `CStr` that can be converted to a displayable string. Ensure `rsmpeg` is imported.

```rust
use rsmpeg::avcodec;

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

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

### av_twofish_init

Source: https://docs.rs/rsmpeg/latest/rsmpeg/ffi/index.html

Initializes an AVTWOFISH context.

```APIDOC
## av_twofish_init

### Description
Initialize an AVTWOFISH context.

### Parameters
None explicitly documented.
```

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

### AVFormatContextInputBuilder::open

Source: https://docs.rs/rsmpeg/latest/rsmpeg/avformat/struct.AVFormatContextInputBuilder.html

Finishes building the AVFormatContextInputBuilder and opens the input context.

```APIDOC
## AVFormatContextInputBuilder::open

### Description
Finishes building and performs the requested action.

### Method
`open`

### Parameters
None

### Returns
`Result<AVFormatContextInput>`
```

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

### gets Function Signature

Source: https://docs.rs/rsmpeg/latest/rsmpeg/ffi/fn.gets.html

This is the raw C function signature for gets as exposed through FFI. It is marked as unsafe because it involves raw pointer manipulation and external C library calls.

```rust
pub unsafe extern "C" fn gets(arg1: *mut i8) -> *mut i8
```

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

### Get Human-Readable Spherical Projection Name

Source: https://docs.rs/rsmpeg/latest/rsmpeg/ffi/fn.av_spherical_projection_name.html

Use this function to get the string name of an AVSphericalProjection enum value. It takes a `u32` representing the projection and returns a C-style string pointer.

```rust
pub unsafe extern "C" fn av_spherical_projection_name(
    projection: u32,
) -> *const i8
```

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

### av_parser_init

Source: https://docs.rs/rsmpeg/latest/rsmpeg/ffi/index.html

Initializes a parser.

```APIDOC
## av_parser_init

### Description
Initializes a parser.

### Method
Not specified (likely C function call)

### Endpoint
Not applicable (FFI function)

### Parameters
Not specified in source.

### Request Example
Not applicable.

### Response
Not specified in source.
```

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

### Option::ok_or_else Example

Source: https://docs.rs/rsmpeg/latest/rsmpeg/ffi/type.AVFifoCB.html

Demonstrates converting an Option to a Result using ok_or_else, providing a default error value when the Option is None.

```rust
let x: Option<&str> = None;
assert_eq!(x.ok_or_else(|| 0), Err(0));
```

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

### Get libavcodec configuration

Source: https://docs.rs/rsmpeg/latest/rsmpeg/avcodec/fn.configuration.html

Call the `configuration` function to get the `libavcodec` configuration string. The result is a `CStr` which can be converted to a displayable string. This is useful for verifying build options and linked libraries.

```rust
use rsmpeg::avcodec;

let configuration = avcodec::configuration();
let configuration = configuration.to_string_lossy();
assert_ne!(configuration.len(), 0);
// prints e.g. "--prefix=/usr --libdir=/usr/lib/x86_64-linux-gnu --enable-gpl --enable-version3 --enable-static --disable-shared"
println!("{configuration}");
```

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

### Get Planar Sample Format - Rust FFI

Source: https://docs.rs/rsmpeg/latest/rsmpeg/ffi/fn.av_get_planar_sample_fmt.html

Use this function to get the planar version of a sample format. If the format is already planar, the original format is returned. Returns `AV_SAMPLE_FMT_NONE` on error.

```rust
pub unsafe extern "C" fn av_get_planar_sample_fmt(
    sample_fmt: i32,
) -> i32
```

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

### Hardware Configuration and Supported Formats

Source: https://docs.rs/rsmpeg/latest/rsmpeg/avcodec/struct.AVCodec.html

Retrieve supported hardware configurations, framerates, pixel formats, sample rates, and sample formats for a given codec.

```rust
pub fn hw_config(&self, index: usize) -> Option<AVCodecHWConfig>
```

```rust
pub fn supported_framerates(&'codec self) -> Option<&'codec [AVRational]>
```

```rust
pub fn pix_fmts(&'codec self) -> Option<&'codec [AVPixelFormat]>
```

```rust
pub fn supported_samplerates(&'codec self) -> Option<&'codec [i32]>
```

```rust
pub fn sample_fmts(&'codec self) -> Option<&'codec [AVSampleFormat]>
```

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

### av_default_get_category

Source: https://docs.rs/rsmpeg/latest/rsmpeg/ffi/index.html

Gets the default category.

```APIDOC
## av_default_get_category

### Description
Gets the default category.
```

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

### SwsContext Initialization and Scaling

Source: https://docs.rs/rsmpeg/latest/rsmpeg/swscale/struct.SwsContext.html

Functions for initializing SwsContext for scaling operations and performing the scaling.

```APIDOC
## SwsContext

### `get_context`

```rust
pub fn get_context(
    src_w: i32,
    src_h: i32,
    src_format: AVPixelFormat,
    dst_w: i32,
    dst_h: i32,
    dst_format: AVPixelFormat,
    flags: SwsFlags,
    src_filter: Option<&SwsFilter>,
    dst_filter: Option<&SwsFilter>,
    param: Option<&[f64; 2]>,
) -> Option<Self>
```

Allocates and returns an `SwsContext`. You need it to perform scaling/conversion operations using `Self::scale()`.

Returns `None` when input is invalid. Parameter `flags` can be set to `rsmpeg::ffi::SWS_FAST_BILINEAR` etc.

### `get_cached_context`

```rust
pub fn get_cached_context(
    self,
    src_w: i32,
    src_h: i32,
    src_format: AVPixelFormat,
    dst_w: i32,
    dst_h: i32,
    dst_format: AVPixelFormat,
    flags: SwsFlags,
    src_filter: Option<&SwsFilter>,
    dst_filter: Option<&SwsFilter>,
    param: Option<&[f64; 2]>,
) -> Option<Self>
```

Checks if context can be reused, otherwise reallocates a new one.

Checks if the parameters are the ones already saved in context. If that is the case, returns the current context. Otherwise, frees context and gets a new context with the new parameters.

Be warned that `src_filter` and `dst_filter` are not checked, they are assumed to remain the same.

Returns `None` when context allocation or initiation failed.

### `scale`

```rust
pub unsafe fn scale(
    &mut self,
    src_slice: *const *const u8,
    src_stride: *const i32,
    src_slice_y: i32,
    src_slice_h: i32,
    dst: *const *mut u8,
    dst_stride: *const i32,
) -> Result<()>
```

Scales the image slice in `src_slice` and puts the resulting scaled slice in the image in `dst`. A slice is a sequence of consecutive rows in an image.

Slices have to be provided in sequential order, either in top-bottom or bottom-top order. If slices are provided in non-sequential order the behavior of the function is undefined.

#### Safety

The `src_slice` should be valid with the `src_stride`, `src_slice_y` and `src_slice_h`. The `dst` should be valid with the `dst_stride`.

### `scale_frame`

```rust
pub fn scale_frame(&mut self, src_frame: &AVFrame, src_slice_y: i32, src_slice_h: i32, dst_frame: &mut AVFrame) -> Result<()>
```

A wrapper of `Self::scale`, check it’s documentation.
```

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

### Get Sample Format Name - rsmpeg FFI

Source: https://docs.rs/rsmpeg/latest/rsmpeg/ffi/fn.av_get_sample_fmt_name.html

Use this unsafe function to get the string name of a sample format identifier. It returns NULL if the format is not recognized. Ensure the sample_fmt is a valid i32 value.

```rust
pub unsafe extern "C" fn av_get_sample_fmt_name(
    sample_fmt: i32,
) -> *const i8
```

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

### get_sample_fmt

Source: https://docs.rs/rsmpeg/latest/rsmpeg/avutil/fn.get_sample_fmt.html

Returns a sample format corresponding to the provided name. Returns None if an error occurs.

```APIDOC
## get_sample_fmt

### Description
Returns a sample format corresponding to the provided name. Returns None if an error occurs.

### Function Signature
```rust
pub fn get_sample_fmt(name: &CStr) -> Option<AVSampleFormat>
```

### Parameters
* `name` (*CStr*) - The name of the sample format to retrieve.

### Returns
* `Option<AVSampleFormat>` - The AVSampleFormat if found, otherwise None.

### Example
```rust
assert_eq!(
    Some(AV_SAMPLE_FMT_FLT),
    get_sample_fmt(&CString::new("flt").unwrap())
);
```
```

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

### Any::type_id

Source: https://docs.rs/rsmpeg/latest/rsmpeg/ffi/struct.AVCodecParserContext.html

Gets the `TypeId` of the implementing type.

```APIDOC
## Any::type_id

### Description
Gets the `TypeId` of `self`.

### Signature
`fn type_id(&self) -> TypeId`
```

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

### sws_frame_setup

Source: https://docs.rs/rsmpeg/latest/rsmpeg/ffi/fn.sws_frame_setup.html

Initializes internal state for frame scaling without performing the actual scaling. It checks for unsupported frame combinations and returns an appropriate error code.

```APIDOC
## sws_frame_setup

### Description
Like `sws_scale_frame`, but without actually scaling. It will instead merely initialize internal state that _would_ be required to perform the operation, as well as returning the correct error code for unsupported frame combinations.

### Function Signature
```rust
pub unsafe extern "C" fn sws_frame_setup(
    ctx: *mut SwsContext,
    dst: *const AVFrame,
    src: *const AVFrame,
) -> i32
```

### Parameters
- **ctx** (*mut SwsContext*) - The scaling context.
- **dst** (*const AVFrame*) - The destination frame to consider.
- **src** (*const AVFrame*) - The source frame to consider.

### Return Value
- **i32**: 0 on success, a negative AVERROR code on failure.
```

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

### Any::type_id

Source: https://docs.rs/rsmpeg/latest/rsmpeg/ffi/struct.AVClass.html

Gets the TypeId of the AVClass instance.

```APIDOC
## fn type_id(&self) -> TypeId

### Description
Gets the `TypeId` of `self`.

### Parameters
* `self`: A reference to the AVClass instance.

### Returns
The `TypeId` of the AVClass instance.
```

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

### av_lfg_init

Source: https://docs.rs/rsmpeg/latest/rsmpeg/ffi/index.html

N/A

```APIDOC
## av_lfg_init

### Description
N/A

### Method
N/A

### Endpoint
N/A
```

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

### av_dict_count

Source: https://docs.rs/rsmpeg/latest/rsmpeg/ffi/fn.av_dict_count.html

Get number of entries in dictionary.

```APIDOC
## av_dict_count

### Description
Get number of entries in dictionary.

### Parameters
#### Path Parameters
- **m** (*const AVDictionary) - Description: dictionary

### Returns
- **i32** - Description: number of entries in dictionary
```

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

### av_get_sample_fmt

Source: https://docs.rs/rsmpeg/latest/rsmpeg/ffi/fn.av_get_sample_fmt.html

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

```APIDOC
## Function: av_get_sample_fmt

### Description
Returns a sample format corresponding to `name`, or `AV_SAMPLE_FMT_NONE` on error.

### Signature
```rust
pub unsafe extern "C" fn av_get_sample_fmt(name: *const i8) -> i32
```

### Parameters
* `name` (*const i8) - A pointer to a null-terminated C string representing the sample format name.
```

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

### AVPixFmtDescriptorRef::name

Source: https://docs.rs/rsmpeg/latest/rsmpeg/avutil/struct.AVPixFmtDescriptorRef.html

Gets the name of the AVPixFmtDescriptor.

```APIDOC
## AVPixFmtDescriptorRef::name

### Description
Get name of the AVPixFmtDescriptor.

### Method
`pub fn name(&self) -> &CStr`
```

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

### Create AVHWDeviceContext

Source: https://docs.rs/rsmpeg/latest/rsmpeg/avutil/struct.AVHWDeviceContext.html

Opens a device of the specified type and creates an AVHWDeviceContext. This is a convenience function for simple cases. Callers needing fine-tuning should use alloc/init manually. The returned context is already initialized.

```rust
pub fn create(
    type: AVHWDeviceType,
    device: Option<&CStr>,
    opts: Option<&AVDictionary>,
    flags: c_int,
) -> Result<Self>
```

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

### hwdevice_get_type_name

Source: https://docs.rs/rsmpeg/latest/rsmpeg/avutil/fn.hwdevice_get_type_name.html

Get the string name of an AVHWDeviceType.

```APIDOC
## Function hwdevice_get_type_name

### Description
Get the string name of an AVHWDeviceType.

### Signature
```rust
pub fn hwdevice_get_type_name(type: AVHWDeviceType) -> Option<&'static CStr>
```

### Parameters
#### Path Parameters
- **type** (AVHWDeviceType) - The hardware device type to get the name for.

### Returns
- **Option<&'static CStr>** - An optional static C string representing the name of the AVHWDeviceType, or None if the type is unknown.
```

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

### Iterating AVOptions with av_opt_next

Source: https://docs.rs/rsmpeg/latest/rsmpeg/ffi/fn.av_opt_next.html

This C function signature demonstrates how to iterate over all AVOptions belonging to an object. Use the previous result or NULL for the initial call.

```c
pub unsafe extern "C" fn av_opt_next(
    obj: *const c_void,
    prev: *const AVOption,
) -> *const AVOption
```

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

### AVFormatContextOutput::oformat

Source: https://docs.rs/rsmpeg/latest/rsmpeg/avformat/struct.AVFormatContextOutput.html

Gets the AVOutputFormatRef from the AVFormatContextOutput.

```APIDOC
## pub fn oformat(&self) -> AVOutputFormatRef<'static>

### Description
Get `AVOutputFormat` from the `AVFormatContextOutput`.

### Method
`oformat`
```

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

### avformat_network_init

Source: https://docs.rs/rsmpeg/latest/rsmpeg/ffi/fn.avformat_network_init.html

Initializes network libraries globally. This is an optional function and is not recommended for newer versions of GnuTLS or OpenSSL. It's mainly for compatibility with older libraries to address thread-safety concerns. Call this before starting any threads that use these libraries if necessary.

```APIDOC
## Function avformat_network_init

### Description
Performs global initialization of network libraries. This function is optional and not recommended for newer versions of GnuTLS or OpenSSL. It exists to work around thread-safety issues with older versions of these libraries.

### Synopsis
```rust
pub unsafe extern "C" fn avformat_network_init() -> i32
```

### Notes
- This function is primarily for compatibility with older GnuTLS or OpenSSL libraries.
- If libavformat is linked to newer versions of these libraries, or if they are not used, calling this function is unnecessary.
- If required, it must be called before any other threads using these libraries are started.
- This function is planned for deprecation and will eventually have no purpose.
```

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

### avcodec_dct_init

Source: https://docs.rs/rsmpeg/latest/rsmpeg/ffi/index.html

Initialize a AVDCT context.

```APIDOC
## avcodec_dct_init

### Description
Initialize a AVDCT context.

### Method
(Not specified, likely a function call)

### Parameters
(Not specified)
```

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

### av_packet_get_side_data

Source: https://docs.rs/rsmpeg/latest/rsmpeg/ffi/index.html

Gets side information from a packet.

```APIDOC
## av_packet_get_side_data

### Description
Gets side information from a packet.

### Method
Not specified (likely C function call)

### Endpoint
Not applicable (FFI function)

### Parameters
Not specified in source.

### Request Example
Not applicable.

### Response
Not specified in source.
```

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

### Create AVFormatContextOutput

Source: https://docs.rs/rsmpeg/latest/rsmpeg/avformat/struct.AVFormatContextOutput.html

Opens a file and creates an AVFormatContextOutput instance. Custom IO can be provided via AVIOContext.

```rust
pub fn create(filename: &CStr) -> Result<Self>
```

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

### av_aes_ctr_get_iv

Source: https://docs.rs/rsmpeg/latest/rsmpeg/ffi/index.html

Gets the current IV for AVAESCTR.

```APIDOC
## av_aes_ctr_get_iv

### Description
Get the current iv
```

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

### av_hwframe_transfer_get_formats

Source: https://docs.rs/rsmpeg/latest/rsmpeg/ffi/index.html

Get a list of possible source or target formats usable in av_hwframe_transfer_data().

```APIDOC
## av_hwframe_transfer_get_formats

### Description
Get a list of possible source or target formats usable in av_hwframe_transfer_data().

### Method
N/A

### Endpoint
N/A
```

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

### av_vorbis_parse_frame

Source: https://docs.rs/rsmpeg/latest/rsmpeg/ffi/index.html

Gets the duration for a Vorbis packet.

```APIDOC
## av_vorbis_parse_frame

### Description
Get the duration for a Vorbis packet.

### Parameters
None explicitly documented.
```

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

### Box::into_raw Example: Equivalent Manual Cleanup

Source: https://docs.rs/rsmpeg/latest/rsmpeg/avformat/type.WritePacketCallback.html

Presents an alternative manual cleanup method for a Box converted to a raw pointer, using Box::from_raw within a drop call.

```rust
let x = Box::new(String::from("Hello"));
let ptr = Box::into_raw(x);
unsafe {
    drop(Box::from_raw(ptr));
}

```

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

### av_cast5_init

Source: https://docs.rs/rsmpeg/latest/rsmpeg/ffi/fn.av_cast5_init.html

Initializes an AVCAST5 context with a provided key and key bits for encryption/decryption.

```APIDOC
## Function av_cast5_init

### Description
Initialize an AVCAST5 context.

### Signature
```rust
pub unsafe extern "C" fn av_cast5_init(
    ctx: *mut AVCAST5,
    key: *const u8,
    key_bits: i32,
) -> i32
```

### Parameters
* `ctx` (*mut AVCAST5) - An AVCAST5 context.
* `key` (*const u8) - A key of 5,6,…16 bytes used for encryption/decryption.
* `key_bits` (i32) - Number of keybits: possible are 40,48,…,128.

### Return Value
* `i32` - 0 on success, less than 0 on failure.
```
Tokens:
Raw