use webpx::decode_rgba;

// `webp_bytes` is the contents of a .webp file.
let (pixels, width, height) = decode_rgba(&webp_bytes)?;
// `pixels.len() == width as usize * height as usize * 4`, in R,G,B,A order.
# Ok::<(), webpx::At<webpx::Error>>(())

use webpx::{Encoder, Unstoppable};

// A 2x2 RGBA image: red, green, blue, white.
let rgba: Vec<u8> = vec![
    255, 0, 0, 255,
    0, 255, 0, 255,
    0, 0, 255, 255,
    255, 255, 255, 255,
];

// Lossy, quality 0.0..=100.0.
let webp = Encoder::new_rgba(&rgba, 2, 2)
    .quality(85.0)
    .encode(Unstoppable)?;
# Ok::<(), webpx::At<webpx::Error>>(())

use webpx::{Decoder, DecoderConfig, Limits};

// Tighter than default: 16 MP per frame for a thumbnail decoder.
let limits = Limits::default().with_max_pixels(16 * 1024 * 1024);

let (pixels, w, h) = Decoder::new(&webp_data)?
    .config(DecoderConfig::new().limits(limits))
    .decode_rgba_raw()?;
# Ok::<(), webpx::At<webpx::Error>>(())

use webpx::{Encoder, Error, StopReason};
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::Arc;

struct Canceller(Arc<AtomicBool>);
impl enough::Stop for Canceller {
    fn check(&self) -> Result<(), enough::StopReason> {
        if self.0.load(Ordering::Relaxed) {
            Err(enough::StopReason::Cancelled)
        } else {
            Ok(())
        }
    }
}

let cancelled = Arc::new(AtomicBool::new(false));
// ... another thread: cancelled.store(true, Ordering::Relaxed);

match Encoder::new_rgba(&data, width, height)
    .quality(85.0)
    .encode(Canceller(cancelled))
{
    Ok(webp) => { /* success */ }
    Err(Error::Stopped(StopReason::Cancelled)) => { /* aborted */ }
    Err(e) => { /* other error */ }
}
# Ok::<(), webpx::At<webpx::Error>>(())

use webpx::{Encoder, Preset, Unstoppable};

// Lossless: exact pixels.
let webp = Encoder::new_rgba(&rgba, 640, 480)
    .lossless(true)
    .encode(Unstoppable)?;

// Tuned lossy with a content preset.
let webp = Encoder::new_rgba(&rgba, 640, 480)
    .preset(Preset::Photo)   // content-aware optimization
    .quality(90.0)
    .method(5)               // 0-6: higher = slower, smaller
    .alpha_quality(95)       // 0-100 alpha-plane quality
    .sharp_yuv(true)         // sharper RGB->YUV conversion
    .encode(Unstoppable)?;

// RGB input (no alpha).
let webp = Encoder::new_rgb(&rgb, 640, 480)
    .quality(85.0)
    .encode(Unstoppable)?;
# Ok::<(), webpx::At<webpx::Error>>(())

use webpx::EncoderConfig;

// Presets for the common extremes.
let webp = EncoderConfig::max_compression().encode_rgba(&data, width, height)?;
let webp = EncoderConfig::max_compression_lossless().encode_rgba(&data, width, height)?;

// Fine-grained control, with PSNR/size stats.
let config = EncoderConfig::new()
    .quality(85.0)
    .method(6)
    .filter_strength(60)
    .sns_strength(80)
    .segments(4)
    .pass(6)
    .preprocessing(4);
let (webp, stats) = config.encode_rgba_with_stats(&data, width, height)?;
println!("PSNR {:.2} dB, {} bytes", stats.psnr[4], stats.coded_size);
# Ok::<(), webpx::At<webpx::Error>>(())

use webpx::Decoder;

let decoder = Decoder::new(&webp_data)?;

// Inspect dimensions without decoding pixels.
let info = decoder.info();
println!("{}x{}, alpha: {}", info.width, info.height, info.has_alpha);

// Extract a region, then resize it.
let (pixels, w, h) = decoder
    .crop(100, 100, 400, 300)
    .scale(200, 150)
    .decode_rgba_raw()?;
# Ok::<(), webpx::At<webpx::Error>>(())

use webpx::{AnimationEncoder, AnimationDecoder, ColorMode, Limits};

// Encode an animated WebP. Timestamps are the show time of each frame in ms.
let mut encoder = AnimationEncoder::new(320, 240)?;
encoder.set_quality(80.0);
encoder.set_lossless(false);
encoder.add_frame_rgba(&frame0, 0)?;
encoder.add_frame_rgba(&frame1, 100)?;
encoder.add_frame_rgba(&frame2, 200)?;
let webp = encoder.finish(300)?; // end timestamp

// Decode with limits when the input is untrusted.
let limits = Limits::default()
    .with_max_frames(1024)
    .with_max_animation_ms(60_000);
let mut decoder =
    AnimationDecoder::with_options_limits(&webp, ColorMode::Rgba, true, &limits)?;
let total = decoder.info().frame_count;
while let Some(frame) = decoder.next_frame()? {
    render(&frame.data, frame.timestamp_ms);
}
# fn render(_: &[u8], _: i32) {}
# Ok::<(), webpx::At<webpx::Error>>(())

use webpx::{embed_icc, get_icc_profile_with_limits, embed_exif, Limits};

// Embed an ICC profile (returns a new, larger WebP).
let with_icc = embed_icc(&webp_data, &srgb_profile)?;

// Extract — bound the metadata chunk even if the bitstream declares it huge.
let limits = Limits::default().with_max_metadata_bytes(4 * 1024 * 1024);
if let Some(icc) = get_icc_profile_with_limits(&with_icc, &limits)? {
    println!("ICC profile: {} bytes", icc.len());
}

// EXIF works the same way (embed_exif / get_exif_with_limits), as does XMP.
let _with_exif = embed_exif(&webp_data, &exif_bytes)?;
# Ok::<(), webpx::At<webpx::Error>>(())

use webpx::{StreamingDecoder, DecodeStatus, ColorMode};

let mut decoder = StreamingDecoder::new(ColorMode::Rgba)?;
for chunk in network_stream {
    match decoder.append(&chunk)? {
        DecodeStatus::Complete => break,
        DecodeStatus::NeedMoreData => continue,
        DecodeStatus::Partial(_rows) => {
            if let Some((data, w, h)) = decoder.get_partial() {
                display_partial(data, w, h); // progressive preview
            }
        }
        _ => {}
    }
}
let (pixels, width, height) = decoder.finish()?;
# fn display_partial(_: &[u8], _: u32, _: u32) {}
# let network_stream: Vec<Vec<u8>> = Vec::new();
# Ok::<(), webpx::At<webpx::Error>>(())

// From the `webp` crate:
use webpx::compat::webp::{Encoder, Decoder};

// From the `webp-animation` crate (uses `finalize()` to match its API):
use webpx::compat::webp_animation::{Encoder, Decoder};