// Copyright 2021 The Wuffs Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//    https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

// ----------------

// This program exercises the Rust PNG decoder at
// https://github.com/image-rs/image-png
// which is the top result for https://crates.io/search?q=png&sort=downloads
//
// Wuffs' C code doesn't depend on Rust per se, but this program gives some
// performance data for specific Rust PNG implementations. The equivalent Wuffs
// benchmarks (on the same test images) are run via:
//
// wuffs bench std/png
//
// To run this program, do "cargo run --release" from the parent directory (the
// directory containing the Cargo.toml file).

extern crate png;
extern crate rustc_version_runtime;

use std::time::Instant;
use std::convert::TryInto;

const ITERSCALE: u64 = 50;
const REPS: u64 = 5;

fn main() {
    let version = rustc_version_runtime::version();
    print!(
        "# Rust {}.{}.{}\n",
        version.major, version.minor, version.patch,
    );
    print!("#\n");
    print!("# The output format, including the \"Benchmark\" prefixes, is compatible with the\n");
    print!("# https://godoc.org/golang.org/x/perf/cmd/benchstat tool. To install it, first\n");
    print!("# install Go, then run \"go get golang.org/x/perf/cmd/benchstat\".\n");

    let mut dst0 = vec![0u8; 64 * 1024 * 1024];
    let mut dst1 = vec![0u8; 64 * 1024 * 1024];

    // The various magic constants below are copied from test/c/std/png.c
    for i in 0..(1 + REPS) {
        bench(
            "19k_8bpp",
            &mut dst0[..],
            &mut dst1[..],
            include_bytes!("../../../test/data/bricks-gray.no-ancillary.png"),
            i == 0,        // warm_up
            160 * 120 * 1, // want_num_bytes = 19_200
            50,            // iters_unscaled
        );

        bench(
            "40k_24bpp",
            &mut dst0[..],
            &mut dst1[..],
            include_bytes!("../../../test/data/hat.png"),
            i == 0,       // warm_up
            90 * 112 * 4, // want_num_bytes = 40_320
            30,           // iters_unscaled
        );

        bench(
            "77k_8bpp",
            &mut dst0[..],
            &mut dst1[..],
            include_bytes!("../../../test/data/bricks-dither.png"),
            i == 0,        // warm_up
            160 * 120 * 4, // want_num_bytes = 76_800
            30,            // iters_unscaled
        );

        bench(
            "552k_32bpp_verify_checksum",
            &mut dst0[..],
            &mut dst1[..],
            include_bytes!("../../../test/data/hibiscus.primitive.png"),
            i == 0,        // warm_up
            312 * 442 * 4, // want_num_bytes = 551_616
            4,             // iters_unscaled
        );

        bench(
            "4002k_24bpp",
            &mut dst0[..],
            &mut dst1[..],
            include_bytes!("../../../test/data/harvesters.png"),
            i == 0,         // warm_up
            1165 * 859 * 4, // want_num_bytes = 4_002_940
            1,              // iters_unscaled
        );
    }
}

fn bench(
    name: &str,          // Benchmark name.
    dst0: &mut [u8],     // Destination buffer #0.
    dst1: &mut [u8],     // Destination buffer #1.
    src: &[u8],          // Source data.
    warm_up: bool,       // Whether this is a warm up rep.
    want_num_bytes: u64, // Expected num_bytes per iteration.
    iters_unscaled: u64, // Base number of iterations.
) {
    let iters = iters_unscaled * ITERSCALE;
    let mut total_num_bytes = 0u64;

    let start = Instant::now();
    for _ in 0..iters {
        let n = decode(&mut dst0[..], &mut dst1[..], src);
        if n != want_num_bytes {
            panic!("num_bytes: got {}, want {}", n, want_num_bytes);
        }
        total_num_bytes += n;
    }
    let elapsed = start.elapsed();

    let elapsed_nanos = (elapsed.as_secs() * 1_000_000_000) + (elapsed.subsec_nanos() as u64);
    let kb_per_s: u64 = total_num_bytes * 1_000_000 / elapsed_nanos;

    if warm_up {
        return;
    }

    print!(
        "Benchmarkrust_png_decode_image_{:16}   {:8}   {:12} ns/op   {:3}.{:03} MB/s\n",
        name,
        iters,
        elapsed_nanos / iters,
        kb_per_s / 1_000,
        kb_per_s % 1_000
    );
}

// decode returns the number of bytes processed.
fn decode(dst0: &mut [u8], dst1: &mut [u8], src: &[u8]) -> u64 {
    let decoder = png::Decoder::new(src);
    let (info, mut reader) = decoder.read_info().unwrap();
    let num_bytes = info.buffer_size() as u64;
    reader.next_frame(dst0).unwrap();
    if info.color_type == png::ColorType::Grayscale {
        // No conversion necessary.
        return num_bytes;
    } else if info.color_type == png::ColorType::RGB {
        // Convert RGB => BGRA.
        let new_size = ((num_bytes / 3) * 4) as usize;
        rgb_to_bgra(&dst0[..num_bytes as usize], &mut dst1[..new_size]);
        return new_size as u64;
    } else if info.color_type == png::ColorType::RGBA {
        // Convert RGBA => BGRA.
        for i in 0..((num_bytes / 4) as usize) {
            let d = dst0[(4 * i) + 0];
            dst0[(4 * i) + 0] = dst0[(4 * i) + 2];
            dst0[(4 * i) + 2] = d;
        }
        return num_bytes;
    }
    // Returning 0 should lead to a panic (when want_num_bytes != 0).
    0
}

/// Copy `src` (treated as 3-byte chunks) into `dst`
/// (treated as 4-byte chunks), filling out `dst` by adding
/// a `0xff` "alpha value" at the end of each entry.
///
/// # Panics:
///
/// Will panic if
///
/// * The length of `src` is not a multiple of 3.
/// * The length of `dst` is not a multiple of 4.
/// * `src` and `dst` do not have the same length in chunks.
#[inline]
pub fn rgb_to_bgra(src: &[u8], dst: &mut [u8]) {
    let nsrc = src.len();
    let ndst = dst.len();
    assert_eq!(0, nsrc % 3);
    assert_eq!(0, ndst % 4);
    assert_eq!(nsrc, (ndst / 4) * 3);
    for (s, d) in src.chunks_exact(3).zip(dst.chunks_exact_mut(4)) {
        let s: &[u8; 3] = s.try_into().unwrap();
        let d: &mut [u8; 4] = d.try_into().unwrap();
        // R
        d[0] = s[2];
        // G
        d[1] = s[1];
        // B
        d[2] = s[0];
        // A
        d[3] = 0xff;
    }
}