### Example Usage: Compress and Decompress Font

Source: https://docs.rs/woofwoof/1.0.2/src/woofwoof/lib.rs.html

Demonstrates a typical workflow of compressing a TTF font to WOFF2 format and then decompressing it back to TTF. This example assumes the existence of a 'font.ttf' file.

```rust
// Compress a TTF font to WOFF2
let ttf_data = std::fs::read("font.ttf").unwrap();
let woff2_data = woofwoof::compress(&ttf_data, "", 8, true)
    .expect("compression failed");

// Decompress back to TTF
let ttf_again = woofwoof::decompress(&woff2_data)
    .expect("decompression failed");

```

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

### Compress and Decompress Fonts with woofwoof

Source: https://docs.rs/woofwoof/1.0.2/index.html

Demonstrates the basic workflow for compressing a TTF font to WOFF2 and decompressing it back to TTF.

```rust
// Compress a TTF font to WOFF2
let ttf_data = std::fs::read("font.ttf").unwrap();
let woff2_data = woofwoof::compress(&ttf_data, "", 8, true)
    .expect("compression failed");

// Decompress back to TTF
let ttf_again = woofwoof::decompress(&woff2_data)
    .expect("decompression failed");
```

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

### Compress Data with Brotli (C ABI)

Source: https://docs.rs/woofwoof/1.0.2/src/woofwoof/brotli_shim.rs.html

Implements the BrotliEncoderCompress function for C compatibility. It takes input data and compresses it using Brotli, writing the output to a provided buffer. Ensure input and output buffers are valid and sizes are correctly specified.

```rust
use std::ffi::c_int;
use std::slice;

use brotli::BrotliCompress;
use brotli::enc::BrotliEncoderParams;
use brotli::enc::backward_references::BrotliEncoderMode;

// Constants matching brotli C API
pub const BROTLI_TRUE: c_int = 1;
pub const BROTLI_FALSE: c_int = 0;

// BrotliEncoderMode values (must match C enum)
const BROTLI_MODE_TEXT: c_int = 1;
const BROTLI_MODE_FONT: c_int = 2;

/// Compress data using brotli.
///
/// This matches the C API signature:
/// ```c
/// BROTLI_BOOL BrotliEncoderCompress(
///     int quality, int lgwin, BrotliEncoderMode mode,
///     size_t input_size, const uint8_t* input_buffer,
///     size_t* encoded_size, uint8_t* encoded_buffer);
/// ```
#[unsafe(no_mangle)]
pub unsafe extern "C" fn woofwoof_BrotliEncoderCompress(
    quality: c_int,
    lgwin: c_int,
    mode: c_int,
    input_size: usize,
    input_buffer: *const u8,
    encoded_size: *mut usize,
    encoded_buffer: *mut u8,
) -> c_int {
    if input_buffer.is_null() || encoded_size.is_null() || encoded_buffer.is_null() {
        return BROTLI_FALSE;
    }

    unsafe {
        let input = slice::from_raw_parts(input_buffer, input_size);
        let max_output_size = *encoded_size;
        let output = slice::from_raw_parts_mut(encoded_buffer, max_output_size);

        let params = BrotliEncoderParams {
            quality,
            lgwin,
            mode: match mode {
                BROTLI_MODE_TEXT => BrotliEncoderMode::BROTLI_MODE_TEXT,
                BROTLI_MODE_FONT => BrotliEncoderMode::BROTLI_MODE_FONT,
                _ => BrotliEncoderMode::BROTLI_MODE_GENERIC,
            },
            ..Default::default()
        };

        let mut input_cursor = std::io::Cursor::new(input);
        let mut output_cursor = std::io::Cursor::new(output);

        match BrotliCompress(&mut input_cursor, &mut output_cursor, &params) {
            Ok(_) => {
                *encoded_size = output_cursor.position() as usize;
                BROTLI_TRUE
            }
            Err(_) => BROTLI_FALSE,
        }
    }
}
```

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

### Brotli Compression API

Source: https://docs.rs/woofwoof/1.0.2/src/woofwoof/brotli_shim.rs.html

Provides a C ABI compatible function for compressing data using the Brotli algorithm. This function mirrors the C API signature for BrotliEncoderCompress.

```APIDOC
## woofwoof_BrotliEncoderCompress

### Description
Compress data using brotli.

This matches the C API signature:
```c
BROTLI_BOOL BrotliEncoderCompress(
    int quality, int lgwin, BrotliEncoderMode mode,
    size_t input_size, const uint8_t* input_buffer,
    size_t* encoded_size, uint8_t* encoded_buffer);
```

### Method
Extern C Function (C ABI)

### Endpoint
N/A (C ABI function)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```json
{
  "example": "This function is called directly from C/C++ and does not have a JSON request body."
}
```

### Response
#### Success Response (200)
Returns `BROTLI_TRUE` (1) on success, `BROTLI_FALSE` (0) on failure.

#### Response Example
```json
{
  "example": "1 (BROTLI_TRUE) or 0 (BROTLI_FALSE)"
}
```
```

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

### Decompress Data with Brotli (C ABI)

Source: https://docs.rs/woofwoof/1.0.2/src/woofwoof/brotli_shim.rs.html

Implements the BrotliDecoderDecompress function for C compatibility. It takes compressed data and decompresses it, writing the output to a provided buffer. Ensure input and output buffers are valid and sizes are correctly specified.

```rust
use std::ffi::c_int;
use std::slice;

use brotli::BrotliDecompress;

// BrotliDecoderResult values
pub const BROTLI_DECODER_RESULT_ERROR: c_int = 0;
pub const BROTLI_DECODER_RESULT_SUCCESS: c_int = 1;

/// Decompress brotli-compressed data.
///
/// This matches the C API signature:
/// ```c
/// BrotliDecoderResult BrotliDecoderDecompress(
///     size_t encoded_size, const uint8_t* encoded_buffer,
///     size_t* decoded_size, uint8_t* decoded_buffer);
/// ```
#[unsafe(no_mangle)]
pub unsafe extern "C" fn woofwoof_BrotliDecoderDecompress(
    encoded_size: usize,
    encoded_buffer: *const u8,
    decoded_size: *mut usize,
    decoded_buffer: *mut u8,
) -> c_int {
    if encoded_buffer.is_null() || decoded_size.is_null() || decoded_buffer.is_null() {
        return BROTLI_DECODER_RESULT_ERROR;
    }

    unsafe {
        let input = slice::from_raw_parts(encoded_buffer, encoded_size);
        let max_output_size = *decoded_size;
        let output = slice::from_raw_parts_mut(decoded_buffer, max_output_size);

        let mut input_cursor = std::io::Cursor::new(input);
        let mut output_cursor = std::io::Cursor::new(output);

        match BrotliDecompress(&mut input_cursor, &mut output_cursor) {
            Ok(_) => {
                *decoded_size = output_cursor.position() as usize;
                BROTLI_DECODER_RESULT_SUCCESS
            }
            Err(_) => BROTLI_DECODER_RESULT_ERROR,
        }
    }
}
```

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

### compress

Source: https://docs.rs/woofwoof/1.0.2/woofwoof

Compresses a TTF or OTF font file into the WOFF2 format.

```APIDOC
## compress

### Description
Compress a TTF/OTF font to WOFF2 format.

### Parameters
- **data** (&[u8]) - Required - The raw TTF/OTF font data.
- **params** (&str) - Required - Compression parameters string.
- **quality** (u32) - Required - Compression quality level.
- **allow_transforms** (bool) - Required - Whether to allow font-specific table transforms.

### Request Example
let ttf_data = std::fs::read("font.ttf").unwrap();
let woff2_data = woofwoof::compress(&ttf_data, "", 8, true).expect("compression failed");
```

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

### compress

Source: https://docs.rs/woofwoof/1.0.2/index.html

Compresses a TTF or OTF font file into the WOFF2 format.

```APIDOC
## compress

### Description
Compress a TTF/OTF font to WOFF2 format.

### Parameters
- **data** (&[u8]) - Required - The raw TTF/OTF font data.
- **params** (&str) - Required - Compression parameters string.
- **quality** (u32) - Required - Compression quality level.
- **allow_transforms** (bool) - Required - Whether to allow font-specific table transforms.

### Response
- **Result<Vec<u8>, Error>** - Returns the compressed WOFF2 data or an error if compression fails.
```

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

### Compress TTF to WOFF2

Source: https://docs.rs/woofwoof/1.0.2/src/woofwoof/lib.rs.html

Compresses TTF or OTF font data into WOFF2 format. Supports optional metadata, Brotli compression quality, and font-specific transforms. Returns None if compression fails.

```rust
/// Compress a TTF/OTF font to WOFF2 format.
///
/// # Arguments
/// * `data` - The TTF or OTF font data
/// * `metadata` - Optional extended metadata (XML)
/// * `quality` - Brotli compression quality (0-11, default 8)
/// * `transform` - Whether to apply font-specific transforms
///
/// # Returns
/// The WOFF2 compressed font data, or `None` if compression failed.
pub fn compress<T>(data: &[u8], metadata: T, quality: usize, transform: bool) -> Option<Vec<u8>>
where
    T: Into<Vec<u8>>,
{
    let metadata = match std::ffi::CString::new(metadata) {
        Ok(metadata) => metadata,
        _ => return None,
    };
    let metadata_size = metadata.count_bytes();

    let size = unsafe {
        ffi::ComputeTTFToWOFF2Size(data.as_ptr(), data.len(), metadata.as_ptr(), metadata_size)
    };

    let mut buffer = vec![0u8; size];
    let mut size = buffer.len();

    let status = unsafe {
        ffi::ConvertTTFToWOFF2(
            data.as_ptr(),
            data.len(),
            buffer.as_mut_ptr(),
            &mut size,
            metadata.as_ptr(),
            metadata_size,
            quality as std::ffi::c_int,
            transform as std::ffi::c_int,
        )
    };

    if status == 0 {
        return None;
    }

    buffer.truncate(size);
    Some(buffer)
}
```

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

### Brotli Decompression API

Source: https://docs.rs/woofwoof/1.0.2/src/woofwoof/brotli_shim.rs.html

Provides a C ABI compatible function for decompressing brotli-compressed data. This function mirrors the C API signature for BrotliDecoderDecompress.

```APIDOC
## woofwoof_BrotliDecoderDecompress

### Description
Decompress brotli-compressed data.

This matches the C API signature:
```c
BrotliDecoderResult BrotliDecoderDecompress(
    size_t encoded_size, const uint8_t* encoded_buffer,
    size_t* decoded_size, uint8_t* decoded_buffer);
```

### Method
Extern C Function (C ABI)

### Endpoint
N/A (C ABI function)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```json
{
  "example": "This function is called directly from C/C++ and does not have a JSON request body."
}
```

### Response
#### Success Response (200)
Returns `BROTLI_DECODER_RESULT_SUCCESS` (1) on success, `BROTLI_DECODER_RESULT_ERROR` (0) on failure.

#### Response Example
```json
{
  "example": "1 (BROTLI_DECODER_RESULT_SUCCESS) or 0 (BROTLI_DECODER_RESULT_ERROR)"
}
```
```

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

### Compress font data to WOFF2

Source: https://docs.rs/woofwoof/1.0.2/woofwoof/fn.compress.html

Use this function to compress TTF or OTF font data. Requires font data as a byte slice and optional metadata.

```rust
pub fn compress<T>(
    data: &[u8],
    metadata: T,
    quality: usize,
    transform: bool,
) -> Option<Vec<u8>>
where
    T: Into<Vec<u8>>,
```

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

### WOFF2 Compression API

Source: https://docs.rs/woofwoof/1.0.2/src/woofwoof/lib.rs.html

Compresses TTF/OTF font data into WOFF2 format.

```APIDOC
## POST /woff2/compress

### Description
Compresses TTF/OTF font data into WOFF2 format using Brotli compression.

### Method
POST

### Endpoint
/woff2/compress

### Parameters
#### Request Body
- **data** (bytes) - Required - The TTF or OTF font data.
- **metadata** (string) - Optional - Extended metadata in XML format.
- **quality** (integer) - Optional - Brotli compression quality (0-11, default 8).
- **transform** (boolean) - Optional - Whether to apply font-specific transforms (default true).

### Request Example
```json
{
  "data": "base64EncodedFontData",
  "metadata": "<xml>...</xml>",
  "quality": 9,
  "transform": true
}
```

### Response
#### Success Response (200)
- **woff2_data** (bytes) - The WOFF2 compressed font data.

#### Response Example
```json
{
  "woff2_data": "base64EncodedWoff2Data"
}
```

#### Error Response (400)
- **error** (string) - Description of the error (e.g., "compression failed").
```

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

### Test: Font Roundtrip Verification

Source: https://docs.rs/woofwoof/1.0.2/src/woofwoof/lib.rs.html

Tests the compression and decompression functionality by performing a roundtrip on a sample TTF font. It verifies the WOFF2 signature and checks if the decompressed font is valid.

```rust
let ttf = std::fs::read("tests/Roboto.ttf").expect("failed to read test font");

// Compress
let woff2 = compress(&ttf, "", 8, true).expect("compression failed");
println!("TTF: {} bytes -> WOFF2: {} bytes", ttf.len(), woff2.len());

// Verify WOFF2 signature
assert_eq!(&woff2[0..4], b"wOF2", "invalid WOFF2 signature");

// Decompress
let roundtripped = decompress(&woff2).expect("decompression failed");

// Note: roundtripped may not be byte-identical due to font transforms,
// but should be a valid font of similar size
println!("Decompressed: {} bytes", roundtripped.len());
assert!(!roundtripped.is_empty());

```

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

### Compress TTF/OTF to WOFF2

Source: https://docs.rs/woofwoof/1.0.2/woofwoof/fn.compress.html

Compresses TTF or OTF font data into WOFF2 format with customizable quality and transforms.

```APIDOC
## compress

### Description
Compresses a TTF/OTF font to WOFF2 format.

### Method
N/A (This is a library function, not an HTTP endpoint)

### Endpoint
N/A

### Parameters
#### Arguments
- **data** (slice of bytes) - The TTF or OTF font data.
- **metadata** (generic type T that implements Into<Vec<u8>>) - Optional extended metadata (XML).
- **quality** (usize) - Brotli compression quality (0-11, default 8).
- **transform** (bool) - Whether to apply font-specific transforms.

### Returns
- **Option<Vec<u8>>** - The WOFF2 compressed font data, or `None` if compression failed.

### Request Example
```rust
// Example usage (assuming you have font data in `font_data`)
let compressed_data = woofwoof::compress(font_data, xml_metadata, 8, true);
match compressed_data {
    Some(data) => println!("Compression successful!"),
    None => println!("Compression failed.")
}
```

### Response
#### Success Response
- **Vec<u8>** - WOFF2 compressed font data.

#### Response Example
```rust
// Successful compression returns Some(Vec<u8>)
// Example: let compressed_font_bytes: Vec<u8> = compressed_data.unwrap();
```

#### Error Response
- **None** - Returned if compression fails.
```

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

### Compression Function

Source: https://docs.rs/woofwoof/1.0.2/woofwoof/all.html

The compress function is used to reduce the size of data.

```APIDOC
## compress

### Description
Compresses the provided input data.

### Parameters
- **data** (bytes) - Required - The raw data to be compressed.
```

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

### Decompress WOFF2 Font Data

Source: https://docs.rs/woofwoof/1.0.2/woofwoof/fn.decompress.html

Use this function to decompress WOFF2 compressed font data into TTF/OTF format. Returns None if decompression fails.

```rust
pub fn decompress(data: &[u8]) -> Option<Vec<u8>>
```

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

### Decompress WOFF2 to TTF

Source: https://docs.rs/woofwoof/1.0.2/src/woofwoof/lib.rs.html

Decompresses WOFF2 font data back to TTF/OTF format. Returns None if decompression fails or if the input data is invalid.

```rust
/// Decompress a WOFF2 font to TTF/OTF format.
///
/// # Arguments
/// * `data` - The WOFF2 compressed font data
///
/// # Returns
/// The decompressed TTF/OTF font data, or `None` if decompression failed.
pub fn decompress(data: &[u8]) -> Option<Vec<u8>> {
    let size = unsafe { ffi::ComputeWOFF2ToTTFSize(data.as_ptr(), data.len()) };

    if size == 0 {
        return None;
    }

    let mut buffer = vec![0u8; size];

    let status =
        unsafe { ffi::ConvertWOFF2ToTTF(buffer.as_mut_ptr(), size, data.as_ptr(), data.len()) };

    if status == 0 {
        return None;
    }

    Some(buffer)
}
```

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

### decompress

Source: https://docs.rs/woofwoof/1.0.2/index.html

Decompresses a WOFF2 font file back into TTF or OTF format.

```APIDOC
## decompress

### Description
Decompress a WOFF2 font to TTF/OTF format.

### Parameters
- **data** (&[u8]) - Required - The WOFF2 font data.

### Response
- **Result<Vec<u8>, Error>** - Returns the decompressed TTF/OTF data or an error if decompression fails.
```

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

### decompress

Source: https://docs.rs/woofwoof/1.0.2/woofwoof

Decompresses a WOFF2 font file back into TTF or OTF format.

```APIDOC
## decompress

### Description
Decompress a WOFF2 font to TTF/OTF format.

### Parameters
- **data** (&[u8]) - Required - The WOFF2 compressed font data.

### Request Example
let ttf_again = woofwoof::decompress(&woff2_data).expect("decompression failed");
```

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

### WOFF2 Decompression API

Source: https://docs.rs/woofwoof/1.0.2/src/woofwoof/lib.rs.html

Decompresses WOFF2 font data back to TTF/OTF format.

```APIDOC
## POST /woff2/decompress

### Description
Decompresses WOFF2 font data back to its original TTF/OTF format.

### Method
POST

### Endpoint
/woff2/decompress

### Parameters
#### Request Body
- **data** (bytes) - Required - The WOFF2 compressed font data.

### Request Example
```json
{
  "data": "base64EncodedWoff2Data"
}
```

### Response
#### Success Response (200)
- **ttf_data** (bytes) - The decompressed TTF/OTF font data.

#### Response Example
```json
{
  "ttf_data": "base64EncodedFontData"
}
```

#### Error Response (400)
- **error** (string) - Description of the error (e.g., "decompression failed").
```

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

### Decompression Function

Source: https://docs.rs/woofwoof/1.0.2/woofwoof/all.html

The decompress function is used to restore compressed data to its original state.

```APIDOC
## decompress

### Description
Decompresses the provided compressed data back to its original form.

### Parameters
- **data** (bytes) - Required - The compressed data to be decompressed.
```

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

### Decompress WOFF2 Font

Source: https://docs.rs/woofwoof/1.0.2/woofwoof/fn.decompress.html

This function decompresses WOFF2 font data into TTF/OTF format.

```APIDOC
## decompress

### Description
Decompress a WOFF2 font to TTF/OTF format.

### Method
This is a function call, not an HTTP endpoint.

### Endpoint
N/A

### Parameters
#### Arguments
- **data** ( &[u8] ) - Required - The WOFF2 compressed font data

### Returns
#### Success Response
- **Vec<u8>** - The decompressed TTF/OTF font data
- **None** - If decompression failed.

### Request Example
```rust
// Example usage (assuming you have compressed data in a byte slice named `compressed_data`)
let decompressed_data = woofwoof::decompress(compressed_data);
match decompressed_data {
    Some(ttf_data) => {
        // Use the decompressed TTF/OTF data
    },
    None => {
        // Handle decompression failure
    }
}
```

### Response Example
```rust
// Success: Some(Vec<u8>) containing TTF/OTF data
// Failure: None
```
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.