Start oxidizing 1/N

darleybarreto

Jul 19, 2021, 6:09 PM

HEFGMMUMJ2GGJGF2BEKF7EUL24AO53WJTXKBJSEGT64AV3Y4TBZQC

Dependencies

• [2] 53LCNWY2 Fixing compilation errors on Windows
• [3] TKSHSYFM Using pkg-config to find the libraries (+ some cleanup)
• [4] HELRYMZK Manual bindings (Windows and Clang aren't very good friends), and getting rid of anyhow
• [5] UPRY2FEL Remove bindgen dependency
• [6] IH334Q5A Reboot
• [7] TTRHEUTN Changing permissions

Change contents

• edit in src/lib.rs at line 6
  [3.241375]

  [3.0]
  + extern crate twox_hash;
• replacement in src/lib.rs at line 10
  [3.241440]→[3.241440:241471](∅→∅)
  − use std::ffi::{CStr, CString};
  [3.241440]

  [3.241471]
  + use std::convert::TryInto;

  + use std::ffi::CStr;

  + use std::hash::Hasher;

  + use std::io::Read;

  + use std::{cmp, fmt, fs, io, marker, mem, ptr, slice, sync};

  +

  + use twox_hash::{xxh3::hash64, XxHash64};

  +

  + const BLOCKSIZELOG_MAX: usize = 17;

  + const BLOCKSIZE_MAX: usize = 1 << BLOCKSIZELOG_MAX;

  + const SEEKABLE_BUFF_SIZE: usize = BLOCKSIZE_MAX;

  + const SEEKABLE_MAXFRAMES: usize = 0x8000000;

  +

  + const MAX_FRAME_DECOMPR_SIZE: u32 = 16;

  + const MAGIC_SKIPPABLE_START: usize = 0x184D2A50;

  + const SKIPPABLE_HEADER_SIZE: usize = 8;

  + const SEEK_TABLE_FOOTER_SIZE: usize = 9;

  + const SEEKABLE_MAGIC_NUMBER: usize = 0x8F92EAB1;

  + const FRAMELOG_STARTING_CAPACITY: usize = 16;
• replacement in src/lib.rs at line 34
  [3.241542]→[3.241542:241609](∅→∅),[3.241609]→[3.31:66](∅→∅)
  − /// The type of seekable compressors.

  − pub struct SeekableCStream {

  − p: *mut ZSTD_seekable_CStream,
  [3.241542]

  [3.241646]
  + #[derive(Clone)]

  + pub struct FrameLogEntry {

  + c_size: u32,

  + d_size: u32,

  + checksum: u64,

  + }

  +

  + /// The type of compressors.

  + pub struct FrameLog {

  + entries: Vec<FrameLogEntry>,

  + checksum_flag: u64,

  + seek_table_pos: u32,

  + seek_table_index: u32,
• replacement in src/lib.rs at line 54
  [3.241728]→[3.241728:241806](∅→∅)
  − /// The type of compressors.

  − pub struct FrameLog {

  − p: *mut ZSTD_frameLog,
  [3.241728]

  [3.241806]
  + /// The type of seekable compressors.

  + pub struct SeekableCStream {

  + cstream: CStream,

  + framelog: FrameLog,

  + frame_c_size: u32,

  + frame_d_size: u32,

  + xxh_state: XxHash64,

  + max_frame_size: u32,

  + writing_seek_table: bool,

  + }

  +

  + pub struct SeekEntry {

  + c_offset: usize,

  + d_offset: usize,

  + checksum: u64,
• edit in src/lib.rs at line 71
  [3.241809]

  [3.241809]
  + pub struct SeekTable {

  + entries: Vec<SeekEntry>,

  + checksum_flag: u64,

  + }

  +
• replacement in src/lib.rs at line 78
  [3.241869]→[3.241869:241896](∅→∅),[3.241896]→[3.241896:241980](∅→∅)
  − p: *mut ZSTD_seekable,

  − b: *mut R,

  − f: *mut libc::FILE,

  − marker: std::marker::PhantomData<&'a R>,
  [3.241869]

  [3.241980]
  + dstream: *mut ZSTD_DStream,

  + seek_table: SeekTable,

  + src: &'a mut R,

  + decompressed_offset: u64,

  + cur_frame: u32,

  + in_buff: [u8; SEEKABLE_BUFF_SIZE],

  + out_buff: [u8; SEEKABLE_BUFF_SIZE],

  + inn: ZSTD_inBuffer,

  + xxh_state: XxHash64,

  + // marker: marker::PhantomData<&'a R>, //TODO: do we need this marker?
• replacement in src/lib.rs at line 100
  [3.85]→[3.85:117](∅→∅)
  − Io(#[from] std::io::Error),
  [3.85]

  [3.242248]
  + Io(#[from] io::Error),

  + Other(&'static str),
• replacement in src/lib.rs at line 104
  [3.242251]→[3.242251:242355](∅→∅)
  − impl std::fmt::Debug for Error {

  − fn fmt(&self, fmt: &mut std::fmt::Formatter) -> std::fmt::Result {
  [3.242251]

  [3.242355]
  + impl fmt::Debug for Error {

  + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
• edit in src/lib.rs at line 114
  [3.242677]

  [3.242677]
  + Error::Other(ref s) => write!(fmt, "{}", s),
• replacement in src/lib.rs at line 119
  [3.242696]→[3.242696:242802](∅→∅)
  − impl std::fmt::Display for Error {

  − fn fmt(&self, fmt: &mut std::fmt::Formatter) -> std::fmt::Result {
  [3.242696]

  [3.242802]
  + impl fmt::Display for Error {

  + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
• edit in src/lib.rs at line 122
  [3.242836]→[3.242836:242845](∅→∅),[3.242845]→[3.242845:243076](∅→∅)
  − }

  − }

  −

  − impl Drop for SeekableCStream {

  − fn drop(&mut self) {

  − unsafe {

  − if !self.p.is_null() {

  − ZSTD_seekable_freeCStream(self.p);

  − self.p = std::ptr::null_mut();

  − }

  − }
• replacement in src/lib.rs at line 127
  [3.243134]→[3.243134:243186](∅→∅)
  − unsafe {

  − if !self.p.is_null() {
  [3.243134]

  [3.243186]
  + if !self.p.is_null() {

  + unsafe {
• replacement in src/lib.rs at line 130
  [3.243228]→[3.243228:243275](∅→∅)
  − self.p = std::ptr::null_mut();
  [3.243228]

  [3.243275]
  + self.p = ptr::null_mut();
• replacement in src/lib.rs at line 136
  [3.243308]→[3.243308:243347](∅→∅)
  − impl<'a, R> Drop for Seekable<'a, R> {
  [3.243308]

  [3.243347]
  + impl<R> Drop for Seekable<'_, R> {
• replacement in src/lib.rs at line 138
  [3.243372]→[3.243372:243389](∅→∅),[3.243389]→[3.243389:243529](∅→∅),[3.243529]→[3.243529:243643](∅→∅),[3.243643]→[3.243643:243657](∅→∅),[3.243657]→[3.243657:243829](∅→∅)
  − unsafe {

  − if !self.p.is_null() {

  − ZSTD_seekable_free(self.p);

  − self.p = std::ptr::null_mut();

  − }

  − if !self.f.is_null() {

  − fclose(self.f);

  − self.f = std::ptr::null_mut();

  − }

  − if !self.b.is_null() {

  − let b: Box<R> = Box::from_raw(self.b);

  − std::mem::drop(b);

  − self.b = std::ptr::null_mut();
  [3.243372]

  [3.243829]
  + if !self.dstream.is_null() {

  + unsafe {

  + ZSTD_freeDStream(self.dstream);

  + self.dstream = ptr::null_mut();
• replacement in src/lib.rs at line 147
  [3.243862]→[3.243862:244062](∅→∅),[3.244062]→[3.244062:244076](∅→∅),[3.244076]→[3.244076:244095](∅→∅),[3.244095]→[3.244095:244170](∅→∅)
  − impl Drop for FrameLog {

  − fn drop(&mut self) {

  − unsafe {

  − if !self.p.is_null() {

  − ZSTD_seekable_freeFrameLog(self.p);

  − self.p = std::ptr::null_mut()

  − }

  − }

  − }

  − }

  −

  − unsafe extern "C" fn zstd_seekable_read<R: std::io::Read + std::io::Seek>(
  [3.243862]

  [3.244170]
  + unsafe extern "C" fn zstd_seekable_read<R: io::Read + io::Seek>(
• replacement in src/lib.rs at line 153
  [3.244305]→[3.244305:244380](∅→∅)
  − let s = std::slice::from_raw_parts_mut(buffer as *mut u8, n as usize);
  [3.244305]

  [3.244380]
  + let s = slice::from_raw_parts_mut(buffer as *mut u8, n as usize);
• replacement in src/lib.rs at line 155
  [3.244442]→[3.244442:244467](∅→∅)
  − std::mem::forget(b);
  [3.244442]

  [3.244467]
  + mem::forget(b);
• replacement in src/lib.rs at line 159
  [3.244481]→[3.244481:244556](∅→∅)
  − unsafe extern "C" fn zstd_seekable_seek<R: std::io::Read + std::io::Seek>(
  [3.244481]

  [3.244556]
  + unsafe extern "C" fn zstd_seekable_seek<R: io::Read + io::Seek>(
• replacement in src/lib.rs at line 165
  [3.244694]→[3.244694:244768](∅→∅)
  − use std::io::SeekFrom;

  − let origin = if origin == libc::SEEK_SET {
  [3.244694]

  [3.244768]
  + use io::SeekFrom;

  + let origin = if origin == SEEK_SET {
• replacement in src/lib.rs at line 168
  [3.244807]→[3.244807:244848](∅→∅)
  − } else if origin == libc::SEEK_CUR {
  [3.244807]

  [3.244848]
  + } else if origin == SEEK_CUR {
• replacement in src/lib.rs at line 174
  [3.245007]→[3.245007:245032](∅→∅)
  − std::mem::forget(b);
  [3.245007]

  [3.245032]
  + mem::forget(b);
• edit in src/lib.rs at line 176
  [3.245043]

  [3.245043]
  + }

  + #[inline(always)]

  + fn slice_to_num(buff: &[u8]) -> Result<u32, Error> {

  + Ok(u32::from_ne_bytes(buff.try_into().map_err(|_| {

  + Error::Other("Invalid slice to convert from bytes to u32")

  + })?))
• replacement in src/lib.rs at line 184
  [3.245046]→[3.245046:245069](∅→∅)
  − impl SeekableCStream {
  [3.245046]

  [3.245069]
  + impl<'a> SeekableCStream {
• replacement in src/lib.rs at line 186
  [3.245280]→[3.245280:245353](∅→∅),[3.245353]→[3.245353:245644](∅→∅)
  − pub fn new(level: usize, frame_size: usize) -> Result<Self, Error> {

  − unsafe {

  − let p = ZSTD_seekable_createCStream();

  − if p.is_null() {

  − return Err(Error::Null);

  − }

  − let result = ZSTD_seekable_initCStream(p, level as c_int, 1, frame_size as c_uint);

  − if ZSTD_isError(result) != 0 {
  [3.245280]

  [3.245644]
  + pub fn new(level: usize, frame_size: u32) -> Result<Self, Error> {

  + let cstream = unsafe { ZSTD_createCStream() };

  +

  + if cstream.is_null() {

  + return Err(Error::Null);

  + }

  +

  + if frame_size > MAX_FRAME_DECOMPR_SIZE {

  + return Err(Error::Other("FrameParameterUnsupported"));

  + } else {

  + let max_frame_size = if frame_size > 0 {

  + frame_size

  + } else {

  + MAX_FRAME_DECOMPR_SIZE

  + };

  +

  + let result = unsafe { ZSTD_initCStream(cstream, level as c_int) };

  +

  + if unsafe { ZSTD_isError(result) } != 0 {
• replacement in src/lib.rs at line 207
  [3.245707]→[3.245707:245745](∅→∅)
  − Ok(SeekableCStream { p })
  [3.245707]

  [3.245745]
  +

  + Ok(SeekableCStream {

  + cstream: CStream { p: cstream },

  + framelog: FrameLog {

  + entries: Vec::with_capacity(FRAMELOG_STARTING_CAPACITY),

  + checksum_flag: 1,

  + seek_table_pos: 0,

  + seek_table_index: 0,

  + },

  + frame_c_size: 0,

  + frame_d_size: 0,

  + xxh_state: XxHash64::with_seed(0),

  + max_frame_size,

  + writing_seek_table: false,

  + })
• replacement in src/lib.rs at line 226
  [3.246170]→[3.246170:246187](∅→∅),[3.246187]→[3.246187:246285](∅→∅),[3.246285]→[3.179:224](∅→∅),[3.183]→[3.246330:246369](∅→∅),[3.224]→[3.246330:246369](∅→∅),[3.246330]→[3.246330:246369](∅→∅),[3.246369]→[3.246369:246472](∅→∅),[3.246472]→[3.225:271](∅→∅),[3.240]→[3.246518:246557](∅→∅),[3.271]→[3.246518:246557](∅→∅),[3.246518]→[3.246518:246557](∅→∅),[3.246557]→[3.246557:246737](∅→∅)
  − unsafe {

  − let mut input = ZSTD_inBuffer {

  − src: input.as_ptr() as *const c_void,

  − size: input.len() as size_t,

  − pos: 0,

  − };

  − let mut output = ZSTD_outBuffer {

  − dst: output.as_mut_ptr() as *mut c_void,

  − size: output.len() as size_t,

  − pos: 0,

  − };

  − let result = ZSTD_seekable_compressStream(self.p, &mut output, &mut input);

  − if ZSTD_isError(result) != 0 {

  − return Err(Error::ZSTD(result));
  [3.246170]

  [3.246737]
  + let mut output = ZSTD_outBuffer {

  + dst: output.as_mut_ptr() as *mut c_void,

  + size: output.len() as size_t,

  + pos: 0,

  + };

  +

  + let len = cmp::min(input.len() as u32, self.max_frame_size - self.frame_d_size);

  +

  + let mut in_tmp = ZSTD_inBuffer {

  + src: input.as_ptr() as *const c_void,

  + size: input.len() as size_t,

  + pos: 0,

  + };

  +

  + if len > 0 {

  + let ret = unsafe { ZSTD_compressStream(self.cstream.p, &mut output, &mut in_tmp) };

  +

  + if self.framelog.checksum_flag != 0 {

  + self.xxh_state

  + .write(unsafe { slice::from_raw_parts(in_tmp.src as *const _, in_tmp.pos) });

  + }

  +

  + self.frame_c_size += output.pos as u32;

  + self.frame_d_size += in_tmp.pos as u32;

  +

  + if unsafe { ZSTD_isError(ret) } != 0 {

  + return Err(Error::ZSTD(ret));

  + }

  + }

  +

  + if self.max_frame_size == self.frame_d_size {

  + let ret = self.end_stream(&mut output)?;

  +

  + if unsafe { ZSTD_isError(ret) } != 0 {

  + return Err(Error::ZSTD(ret));
• replacement in src/lib.rs at line 262
  [3.246751]→[3.246751:246809](∅→∅)
  − Ok((output.pos as usize, input.pos as usize))
  [3.246751]

  [3.246809]
  + }

  +

  + Ok((output.pos as usize, in_tmp.pos as usize))

  + }

  +

  + fn end_frame(&mut self, mut output: ZSTD_outBuffer) -> Result<usize, Error> {

  + let prev_out_pos = output.pos;

  + let ret = unsafe { ZSTD_endStream(self.cstream.p, &mut output) };

  +

  + self.frame_c_size += (output.pos - prev_out_pos) as u32;

  +

  + if ret != 0 {

  + return Ok(ret);

  + }

  +

  + let checksum = if self.framelog.checksum_flag != 0 {

  + self.xxh_state.finish() & 0xFFFFFFFFu64

  + } else {

  + 0

  + };

  +

  + self.framelog

  + .log_frame(self.frame_c_size, self.frame_d_size, checksum)?;

  +

  + self.frame_c_size = 0;

  + self.frame_d_size = 0;

  +

  + unsafe { ZSTD_resetCStream(self.cstream.p, 0) };

  +

  + if self.framelog.checksum_flag != 0 {

  + self.xxh_state = XxHash64::with_seed(0);
• edit in src/lib.rs at line 294
  [3.246819]

  [3.246819]
  +

  + Ok(0)
• replacement in src/lib.rs at line 299
  [3.246902]→[3.246902:246980](∅→∅),[3.246980]→[3.246980:247100](∅→∅),[3.247100]→[3.272:318](∅→∅),[3.297]→[3.247146:247185](∅→∅),[3.318]→[3.247146:247185](∅→∅),[3.247146]→[3.247146:247185](∅→∅),[3.247185]→[3.247185:247348](∅→∅)
  − pub fn end_stream(&mut self, output: &mut [u8]) -> Result<usize, Error> {

  − unsafe {

  − let mut output = ZSTD_outBuffer {

  − dst: output.as_mut_ptr() as *mut c_void,

  − size: output.len() as size_t,

  − pos: 0,

  − };

  − let result = ZSTD_seekable_endStream(self.p, &mut output);

  − if ZSTD_isError(result) != 0 {

  − return Err(Error::ZSTD(result));
  [3.246902]

  [3.247348]
  + pub fn end_stream(&mut self, output: &mut ZSTD_outBuffer) -> Result<usize, Error> {

  + if !self.writing_seek_table && self.frame_d_size != 0 {

  + let end_frame = self.end_frame(*output)?;

  +

  + if unsafe { ZSTD_isError(end_frame) } != 0 {

  + return Err(Error::ZSTD(end_frame));

  + } else if end_frame != 0 {

  + return Ok(end_frame + self.framelog.seek_table_size());
• edit in src/lib.rs at line 308
  [3.247362]→[3.247362:247398](∅→∅)
  − Ok(output.pos as usize)
• edit in src/lib.rs at line 309
  [3.247408]

  [3.247408]
  +

  + self.writing_seek_table = true;

  + return self.framelog.write_seek_table(output);
• replacement in src/lib.rs at line 315
  [3.247417]→[3.247417:247432](∅→∅)
  − impl CStream {
  [3.247417]

  [3.247432]
  + impl<'a> CStream {
• replacement in src/lib.rs at line 344
  [3.248538]→[3.248538:248653](∅→∅),[3.248653]→[3.319:364](∅→∅),[3.353]→[3.248698:248840](∅→∅),[3.364]→[3.248698:248840](∅→∅),[3.248698]→[3.248698:248840](∅→∅),[3.248840]→[3.365:411](∅→∅),[3.410]→[3.248886:249089](∅→∅),[3.411]→[3.248886:249089](∅→∅),[3.248886]→[3.248886:249089](∅→∅)
  − unsafe {

  − let mut input = ZSTD_inBuffer {

  − src: input.as_ptr() as *const c_void,

  − size: input.len() as size_t,

  − pos: 0,

  − };

  − let mut output = ZSTD_outBuffer {

  − dst: output.as_mut_ptr() as *mut c_void,

  − size: output.len() as size_t,

  − pos: 0,

  − };

  − let result = ZSTD_compressStream(self.p, &mut output, &mut input);

  − Ok((output.pos as usize, input.pos as usize, result as usize))

  − }
  [3.248538]

  [3.249089]
  + let mut input = ZSTD_inBuffer {

  + src: input.as_ptr() as *const c_void,

  + size: input.len() as size_t,

  + pos: 0,

  + };

  +

  + let mut output = ZSTD_outBuffer {

  + dst: output.as_mut_ptr() as *mut c_void,

  + size: output.len() as size_t,

  + pos: 0,

  + };

  +

  + let result = unsafe { ZSTD_compressStream(self.p, &mut output, &mut input) };

  + Ok((output.pos as usize, input.pos as usize, result as usize))
• replacement in src/lib.rs at line 366
  [3.249260]→[3.249260:249375](∅→∅),[3.249375]→[3.412:457](∅→∅),[3.457]→[3.249420:249562](∅→∅),[3.466]→[3.249420:249562](∅→∅),[3.249420]→[3.249420:249562](∅→∅),[3.249562]→[3.458:504](∅→∅),[3.504]→[3.249608:249647](∅→∅),[3.523]→[3.249608:249647](∅→∅),[3.249608]→[3.249608:249647](∅→∅),[3.249647]→[3.505:610](∅→∅),[3.610]→[3.249741:249826](∅→∅),[3.620]→[3.249741:249826](∅→∅),[3.249741]→[3.249741:249826](∅→∅)
  − unsafe {

  − let mut input = ZSTD_inBuffer {

  − src: input.as_ptr() as *const c_void,

  − size: input.len() as size_t,

  − pos: 0,

  − };

  − let mut output = ZSTD_outBuffer {

  − dst: output.as_mut_ptr() as *mut c_void,

  − size: output.len() as size_t,

  − pos: 0,

  − };

  − let result = ZSTD_compressStream2(self.p, &mut output, &mut input, op as ZSTD_EndDirective);

  − Ok((output.pos as usize, input.pos as usize, result as usize))

  − }
  [3.249260]

  [3.249826]
  + let mut input = ZSTD_inBuffer {

  + src: input.as_ptr() as *const c_void,

  + size: input.len() as size_t,

  + pos: 0,

  + };

  + let mut output = ZSTD_outBuffer {

  + dst: output.as_mut_ptr() as *mut c_void,

  + size: output.len() as size_t,

  + pos: 0,

  + };

  + let result = unsafe {

  + ZSTD_compressStream2(self.p, &mut output, &mut input, op as ZSTD_EndDirective)

  + };

  + Ok((output.pos as usize, input.pos as usize, result as usize))
• replacement in src/lib.rs at line 383
  [3.249915]→[3.249915:250035](∅→∅),[3.250035]→[3.611:657](∅→∅),[3.657]→[3.250081:250249](∅→∅),[3.677]→[3.250081:250249](∅→∅),[3.250081]→[3.250081:250249](∅→∅)
  − unsafe {

  − let mut output = ZSTD_outBuffer {

  − dst: output.as_mut_ptr() as *mut c_void,

  − size: output.len() as size_t,

  − pos: 0,

  − };

  − let result = ZSTD_flushStream(self.p, &mut output);

  − Ok((output.pos as usize, result as usize))

  − }
  [3.249915]

  [3.250249]
  + let mut output = ZSTD_outBuffer {

  + dst: output.as_mut_ptr() as *mut c_void,

  + size: output.len() as size_t,

  + pos: 0,

  + };

  + let result = unsafe { ZSTD_flushStream(self.p, &mut output) };

  + Ok((output.pos as usize, result as usize))
• replacement in src/lib.rs at line 394
  [3.250403]→[3.250403:250523](∅→∅),[3.250523]→[3.658:704](∅→∅),[3.704]→[3.250569:250812](∅→∅),[3.734]→[3.250569:250812](∅→∅),[3.250569]→[3.250569:250812](∅→∅)
  − unsafe {

  − let mut output = ZSTD_outBuffer {

  − dst: output.as_mut_ptr() as *mut c_void,

  − size: output.len() as size_t,

  − pos: 0,

  − };

  − let result = ZSTD_endStream(self.p, &mut output);

  − if ZSTD_isError(result) != 0 {

  − return Err(Error::ZSTD(result));

  − }

  − Ok(output.pos as usize)
  [3.250403]

  [3.250812]
  + let mut output = ZSTD_outBuffer {

  + dst: output.as_mut_ptr() as *mut c_void,

  + size: output.len() as size_t,

  + pos: 0,

  + };

  + let result = unsafe { ZSTD_endStream(self.p, &mut output) };

  + if unsafe { ZSTD_isError(result) } != 0 {

  + return Err(Error::ZSTD(result));
• edit in src/lib.rs at line 403
  [3.250822]

  [3.250822]
  + Ok(output.pos as usize)
• replacement in src/lib.rs at line 421
  [3.251058]→[3.251058:251101](∅→∅)
  − self.p = std::ptr::null_mut();
  [3.251058]

  [3.251101]
  + self.p = ptr::null_mut();
• replacement in src/lib.rs at line 426
  [3.251120]→[3.251120:251135](∅→∅)
  − impl DStream {
  [3.251120]

  [3.251135]
  + impl<'a> DStream {
• replacement in src/lib.rs at line 442
  [3.251468]→[3.251468:251583](∅→∅),[3.251583]→[3.705:750](∅→∅),[3.750]→[3.251628:251770](∅→∅),[3.1024]→[3.251628:251770](∅→∅),[3.251628]→[3.251628:251770](∅→∅),[3.251770]→[3.751:797](∅→∅)
  − unsafe {

  − let mut input = ZSTD_inBuffer {

  − src: input.as_ptr() as *const c_void,

  − size: input.len() as size_t,

  − pos: 0,

  − };

  − let mut output = ZSTD_outBuffer {

  − dst: output.as_mut_ptr() as *mut c_void,

  − size: output.len() as size_t,
  [3.251468]

  [3.251816]
  + let mut input = ZSTD_inBuffer {

  + src: input.as_ptr() as *const c_void,

  + size: input.len() as size_t,

  + pos: 0,

  + };

  + let mut output = ZSTD_outBuffer {

  + dst: output.as_mut_ptr() as *mut c_void,

  + size: output.len() as size_t,

  + pos: 0,

  + };

  + let _result = unsafe { ZSTD_decompressStream(self.p, &mut output, &mut input) };

  + Ok((output.pos as usize, input.pos as usize))

  + }

  + }

  +

  + impl<'a, R: io::Read + io::Seek> Seekable<'a, R> {

  + fn make_seekable(source: &'a mut R, dstream: *mut ZSTD_DStream) -> Self {

  + Seekable {

  + dstream,

  + seek_table: SeekTable {

  + entries: Vec::new(),

  + checksum_flag: 1,

  + },

  + src: source,

  + decompressed_offset: 0,

  + cur_frame: 0,

  + in_buff: [0; SEEKABLE_BUFF_SIZE],

  + out_buff: [0; SEEKABLE_BUFF_SIZE],

  + inn: ZSTD_inBuffer {

  + src: ptr::null() as *const c_void,

  + size: 0,
• replacement in src/lib.rs at line 474
  [3.251840]→[3.251840:251995](∅→∅)
  − };

  − let _result = ZSTD_decompressStream(self.p, &mut output, &mut input);

  − Ok((output.pos as usize, input.pos as usize))
  [3.251840]

  [3.251995]
  + },

  + xxh_state: XxHash64::with_seed(0),

  + // marker: marker::PhantomData,
• replacement in src/lib.rs at line 479
  [3.252011]→[3.252011:252013](∅→∅)
  − }
  [3.252011]

  [3.252013]
  +

  + fn load_seek_table(&mut self) -> Result<(), Error> {

  + self.src

  + .seek(io::SeekFrom::End(-(SEEK_TABLE_FOOTER_SIZE as i64)));
• replacement in src/lib.rs at line 484
  [3.252014]→[3.252014:252042](∅→∅),[3.252042]→[3.252042:252177](∅→∅),[3.252177]→[3.252177:252250](∅→∅),[3.252250]→[3.252250:252305](∅→∅),[3.252305]→[3.252305:252330](∅→∅),[3.252330]→[3.798:897](∅→∅),[3.897]→[3.252429:252727](∅→∅),[3.1191]→[3.252429:252727](∅→∅),[3.252429]→[3.252429:252727](∅→∅)
  − impl<'a> Seekable<'a, ()> {

  − /// Initialise a decompressor with an input buffer.

  − pub fn init_buf(input: &'a [u8]) -> Result<Self, Error> {

  − unsafe {

  − let p = ZSTD_seekable_create();

  − if p.is_null() {

  − return Err(Error::Null);

  − }

  − let result =

  − ZSTD_seekable_initBuff(p, input.as_ptr() as *const c_void, input.len() as size_t);

  − if ZSTD_isError(result) != 0 {

  − return Err(Error::ZSTD(result));

  − }

  − Ok(Seekable {

  − p,

  − f: std::ptr::null_mut(),

  − b: std::ptr::null_mut(),

  − marker: std::marker::PhantomData,

  − })
  [3.252014]

  [3.252727]
  + let mut handle = self.src.take(SEEK_TABLE_FOOTER_SIZE as u64);

  + handle.read(&mut self.in_buff);

  +

  + if slice_to_num(&self.in_buff[5..9])? as usize != SEEKABLE_MAGIC_NUMBER {

  + return Err(Error::Other("PrefixUnknown"));

  + }

  +

  + let checksum_flag = (self.in_buff[4] >> 7) as usize;

  + if ((checksum_flag >> 2) & 0x1f) == 0 {

  + return Err(Error::Other("CorruptionDetected"));
• replacement in src/lib.rs at line 495
  [3.252737]→[3.252737:252743](∅→∅)
  − }
  [3.252737]

  [3.252743]
  +

  + let num_frames = slice_to_num(&self.in_buff[..4])? as usize;

  + let size_p_entry: usize = 8 + if checksum_flag != 0 { 4 } else { 0 };

  + let table_size = size_p_entry * num_frames;

  + let frame_size = table_size + SEEK_TABLE_FOOTER_SIZE + SKIPPABLE_HEADER_SIZE;
• replacement in src/lib.rs at line 501
  [3.252744]→[3.252744:252874](∅→∅),[3.252874]→[3.252874:253325](∅→∅)
  − /// Initialise a decompressor with a file. This method opens the file, and dropping the resulting `Seekable` closes the file.

  − pub fn init_file(name_: &str) -> Result<Self, Error> {

  − unsafe {

  − let name = CString::new(name_).unwrap();

  − let f: *mut libc::FILE = fopen(name.as_ptr(), "rb\0".as_ptr() as *const c_char);

  − if f.is_null() {

  − return Err(Error::CouldNotOpenFile(name_.to_string()));

  − }

  − let p = ZSTD_seekable_create();

  − if p.is_null() {

  − return Err(Error::Null);
  [3.252744]

  [3.253325]
  + let mut remaining = frame_size as usize - SEEK_TABLE_FOOTER_SIZE;

  + let to_read = cmp::min(remaining, SEEKABLE_BUFF_SIZE);

  +

  + self.src.seek(io::SeekFrom::End(-(frame_size as i64)));

  +

  + handle = self.src.take(to_read as u64);

  + handle.read(&mut self.in_buff)?;

  + remaining -= to_read;

  +

  + if slice_to_num(&self.in_buff[..4])? as usize != (MAGIC_SKIPPABLE_START | 0xE) {

  + return Err(Error::Other("PrefixUnknown"));

  + }

  + if slice_to_num(&self.in_buff[4..8])? as usize + SKIPPABLE_HEADER_SIZE != frame_size {

  + return Err(Error::Other("PrefixUnknown"));

  + }

  +

  + let mut entries: Vec<SeekEntry> = Vec::with_capacity((num_frames + 1) as usize);

  + let (mut idx, mut pos) = (0usize, 8usize);

  + let (mut c_offset, mut d_offset) = (0, 0);

  +

  + let buffer_ptr = (&mut self.in_buff).as_mut_ptr();

  +

  + while idx < num_frames {

  + if pos + size_p_entry > SEEKABLE_BUFF_SIZE {

  + let offset = SEEKABLE_BUFF_SIZE;

  + let to_read = cmp::min(remaining, SEEKABLE_BUFF_SIZE - offset);

  +

  + // FIXME: replace this pointer arithmetic with something safer

  + unsafe { (buffer_ptr.add(pos)).copy_to(buffer_ptr, offset) };

  +

  + handle = self.src.take(to_read as u64);

  + // FIXME: if pointer arithmetic replace, this needs to change

  + handle

  + .read(unsafe { slice::from_raw_parts_mut(buffer_ptr.add(offset), to_read) })?;

  + remaining -= to_read;

  + pos = 0;
• replacement in src/lib.rs at line 538
  [3.253339]→[3.253339:253499](∅→∅)
  − let result = ZSTD_seekable_initFile(p, f as *mut FILE);

  − if ZSTD_isError(result) != 0 {

  − return Err(Error::ZSTD(result));
  [3.253339]

  [3.253499]
  +

  + entries[idx].c_offset = c_offset;

  + entries[idx].d_offset = d_offset;

  +

  + c_offset += slice_to_num(&self.in_buff[pos..pos + 4])? as usize;

  + pos += 4;

  + d_offset += slice_to_num(&self.in_buff[pos..pos + 4])? as usize;

  + pos += 4;

  +

  + if checksum_flag != 0 {

  + entries[idx].checksum = slice_to_num(&self.in_buff[pos..pos + 4])? as u64;

  + pos += 4;
• replacement in src/lib.rs at line 551
  [3.253513]→[3.253513:253683](∅→∅)
  − Ok(Seekable {

  − p,

  − f,

  − b: std::ptr::null_mut(),

  − marker: std::marker::PhantomData,

  − })
  [3.253513]

  [3.253683]
  +

  + idx += 1;
• edit in src/lib.rs at line 554
  [3.253693]

  [3.253693]
  + entries[num_frames].c_offset = c_offset;

  + entries[num_frames].d_offset = d_offset;

  + self.seek_table.entries = entries;

  + self.seek_table.checksum_flag = checksum_flag as u64;

  +

  + Ok(())
• edit in src/lib.rs at line 561
  [3.253699]→[3.253699:253701](∅→∅)
  − }
• replacement in src/lib.rs at line 562
  [3.253702]→[3.253702:253763](∅→∅),[3.253763]→[3.253763:253893](∅→∅),[3.253893]→[3.253893:254572](∅→∅),[3.254572]→[3.254572:254613](∅→∅),[3.254613]→[3.254613:254640](∅→∅),[3.254640]→[3.254640:254690](∅→∅),[3.254690]→[3.254690:254705](∅→∅)
  − impl<'a, R: std::io::Read + std::io::Seek> Seekable<'a, R> {

  − /// Initialise a decompressor with a file. This method opens the file, and dropping the resulting `Seekable` closes the file.

  − pub fn init(r: Box<R>) -> Result<Self, Error> {

  − unsafe {

  − let p = ZSTD_seekable_create();

  − if p.is_null() {

  − return Err(Error::Null);

  − }

  − let opaque = Box::into_raw(r) as *mut R;

  − let adv = ZSTD_seekable_customFile {

  − opaque: opaque as *mut c_void,

  − read: Some(zstd_seekable_read::<R>),

  − seek: Some(zstd_seekable_seek::<R>),

  − };

  − let result = ZSTD_seekable_initAdvanced(p, adv);

  − if ZSTD_isError(result) != 0 {

  − return Err(Error::ZSTD(result));

  − }

  − Ok(Seekable {

  − p,

  − f: std::ptr::null_mut(),

  − b: opaque,

  − marker: std::marker::PhantomData,

  − })
  [3.253702]

  [3.254705]
  + fn init_advanced(&mut self) -> Result<(), Error> {

  + self.load_seek_table()?;

  +

  + self.decompressed_offset = u64::MAX;

  + self.cur_frame = u32::MAX;

  +

  + let dstream_init = unsafe { ZSTD_initDStream(self.dstream) };

  + if unsafe { ZSTD_isError(dstream_init) } != 0 {

  + Err(Error::ZSTD(dstream_init))

  + } else {

  + Ok(())
• replacement in src/lib.rs at line 576
  [3.254722]→[3.254722:254803](∅→∅)
  − pub fn into_inner(self) -> Box<R> {

  − unsafe { Box::from_raw(self.b) }
  [3.254722]

  [3.254803]
  + /// Decompress a single frame. This method internally calls `decompress`, and `dest` must be exactly the size of the uncompressed frame.

  + pub fn decompress_frame(&mut self, dest: &mut [u8], index: usize) -> Result<usize, Error> {

  + let dec_size = self.get_frame_decompressed_size(index)?;

  +

  + if dest.len() < dec_size {

  + return Err(Error::Other("DestinationSizeTooSmall"));

  + }

  +

  + self.decompress(

  + dest,

  + dec_size,

  + self.seek_table.entries[index].d_offset as u64,

  + )
• edit in src/lib.rs at line 590
  [3.254809]→[3.254809:254811](∅→∅)
  − }
• edit in src/lib.rs at line 591
  [3.254812]→[3.254812:254842](∅→∅)
  − impl<'a, R> Seekable<'a, R> {
• replacement in src/lib.rs at line 596
  [3.255102]→[3.255102:255331](∅→∅),[3.255331]→[3.898:935](∅→∅),[3.935]→[3.255368:255499](∅→∅),[3.1239]→[3.255368:255499](∅→∅),[3.255368]→[3.255368:255499](∅→∅)
  − pub fn decompress(&mut self, out: &mut [u8], offset: u64) -> Result<usize, Error> {

  − unsafe {

  − let result = ZSTD_seekable_decompress(

  − self.p,

  − out.as_mut_ptr() as *mut c_void,

  − out.len() as size_t,

  − offset,

  − );

  − if ZSTD_isError(result) != 0 {

  − return Err(Error::ZSTD(result));
  [3.255102]

  [3.255499]
  + pub fn decompress(

  + &mut self,

  + out: &mut [u8],

  + len: usize,

  + offset: u64,

  + ) -> Result<usize, Error> {

  + let mut tgt_frame = self.seekable_offset_to_frame_index(offset);

  + let dst = out.as_mut_ptr();

  +

  + loop {

  + if tgt_frame as usize != self.cur_frame as usize || offset != self.decompressed_offset {

  + self.decompressed_offset = self.seek_table.entries[tgt_frame].d_offset as u64;

  + self.cur_frame = tgt_frame as u32;

  +

  + self.src.seek(io::SeekFrom::Start(

  + self.seek_table.entries[tgt_frame].c_offset as u64,

  + ));

  +

  + self.inn = ZSTD_inBuffer {

  + src: self.in_buff.as_ptr() as *const _ as *const c_void,

  + size: 0,

  + pos: 0,

  + };

  + self.xxh_state = XxHash64::with_seed(0);

  + unsafe { ZSTD_resetDStream(self.dstream) };
• replacement in src/lib.rs at line 622
  [3.255513]→[3.255513:255545](∅→∅)
  − Ok(result as usize)
  [3.255513]

  [3.255545]
  +

  + while self.decompressed_offset < offset + len as u64 {

  + let mut out_tmp = if self.decompressed_offset < offset {

  + ZSTD_outBuffer {

  + dst: self.out_buff.as_mut_ptr() as *mut c_void,

  + size: cmp::min(

  + SEEKABLE_BUFF_SIZE,

  + (offset - self.decompressed_offset) as size_t,

  + ),

  + pos: 0,

  + }

  + } else {

  + ZSTD_outBuffer {

  + dst: dst as *mut c_void,

  + size: len,

  + pos: (self.decompressed_offset - offset) as size_t,

  + }

  + };

  +

  + let prev_out_pos = out_tmp.pos;

  + let mut to_read =

  + unsafe { ZSTD_decompressStream(self.dstream, &mut out_tmp, &mut self.inn) };

  + if unsafe { ZSTD_isError(to_read) } != 0 {

  + return Err(Error::ZSTD(to_read));

  + }

  +

  + if self.seek_table.checksum_flag != 0 {

  + // FIXME: replace this pointer arithmetic with something safer

  + let tmp: &[u8] = unsafe {

  + slice::from_raw_parts_mut(

  + (out_tmp.dst as *mut u8).add(prev_out_pos),

  + out_tmp.pos - prev_out_pos,

  + )

  + };

  + self.xxh_state.write(tmp)

  + }

  +

  + self.decompressed_offset += (out_tmp.pos - prev_out_pos) as u64;

  + if to_read == 0 {

  + if self.seek_table.checksum_flag != 0

  + && (self.xxh_state.finish() & 0xFFFFFFFFu64)

  + != self.seek_table.entries[tgt_frame].checksum

  + {

  + return Err(Error::Other("CorruptionDetected"));

  + }

  +

  + if self.decompressed_offset < offset + len as u64 {

  + tgt_frame = self.seekable_offset_to_frame_index(self.decompressed_offset);

  + }

  +

  + break;

  + }

  +

  + if self.inn.pos == self.inn.size {

  + to_read = cmp::min(to_read, SEEKABLE_BUFF_SIZE);

  + let mut handle = self.src.take(to_read as u64);

  + handle

  + .read(&mut self.in_buff)

  + .map_err(|_| Error::Other("Not able to read buffer"));

  + self.inn.size = to_read;

  + self.inn.pos = 0;

  + }

  + }

  +

  + if self.decompressed_offset != offset + len as u64 {

  + break;

  + }

  + }

  +

  + Ok(len)

  + }

  + }

  +

  + impl<'a> Seekable<'a, io::Cursor<&'a mut [u8]>> {

  + /// Initialise a decompressor with an input buffer.

  + pub fn init_buf(input: &'a mut [u8]) -> Result<Self, Error> {

  + let dstream = unsafe { ZSTD_createDStream() };

  + if dstream.is_null() {

  + return Err(Error::Null);
• edit in src/lib.rs at line 702
  [3.255555]

  [3.255555]
  +

  + let mut source = io::Cursor::new(input);

  + let mut seekable = Seekable::make_seekable(&mut source, dstream);

  + seekable.init_advanced()?;

  + Ok(seekable)

  + }

  + }

  +

  + impl<'a> Seekable<'a, fs::File> {

  + /// Initialise a decompressor with a file. This method opens the file, and dropping the resulting `Seekable` closes the file.

  + pub fn init_file(name: &'a str) -> Result<Self, Error> {

  + let mut source = fs::File::create(name)?;

  + let mut seekable = Seekable::make_seekable(&mut source, ptr::null_mut());

  + seekable.init_advanced()?;

  + Ok(seekable)

  + }

  + }

  +

  + impl<'a, R: io::Read + io::Seek> Seekable<'a, Box<R>> {

  + /// Initialise a decompressor with a file. This method opens the file, and dropping the resulting `Seekable` closes the file.

  + pub fn init(source: &'a mut Box<R>) -> Result<Self, Error> {

  + let source = &mut *source;

  + let mut seekable = Seekable::make_seekable(source, ptr::null_mut());

  + seekable.init_advanced()?;

  + Ok(seekable)
• edit in src/lib.rs at line 728
  [3.255561]

  [3.255561]
  +

  + // TODO: implement this properly

  + // pub fn into_inner(self) -> Box<R> {

  + // *self.src

  + // }

  + }
• edit in src/lib.rs at line 735
  [3.255562]

  [3.255562]
  + impl<'a, R> Seekable<'a, R> {
• edit in src/lib.rs at line 737
  [3.255603]

  [3.255603]
  + #[inline(always)]
• replacement in src/lib.rs at line 739
  [3.255647]→[3.255647:255710](∅→∅)
  − unsafe { ZSTD_seekable_getNumFrames(self.p) as usize }
  [3.255647]

  [3.255710]
  + self.seek_table.entries.len()
• replacement in src/lib.rs at line 742
  [3.255768]→[3.936:1019](∅→∅),[3.1019]→[3.255846:255935](∅→∅),[3.1328]→[3.255846:255935](∅→∅),[3.255846]→[3.255846:255935](∅→∅)
  − pub fn get_frame_compressed_offset(&self, frame_index: usize) -> c_ulonglong {

  − unsafe { ZSTD_seekable_getFrameCompressedOffset(self.p, frame_index as c_uint) }
  [3.255768]

  [3.255935]
  + pub fn get_frame_compressed_offset(&self, frame_index: usize) -> Result<usize, Error> {

  + if frame_index >= self.get_num_frames() {

  + Err(Error::Other("FrameIndexTooLarge"))

  + } else {

  + Ok(self.seek_table.entries[frame_index].c_offset)

  + }
• replacement in src/lib.rs at line 750
  [3.255991]→[3.255991:256162](∅→∅)
  − pub fn get_frame_compressed_size(&self, frame_index: usize) -> usize {

  − unsafe { ZSTD_seekable_getFrameCompressedSize(self.p, frame_index as c_uint) as usize }
  [3.255991]

  [3.256162]
  + pub fn get_frame_compressed_size(&self, frame_index: usize) -> Result<usize, Error> {

  + if frame_index >= self.get_num_frames() {

  + Err(Error::Other("FrameIndexTooLarge"))

  + } else {

  + Ok(self.seek_table.entries[frame_index + 1].c_offset

  + - self.seek_table.entries[frame_index].c_offset)

  + }
• replacement in src/lib.rs at line 759
  [3.256222]→[3.256222:256390](∅→∅)
  − pub fn get_frame_decompressed_offset(&self, frame_index: usize) -> u64 {

  − unsafe { ZSTD_seekable_getFrameDecompressedOffset(self.p, frame_index as c_uint) }
  [3.256222]

  [3.256390]
  + pub fn get_frame_decompressed_offset(&self, frame_index: usize) -> Result<usize, Error> {

  + if frame_index >= self.get_num_frames() {

  + Err(Error::Other("FrameIndexTooLarge"))

  + } else {

  + Ok(self.seek_table.entries[frame_index].d_offset)

  + }
• replacement in src/lib.rs at line 767
  [3.256448]→[3.256448:256623](∅→∅),[3.256623]→[3.256623:256629](∅→∅),[3.256629]→[3.256629:256770](∅→∅),[3.256770]→[3.256770:256985](∅→∅),[3.256985]→[3.1020:1058](∅→∅),[3.1058]→[3.257023:257079](∅→∅),[3.1377]→[3.257023:257079](∅→∅),[3.257023]→[3.257023:257079](∅→∅)
  − pub fn get_frame_decompressed_size(&self, frame_index: usize) -> usize {

  − unsafe { ZSTD_seekable_getFrameDecompressedSize(self.p, frame_index as c_uint) as usize }

  − }

  − /// Decompress a single frame. This method internally calls `decompress`, and `dest` must be exactly the size of the uncompressed frame.

  − pub fn decompress_frame(&mut self, dest: &mut [u8], index: usize) -> usize {

  − unsafe {

  − ZSTD_seekable_decompressFrame(

  − self.p,

  − dest.as_mut_ptr() as *mut c_void,

  − dest.len() as size_t,

  − index as c_uint,

  − ) as usize
  [3.256448]

  [3.257079]
  + pub fn get_frame_decompressed_size(&self, frame_index: usize) -> Result<usize, Error> {

  + if frame_index > self.get_num_frames() {

  + Err(Error::Other("FrameIndexTooLarge"))

  + } else {

  + Ok(self.seek_table.entries[frame_index + 1].d_offset

  + - self.seek_table.entries[frame_index].d_offset)
• replacement in src/lib.rs at line 776
  [3.257168]→[3.257168:257322](∅→∅)
  − pub fn seekable_offset_to_frame_index(&mut self, offset: u64) -> usize {

  − unsafe { ZSTD_seekable_offsetToFrameIndex(self.p, offset) as usize }
  [3.257168]

  [3.257322]
  + pub fn seekable_offset_to_frame_index(&self, offset: u64) -> usize {

  + if offset >= self.seek_table.entries[self.get_num_frames()].d_offset as u64 {

  + return self.get_num_frames();

  + }

  +

  + let (mut lo, mut hi) = (0, self.get_num_frames());

  +

  + while lo + 1 < hi {

  + let mid = lo + ((hi - lo) >> 1);

  + if self.seek_table.entries[mid].d_offset as u64 <= offset {

  + lo = mid

  + } else {

  + hi = mid;

  + }

  + }

  +

  + lo
• replacement in src/lib.rs at line 803
  [3.257480]→[3.257480:257505](∅→∅)
  − impl Dst for [u8; 256] {
  [3.257480]

  [3.257505]
  + impl<const N: usize> Dst for [u8; N] {
• replacement in src/lib.rs at line 811
  [3.257679]→[3.257679:257691](∅→∅)
  − 256
  [3.257679]

  [3.257691]
  + N
• edit in src/lib.rs at line 817
  [3.257793]→[3.257793:258033](∅→∅),[3.258033]→[3.258033:258098](∅→∅),[3.258098]→[3.258098:258348](∅→∅),[3.258348]→[3.258348:258413](∅→∅),[3.258413]→[3.258413:258663](∅→∅),[3.258663]→[3.258663:258728](∅→∅),[3.258728]→[3.258728:258978](∅→∅),[3.258978]→[3.258978:259043](∅→∅),[3.259043]→[3.259043:259051](∅→∅)
  − impl Dst for [u8; 512] {

  − fn as_mut_ptr(&mut self) -> *mut u8 {

  − self.as_mut().as_mut_ptr()

  − }

  − fn as_slice(&self) -> &[u8] {

  − self.as_ref()

  − }

  − fn len(&self) -> usize {

  − 512

  − }

  − fn new() -> Self {

  − unsafe { std::mem::MaybeUninit::uninit().assume_init() }

  − }

  − }

  − impl Dst for [u8; 1024] {

  − fn as_mut_ptr(&mut self) -> *mut u8 {

  − self.as_mut().as_mut_ptr()

  − }

  − fn as_slice(&self) -> &[u8] {

  − self.as_ref()

  − }

  − fn len(&self) -> usize {

  − 1024

  − }

  − fn new() -> Self {

  − unsafe { std::mem::MaybeUninit::uninit().assume_init() }

  − }

  − }

  − impl Dst for [u8; 2048] {

  − fn as_mut_ptr(&mut self) -> *mut u8 {

  − self.as_mut().as_mut_ptr()

  − }

  − fn as_slice(&self) -> &[u8] {

  − self.as_ref()

  − }

  − fn len(&self) -> usize {

  − 2048

  − }

  − fn new() -> Self {

  − unsafe { std::mem::MaybeUninit::uninit().assume_init() }

  − }

  − }

  − impl Dst for [u8; 4096] {

  − fn as_mut_ptr(&mut self) -> *mut u8 {

  − self.as_mut().as_mut_ptr()

  − }

  − fn as_slice(&self) -> &[u8] {

  − self.as_ref()

  − }

  − fn len(&self) -> usize {

  − 4096

  − }

  − fn new() -> Self {

  − unsafe { std::mem::MaybeUninit::uninit().assume_init() }

  − }

  − }
• replacement in src/lib.rs at line 819
  [3.259089]→[3.1059:1103](∅→∅),[3.1103]→[3.259133:259155](∅→∅),[3.1442]→[3.259133:259155](∅→∅),[3.259133]→[3.259133:259155](∅→∅)
  − src_size: size_t,

  − dst_size: size_t,

  − checksum: c_uint,
  [3.259089]

  [3.259155]
  + src_size: u32,

  + dst_size: u32,

  + checksum: u64,
• replacement in src/lib.rs at line 831
  [3.259302]→[3.259302:259367](∅→∅),[3.259367]→[3.259367:259369](∅→∅)
  − extern "C" {

  − fn xxh64(src: *const u8, len: c_int) -> c_uint;

  − }
  [3.259302]

  [3.259369]
  + fn compress_frame<D: Dst>(src: &[u8], level: usize) -> Result<CompressedFrame<D>, Error> {

  + let mut dst = D::new();
• replacement in src/lib.rs at line 834
  [3.259370]→[3.259370:259397](∅→∅),[3.259397]→[3.259397:259421](∅→∅),[3.259421]→[3.1104:1125](∅→∅),[3.1125]→[3.259442:259501](∅→∅),[3.1474]→[3.259442:259501](∅→∅),[3.259442]→[3.259442:259501](∅→∅),[3.259501]→[3.259501:259636](∅→∅)
  − fn compress_frame<D: Dst>(

  − src_ptr: *const u8,

  − src_len: size_t,

  − level: usize,

  − ) -> Result<CompressedFrame<D>, Error> {

  − unsafe {

  − let mut dst = D::new();

  − let checksum = xxh64(src_ptr, src_len as c_int);

  − let ret = ZSTD_compress(
  [3.259370]

  [3.259636]
  + let ret = unsafe {

  + ZSTD_compress(
• replacement in src/lib.rs at line 838
  [3.1159]→[3.259714:259773](∅→∅),[3.1518]→[3.259714:259773](∅→∅),[3.259714]→[3.259714:259773](∅→∅)
  − src_ptr as *const c_void,

  − src_len,
  [3.1159]

  [3.259773]
  + src.as_ptr() as *const c_void,

  + src.len() as size_t,
• replacement in src/lib.rs at line 841
  [3.259801]→[3.259801:260079](∅→∅)
  − );

  − if ZSTD_isError(ret) != 0 {

  − return Err(Error::ZSTD(ret));

  − }

  − println!("{:?}", dst.as_slice());

  − Ok(CompressedFrame {

  − src_size: src_len,

  − dst_size: ret,

  − checksum,

  − dst,

  − })
  [3.259801]

  [3.260079]
  + )

  + };

  +

  + if unsafe { ZSTD_isError(ret) } != 0 {

  + return Err(Error::ZSTD(ret));
• edit in src/lib.rs at line 847
  [3.260085]

  [3.260085]
  +

  + println!("{:?}", dst.as_slice());

  +

  + let checksum = hash64(src);

  +

  + Ok(CompressedFrame {

  + src_size: src.len() as u32,

  + dst_size: ret as u32,

  + checksum,

  + dst,

  + })
• replacement in src/lib.rs at line 862
  [3.260131]→[3.260131:260245](∅→∅)
  − let p = unsafe { ZSTD_seekable_createFrameLog(1) };

  − assert!(!p.is_null());

  − FrameLog { p }
  [3.260131]

  [3.260245]
  + FrameLog {

  + entries: Vec::new(),

  + checksum_flag: 1,

  + seek_table_pos: 0,

  + seek_table_index: 0,

  + }

  + }

  +

  + pub fn log_frame(&mut self, c_size: u32, d_size: u32, checksum: u64) -> Result<(), Error> {

  + if self.entries.len() == SEEKABLE_MAXFRAMES {

  + return Err(Error::Other("FrameIndexTooLarge"));

  + }

  +

  + self.entries.push(FrameLogEntry {

  + c_size,

  + d_size,

  + checksum,

  + });

  +

  + Ok(())

  + }

  +

  + #[inline(always)]

  + pub fn seek_table_size(&self) -> usize {

  + let size_p_frame = 8 + if self.checksum_flag != 0 { 4 } else { 0 };

  + return SKIPPABLE_HEADER_SIZE + size_p_frame * self.entries.len() + SEEK_TABLE_FOOTER_SIZE;
• edit in src/lib.rs at line 889
  [3.260251]

  [3.260251]
  +

  + pub fn stwrite32(&self, output: &mut ZSTD_outBuffer, value: usize, offset: usize) -> usize {

  + if (self.seek_table_pos as usize) < offset + 4 {

  + let tmp = value.to_ne_bytes();

  + let len_write = cmp::min(

  + output.size - output.pos,

  + offset + 4 - self.seek_table_pos as usize,

  + );
• replacement in src/lib.rs at line 898
  [3.260252]→[3.260252:260547](∅→∅)
  − pub fn log_frame<D: Dst>(&mut self, frame: &CompressedFrame<D>) -> usize {

  − unsafe {

  − ZSTD_seekable_logFrame(

  − self.p,

  − frame.dst_size as c_uint,

  − frame.src_size as c_uint,

  − frame.checksum,

  − ) as usize
  [3.260252]

  [3.260547]
  + // FIXME: replace this pointer arithmetic with something safer

  + unsafe {

  + ptr::copy_nonoverlapping(

  + tmp.as_ptr().add(self.seek_table_pos as usize - offset) as *const usize,

  + output.dst.add(output.pos) as *mut usize,

  + len_write,

  + )

  + };

  +

  + output.pos += len_write;

  +

  + return if len_write < 4 {

  + self.seek_table_size() - self.seek_table_pos as usize

  + } else {

  + 0

  + };
• edit in src/lib.rs at line 915
  [3.260557]

  [3.260557]
  + 0
• replacement in src/lib.rs at line 918
  [3.260564]→[3.260564:260653](∅→∅)
  − pub fn write_all<W: std::io::Write>(&self, mut w: W) -> Result<(), std::io::Error> {
  [3.260564]

  [3.260653]
  + pub fn write_all<W: io::Write>(&mut self, mut w: W) -> Result<(), io::Error> {
• replacement in src/lib.rs at line 925
  [3.260840]→[3.260840:261029](∅→∅)
  − unsafe {

  − while ZSTD_seekable_writeSeekTable(self.p, &mut output_) != 0 {

  − w.write_all(&output[..output_.pos as usize])?;

  − output_.pos = 0;
  [3.260840]

  [3.261029]
  +

  + while let Ok(ret) = self.write_seek_table(&mut output_) {

  + if ret == 0 {

  + break;
• edit in src/lib.rs at line 930
  [3.261043]

  [3.261043]
  +
• edit in src/lib.rs at line 932
  [3.261102]

  [3.261102]
  + output_.pos = 0;
• edit in src/lib.rs at line 934
  [3.261112]

  [3.261112]
  +

  + w.write_all(&output[..output_.pos as usize])?;
• replacement in src/lib.rs at line 938
  [3.261133]→[3.261133:261135](∅→∅)
  − }
  [3.261133]

  [3.261135]
  +

  + pub fn write_seek_table(&mut self, output: &mut ZSTD_outBuffer) -> Result<usize, Error> {

  + let size_p_frame = 8 + if self.checksum_flag != 0 { 4 } else { 0 };

  + let table_len = self.seek_table_size();

  +

  + let mut ret: usize = self.stwrite32(output, MAGIC_SKIPPABLE_START | 0xE, 0);

  + if ret != 0 {

  + return Ok(ret);

  + };

  +

  + // assert!(table_len <= usize::MAX);

  +

  + ret = self.stwrite32(output, table_len - SKIPPABLE_HEADER_SIZE, 4);

  + if ret != 0 {

  + return Ok(ret);

  + };

  +

  + let mut i = self.seek_table_index as usize;

  +

  + while i < self.entries.len() {

  + let start = SKIPPABLE_HEADER_SIZE + size_p_frame * i;

  + // assert!(start + 8 <= usize::MAX);

  +

  + ret = self.stwrite32(output, self.entries[i].c_size as usize, start);

  + if ret != 0 {

  + return Ok(ret);

  + };

  +

  + ret = self.stwrite32(output, self.entries[i].d_size as usize, start + 4);

  + if ret != 0 {

  + return Ok(ret);

  + };

  +

  + if self.checksum_flag != 0 {

  + ret = self.stwrite32(output, self.entries[i].checksum as usize, start + 8);

  + if ret != 0 {

  + return Ok(ret);

  + };

  + }
• replacement in src/lib.rs at line 978
  [3.261136]→[3.261136:261169](∅→∅),[3.261169]→[3.1160:1177](∅→∅),[3.1177]→[3.261186:261188](∅→∅),[3.1546]→[3.261186:261188](∅→∅),[3.261186]→[3.261186:261188](∅→∅)
  − struct Chunk {

  − p: *const u8,

  − len: size_t,

  − }
  [3.261136]

  [3.261188]
  + i += 1;

  + }
• replacement in src/lib.rs at line 981
  [3.261189]→[3.261189:261219](∅→∅)
  − unsafe impl Send for Chunk {}
  [3.261189]

  [3.261219]
  + self.seek_table_index = i as u32;

  + // assert!(table_len <= usize::MAX);
• replacement in src/lib.rs at line 984
  [3.261220]→[3.261220:261283](∅→∅),[3.261283]→[3.261283:261299](∅→∅)
  − pub fn parallel_compress<W: std::io::Write, D: Dst + 'static>(

  − src: &[u8],
  [3.261220]

  [3.261299]
  + ret = self.stwrite32(

  + output,

  + self.entries.len(),

  + table_len - SEEK_TABLE_FOOTER_SIZE,

  + );

  + if ret != 0 {

  + return Ok(ret);

  + };

  +

  + if output.size - output.pos < 1 {

  + return Ok(table_len - self.seek_table_pos as usize);

  + }

  + if (self.seek_table_pos as usize) < table_len {

  + let sfd = (self.checksum_flag << 7) as u8;

  +

  + let array = unsafe { slice::from_raw_parts_mut(output.dst as *mut u8, output.size) };

  +

  + array

  + .get_mut(output.pos)

  + .and_then(|el| Some(*el = sfd))

  + .ok_or(Error::Other("index out of bounds"));

  +

  + output.pos += 1;

  + }

  +

  + ret = self.stwrite32(output, SEEKABLE_MAGIC_NUMBER, table_len - 4);

  + if ret != 0 {

  + return Ok(ret);

  + };

  +

  + if self.seek_table_pos as usize != table_len {

  + Err(Error::Other("Generic error from ZSTD"))

  + } else {

  + Ok(0)

  + }

  + }

  + }

  +

  + pub fn parallel_compress<W: io::Write, D: Dst + 'static>(

  + src: &'static [u8],
• replacement in src/lib.rs at line 1028
  [3.1203]→[3.261386:261420](∅→∅),[3.261386]→[3.261386:261420](∅→∅)
  − use std::sync::mpsc::channel;
  [3.1203]

  [3.261420]
  + use sync::mpsc::channel;
• edit in src/lib.rs at line 1038
  [3.261715]→[3.261715:261774](∅→∅),[3.261774]→[3.1204:1244](∅→∅),[3.1244]→[3.261814:261825](∅→∅),[3.1597]→[3.261814:261825](∅→∅),[3.261814]→[3.261814:261825](∅→∅)
  − let chunk = Chunk {

  − p: chunk.as_ptr(),

  − len: chunk.len() as size_t,

  − };
• replacement in src/lib.rs at line 1039
  [3.261856]→[3.261856:261932](∅→∅)
  − let frame = compress_frame(chunk.p, chunk.len, level).unwrap();
  [3.261856]

  [3.261932]
  + let frame = compress_frame(chunk, level);
• replacement in src/lib.rs at line 1045
  [3.262054]→[3.262054:262288](∅→∅)
  − let frames: Vec<CompressedFrame<D>> = unsafe {

  − let mut frames = Vec::with_capacity(n);

  − frames.set_len(n);

  − for (i, frame) in rx.iter().take(n) {

  − frames[i] = frame

  − }

  − frames

  − };
  [3.262054]

  [3.262288]
  + let mut frames: Vec<CompressedFrame<D>> = Vec::with_capacity(n);

  + unsafe { frames.set_len(n) };

  + for (i, frame) in rx.iter().take(n) {

  + frames[i] = frame?;

  + }

  +
• replacement in src/lib.rs at line 1054
  [3.262401]→[3.262401:262431](∅→∅)
  − log.log_frame(frame);
  [3.262401]

  [3.262431]
  + log.log_frame(frame.src_size, frame.dst_size, frame.checksum)?;
• replacement in src/lib.rs at line 1073
  [3.263713]→[3.263713:263774](∅→∅)
  − println!("{:?}", std::str::from_utf8(&decomp).unwrap());
  [3.263713]

  [3.263774]
  + println!("{:?}", str::from_utf8(&decomp).unwrap());
• replacement in src/lib.rs at line 1100
  [3.265152]→[3.265152:265243](∅→∅)
  − use std::io::Write;

  − let mut file = std::fs::File::create("test").unwrap();
  [3.265152]

  [3.265243]
  + use io::Write;

  + let mut file = fs::File::create("test").unwrap();
• replacement in src/lib.rs at line 1115
  [3.265774]→[3.265774:265835](∅→∅)
  − println!("{:?}", std::str::from_utf8(&decomp).unwrap());
  [3.265774]

  [3.265835]
  + println!("{:?}", str::from_utf8(&decomp).unwrap());
• replacement in src/bindings.rs at line 1
  [3.1612]→[3.1245:1309](∅→∅),[3.1309]→[3.1666:1667](∅→∅),[3.1666]→[3.1666:1667](∅→∅),[3.1798]→[3.1798:1839](∅→∅),[3.1839]→[3.1310:1345](∅→∅),[3.1345]→[3.1863:1887](∅→∅),[3.1863]→[3.1863:1887](∅→∅)
  − use libc::{c_void, size_t, c_int, c_uint, c_char, c_ulonglong};

  −

  − #[repr(C)]

  − #[derive(Debug, Copy, Clone)]

  − pub struct ZSTD_seekable_CStream {

  − _unused: [u8; 0],

  − }
  [3.1612]

  [3.1346]
  + use libc::{c_char, c_int, c_longlong, c_uint, c_void, size_t};
• edit in src/bindings.rs at line 6
  [3.1374]→[3.1953:1977](∅→∅),[3.1953]→[3.1953:1977](∅→∅),[3.1977]→[3.1375:1376](∅→∅),[3.1376]→[3.1977:2018](∅→∅),[3.1977]→[3.1977:2018](∅→∅),[3.2018]→[3.1377:1404](∅→∅)
  − _unused: [u8; 0],

  − }

  −

  − #[repr(C)]

  − #[derive(Debug, Copy, Clone)]

  − pub struct ZSTD_frameLog {
• edit in src/bindings.rs at line 11
  [3.2990]→[3.1407:1434](∅→∅),[3.1434]→[3.3015:3039](∅→∅),[3.3015]→[3.3015:3039](∅→∅),[3.3039]→[3.1435:1436](∅→∅),[3.1436]→[3.3103:3144](∅→∅),[3.3103]→[3.3103:3144](∅→∅)
  − pub struct ZSTD_seekable {

  − _unused: [u8; 0],

  − }

  −

  − #[repr(C)]

  − #[derive(Debug, Copy, Clone)]
• edit in src/bindings.rs at line 29
  [3.8872]→[3.8872:8874](∅→∅),[3.8874]→[3.1579:1580](∅→∅),[3.1580]→[3.1580:2045](∅→∅),[3.2045]→[3.8932:8973](∅→∅),[3.8932]→[3.8932:8973](∅→∅),[3.8973]→[3.2046:2197](∅→∅)
  − }

  −

  − pub type ZSTD_seekable_read = ::std::option::Option<

  − unsafe extern "C" fn(

  − opaque: *mut ::std::os::raw::c_void,

  − buffer: *mut ::std::os::raw::c_void,

  − n: size_t,

  − ) -> ::std::os::raw::c_int,

  − >;

  − pub type ZSTD_seekable_seek = ::std::option::Option<

  − unsafe extern "C" fn(

  − opaque: *mut ::std::os::raw::c_void,

  − offset: ::std::os::raw::c_longlong,

  − origin: ::std::os::raw::c_int,

  − ) -> ::std::os::raw::c_int,

  − >;

  − #[repr(C)]

  − #[derive(Debug, Copy, Clone)]

  − pub struct ZSTD_seekable_customFile {

  − pub opaque: *mut ::std::os::raw::c_void,

  − pub read: ZSTD_seekable_read,

  − pub seek: ZSTD_seekable_seek,
• edit in src/bindings.rs at line 46
  [3.2693]→[3.9081:9153](∅→∅),[3.9081]→[3.9081:9153](∅→∅),[3.9168]→[3.9168:9249](∅→∅),[3.9264]→[3.9264:9343](∅→∅),[3.9343]→[3.2694:2786](∅→∅),[3.2786]→[3.9483:9500](∅→∅),[3.9483]→[3.9483:9500](∅→∅),[3.9515]→[3.9515:9686](∅→∅),[3.9701]→[3.9701:9832](∅→∅),[3.9832]→[3.2787:2871](∅→∅),[3.2871]→[3.10098:10171](∅→∅),[3.10098]→[3.10098:10171](∅→∅),[3.10186]→[3.10186:10253](∅→∅),[3.10253]→[3.2872:2964](∅→∅),[3.2964]→[3.10393:10410](∅→∅),[3.10393]→[3.10393:10410](∅→∅),[3.10425]→[3.10425:10552](∅→∅),[3.10567]→[3.10567:10624](∅→∅),[3.10639]→[3.10639:10704](∅→∅),[3.10719]→[3.10719:10786](∅→∅),[3.10786]→[3.2965:2993](∅→∅),[3.2993]→[3.10830:10872](∅→∅),[3.10830]→[3.10830:10872](∅→∅),[3.10887]→[3.10887:10978](∅→∅),[3.10993]→[3.10993:11062](∅→∅),[3.11062]→[3.2994:3020](∅→∅),[3.3020]→[3.11104:11129](∅→∅),[3.11104]→[3.11104:11129](∅→∅),[3.11129]→[3.3021:3050](∅→∅),[3.3050]→[3.11174:11191](∅→∅),[3.11174]→[3.11174:11191](∅→∅),[3.11206]→[3.11206:11280](∅→∅),[3.11280]→[3.3051:3077](∅→∅),[3.3077]→[3.11322:11347](∅→∅),[3.11322]→[3.11322:11347](∅→∅),[3.11347]→[3.3078:3106](∅→∅),[3.3106]→[3.11391:11408](∅→∅),[3.11391]→[3.11391:11408](∅→∅),[3.11408]→[3.3107:3180](∅→∅),[3.3180]→[3.11527:11610](∅→∅),[3.11527]→[3.11527:11610](∅→∅),[3.11610]→[3.3181:3231](∅→∅),[3.3231]→[3.11707:11792](∅→∅),[3.11707]→[3.11707:11792](∅→∅),[3.11792]→[3.3232:3282](∅→∅),[3.3282]→[3.11889:11970](∅→∅),[3.11889]→[3.11889:11970](∅→∅),[3.11970]→[3.3283:3311](∅→∅),[3.3311]→[3.12014:12031](∅→∅),[3.12014]→[3.12014:12031](∅→∅),[3.12046]→[3.12046:12129](∅→∅),[3.12129]→[3.3312:3340](∅→∅),[3.3340]→[3.12173:12190](∅→∅),[3.12173]→[3.12173:12190](∅→∅),[3.12205]→[3.12205:12282](∅→∅),[3.12282]→[3.3341:3387](∅→∅)
  − pub fn ZSTD_seekable_createCStream() -> *mut ZSTD_seekable_CStream;

  − pub fn ZSTD_seekable_freeCStream(zcs: *mut ZSTD_seekable_CStream) -> size_t;

  − pub fn ZSTD_seekable_initCStream(

  − zcs: *mut ZSTD_seekable_CStream,

  − compressionLevel: c_int,

  − checksumFlag: c_int,

  − maxFrameSize: c_uint,

  − ) -> size_t;

  − pub fn ZSTD_seekable_compressStream(

  − zcs: *mut ZSTD_seekable_CStream,

  − output: *mut ZSTD_outBuffer,

  − input: *mut ZSTD_inBuffer,

  − ) -> size_t;

  − pub fn ZSTD_seekable_endStream(

  − zcs: *mut ZSTD_seekable_CStream,

  − output: *mut ZSTD_outBuffer,

  − ) -> size_t;

  − pub fn ZSTD_seekable_createFrameLog(checksumFlag: c_int) -> *mut ZSTD_frameLog;

  − pub fn ZSTD_seekable_freeFrameLog(fl: *mut ZSTD_frameLog) -> size_t;

  − pub fn ZSTD_seekable_logFrame(

  − fl: *mut ZSTD_frameLog,

  − compressedSize: c_uint,

  − decompressedSize: c_uint,

  − checksum: c_uint,

  − ) -> size_t;

  − pub fn ZSTD_seekable_writeSeekTable(

  − fl: *mut ZSTD_frameLog,

  − output: *mut ZSTD_outBuffer,

  − ) -> size_t;

  − pub fn ZSTD_seekable_create() -> *mut ZSTD_seekable;

  − pub fn ZSTD_seekable_free(zs: *mut ZSTD_seekable) -> size_t;

  − pub fn ZSTD_seekable_initBuff(

  − zs: *mut ZSTD_seekable,

  − src: *const c_void,

  − srcSize: size_t,

  − ) -> size_t;

  − pub fn ZSTD_seekable_initFile(zs: *mut ZSTD_seekable, src: *mut libc::FILE) -> size_t;

  − pub fn ZSTD_seekable_decompress(

  − zs: *mut ZSTD_seekable,

  − dst: *mut c_void,

  − dstSize: size_t,

  − offset: c_ulonglong,

  − ) -> size_t;

  − pub fn ZSTD_seekable_decompressFrame(

  − zs: *mut ZSTD_seekable,

  − dst: *mut c_void,

  − dstSize: size_t,

  − frameIndex: c_uint,

  − ) -> size_t;

  − pub fn ZSTD_seekable_getNumFrames(zs: *mut ZSTD_seekable) -> c_uint;

  − pub fn ZSTD_seekable_getFrameCompressedOffset(

  − zs: *mut ZSTD_seekable,

  − frameIndex: c_uint,

  − ) -> c_ulonglong;

  − pub fn ZSTD_seekable_getFrameDecompressedOffset(

  − zs: *mut ZSTD_seekable,

  − frameIndex: c_uint,

  − ) -> c_ulonglong;

  − pub fn ZSTD_seekable_getFrameCompressedSize(

  − zs: *mut ZSTD_seekable,

  − frameIndex: c_uint,

  − ) -> size_t;

  − pub fn ZSTD_seekable_getFrameDecompressedSize(

  − zs: *mut ZSTD_seekable,

  − frameIndex: c_uint,

  − ) -> size_t;

  − pub fn ZSTD_seekable_offsetToFrameIndex(

  − zs: *mut ZSTD_seekable,

  − offset: c_ulonglong,

  − ) -> c_uint;
• edit in src/bindings.rs at line 52
  [3.3576]

  [3.3576]
  + pub fn ZSTD_resetCStream(zcs: *mut ZSTD_CStream, pledgedSrcSize: c_longlong);
• edit in src/bindings.rs at line 66
  [3.4179]

  [3.4179]
  + pub fn ZSTD_resetDStream(zds: *mut ZSTD_DStream) -> size_t;
• replacement in src/bindings.rs at line 72
  [3.4334]→[3.4334:4461](∅→∅),[3.4461]→[3.4461:4572](∅→∅)
  − pub fn ZSTD_seekable_initAdvanced(

  − zs: *mut ZSTD_seekable,

  − src: ZSTD_seekable_customFile,

  − ) -> size_t;

  − pub fn ZSTD_initCStream(

  − zcs: *mut ZSTD_CStream,

  − compressionLevel: c_int,

  − ) -> size_t;
  [3.4334]

  [3.12360]
  + pub fn ZSTD_initCStream(zcs: *mut ZSTD_CStream, compressionLevel: c_int) -> size_t;
• edit in build.rs at line 2
  [3.266149]→[3.266149:266447](∅→∅)
  − cc::Build::new()

  − .file("zstd/contrib/seekable_format/zstdseek_compress.c")

  − .file("zstd/contrib/seekable_format/zstdseek_decompress.c")

  − .file("xxh64.c")

  − .opt_level(3)

  − .include("zstd/lib/common")

  − .include("zstd/lib")

  − .compile("zstdseek");

  −
• edit in build.rs at line 5
  [2.108]→[2.108:220](∅→∅)
  − if pkg_config::probe_library("libxxhash").is_err() {

  − println!("cargo:rustc-link-lib=xxhash");

  − }
• replacement in Cargo.toml at line 15
  [3.270088]→[3.13320:13341](∅→∅),[3.13341]→[3.270088:270374](∅→∅),[3.270088]→[3.270088:270374](∅→∅)
  − "src/bindings.rs",

  − "xxh64.c",

  − "zstd/contrib/seekable_format/zstd_seekable.h",

  − "zstd/contrib/seekable_format/zstdseek_compress.c",

  − "zstd/contrib/seekable_format/zstdseek_decompress.c",

  − "zstd/lib/common/mem.h",

  − "zstd/lib/common/xxhash.h",

  − "zstd/lib/zstd.h",

  − "zstd/lib/common/zstd_errors.h",
  [3.270088]

  [3.270374]
  + "src/bindings.rs"
• edit in Cargo.toml at line 22
  [3.270457]

  [3.270457]
  + twox-hash = "1.6.0"
• edit in Cargo.toml at line 25
  [3.270479]→[3.270479:270490](∅→∅)
  − cc = "1.0"