pijul/zstd-seekable - Change 6XB4RDRQIINYARVQUO3U3ZG7652UIUXBUF33U7JEJ7ASRI47EKHAC

Adding changes from original impl

Created by darleybarreto on July 26, 2021

6XB4RDRQIINYARVQUO3U3ZG7652UIUXBUF33U7JEJ7ASRI47EKHAC

Dependencies

In channels

main

In discussions

#5 Oxidizing C files

Change contents

Insertion in src/lib.rs at line 23 [5.241245]
[3.400]
[4.0]
```
const SEEKABLE_NO_OUTPUT_PROGRESS_MAX: u32 = 16;
```
Insertion in src/lib.rs at line 30 [5.241245]
[3.665]
[5.241471]
```
const ZSTD_reset_session_only: c_uint = 1;
```

Replacement in src/lib.rs at line 69 [5.241245]

B:BD[3.1192] → [3.1192:1234]

    c_offset: usize,
    d_offset: usize,

[3.1192]

[3.1234]

    c_offset: u64,
    d_offset: u64,

Insertion in src/lib.rs at line 84 [5.241245]
[6.91]
[3.1413]
```
    inner_buf_size: Option<usize>,
```
Insertion in src/lib.rs at line 106 [5.241245]
[4.231]
[4.231]
```
    SeekableIo,
```
Replacement in src/lib.rs at line 111 [5.241245]
B:BD[4.345] → [4.345:378]
```
    DSizeTooSmall(usize, usize),
```
[4.345]
[5.242248]
```
    DSizeTooSmall(u64, u64),
```

Replacement in src/lib.rs at line 123 [5.241245]

B:BD[4.564] → [4.564:613]

            Error::Null => write!(fmt, "Null."),

[4.564]

[4.613]

            Error::Null => write!(fmt, "Null pointer."),

Replacement in src/lib.rs at line 129 [5.241245]

B:BD[4.794] → [4.794:865]

            Error::Generic => write!(fmt, "Generic error from ZSTD."),

[4.794]

[4.865]

            Error::Generic => write!(fmt, "Error (generic)."),
            Error::SeekableIo => write!(fmt, "An I/O error occurred when reading/seeking."),

Replacement in src/lib.rs at line 134 [5.241245]

B:BD[4.1040] → [4.1040:1121]

                "Frame parameter not supported. Expected at most {}, found {}.",

[4.1040]

[4.1121]

                "Unsupported frame parameter. Expected at most {}, found {}.",

Replacement in src/lib.rs at line 137 [5.241245]

B:BD[4.1157] → [4.1157:1316]

            Error::PrefixUnknown(p) => write!(fmt, "Prefix unknown {}", p),
            Error::Corruption(ref s) => write!(fmt, "Corruption detected {}.", s),

[4.1157]

[4.1316]

            Error::PrefixUnknown(p) => write!(fmt, "Unknown frame descriptor {}", p),
            Error::Corruption(ref s) => write!(fmt, "Corrupted block detected {}.", s),

Replacement in src/lib.rs at line 141 [5.241245]

B:BD[4.1387] → [4.1387:1466]

                "Destination size too small. Expected at least {}, found {}.",

[4.1387]

[4.1466]

                "Destination buffer is too small. Expected at least {}, found {}.",

Replacement in src/lib.rs at line 322 [5.241245]

B:BD[3.5878] → [3.5878:5935]

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

[3.5878]

[3.5935]

        unsafe {
            let r = ZSTD_CCtx_reset(self.cstream.p, ZSTD_reset_session_only);
            if ZSTD_isError(r) != 0 {
                return Err(Error::ZSTD(r));
            }
        };

Replacement in src/lib.rs at line 523 [5.241245]

B:BD[4.3514] → [4.3514:3587]

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

[4.3514]

[4.3587]

        let mut seekable = Self::make_seekable(source, ptr::null_mut(), None);

Replacement in src/lib.rs at line 528 [5.241245]

∅:D[4.3650] → [6.207:277]

B:BD[6.207] → [6.207:277]

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

[4.3650]

[3.8948]

    fn make_seekable(source: R, dstream: *mut ZSTD_DStream, size: Option<usize>) -> Self {

Insertion in src/lib.rs at line 536 [5.241245]
[3.9135]
[3.9135]
```
            inner_buf_size: size,
```

Replacement in src/lib.rs at line 562 [5.241245]

B:BD[3.9915] → [3.9915:9976]

B:BD[3.9976] → [4.3850:3898]

        let checksum_flag = (self.in_buff[4] >> 7) as usize;
        if ((checksum_flag >> 2) & 0x1f) != 0 {

[3.9915]

[4.3898]

        let sfd = self.in_buff[4];
        let checksum_flag = (sfd >> 7) as usize;
        if ((sfd >> 2) & 0x1f) != 0 {

Replacement in src/lib.rs at line 617 [5.241245]

∅:D[2.151] → [4.4779:4852]

B:BD[4.4779] → [4.4779:4852]

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

[2.151]

[4.4852]

            let a = slice_to_num(&self.in_buff[pos..pos + 4])? as u64;

Replacement in src/lib.rs at line 620 [5.241245]

B:BD[3.12153] → [3.12153:12230]

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

[3.12153]

[3.12230]

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

Replacement in src/lib.rs at line 651 [5.241245]

B:BD[4.5125] → [2.152:200]

                Err(Error::ZSTD(dstream_init));

[4.5125]

[4.5180]

                Err(Error::ZSTD(dstream_init))

Replacement in src/lib.rs at line 662 [5.241245]

B:BD[3.13330] → [3.13330:13365]

B:BD[3.13365] → [4.5239:5299]

        if dest.len() < dec_size {
            Err(Error::DSizeTooSmall(dest.len(), dec_size))

[3.13330]

[4.5299]

        if (dest.len() as u64) < dec_size {
            Err(Error::DSizeTooSmall(dest.len() as u64, dec_size))

Replacement in src/lib.rs at line 665 [5.241245]

B:BD[4.5316] → [4.5316:5471]

            self.decompress(
                dest,
                dec_size,
                self.seek_table.entries[index].d_offset as u64,
            )

[4.5316]

[3.13430]

            self.decompress(dest, dec_size, self.seek_table.entries[index].d_offset)

Replacement in src/lib.rs at line 674 [5.241245]

B:BD[5.255102] → [7.488:588]

    pub fn decompress(&mut self, out: &mut [u8], len: usize, offset: u64) -> Result<usize, Error> {

[5.255102]

[3.13716]

    pub fn decompress(&mut self, out: &mut [u8], len: u64, offset: u64) -> Result<usize, Error> {
        let eos = self.seek_table.entries[self.seek_table.entries.len() - 1].d_offset;
        let len = if offset + len > eos {
            eos - offset
        } else {
            len
        };

Insertion in src/lib.rs at line 684 [5.241245]

[3.13789]

[3.13825]

        let mut no_output_progress_c = 0u32;
        let mut src_bytes_read = 0usize;

Replacement in src/lib.rs at line 689 [5.241245]

B:BD[3.13942] → [3.13942:14037]

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

[3.13942]

[3.14037]

                self.decompressed_offset = self.seek_table.entries[tgt_frame].d_offset;

Replacement in src/lib.rs at line 693 [5.241245]

B:BD[3.14140] → [3.14140:14212]

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

[3.14140]

[7.589]

                    self.seek_table.entries[tgt_frame].c_offset,

Insertion in src/lib.rs at line 701 [5.241245]
[3.14429]
[3.14429]

Replacement in src/lib.rs at line 703 [5.241245]

B:BD[3.14486] → [3.14486:14546]

                unsafe { ZSTD_resetDStream(self.dstream) };

[3.14486]

[5.255499]


                unsafe {
                    let r = ZSTD_DCtx_reset(self.dstream, ZSTD_reset_session_only);
                    if ZSTD_isError(r) != 0 {
                        return Err(Error::ZSTD(r));
                    }
                }
                if let Some(size) = &self.inner_buf_size {
                    if src_bytes_read > *size {
                        return Err(Error::SeekableIo);
                    }
                }

Replacement in src/lib.rs at line 736 [5.241245]

B:BD[2.812] → [2.812:851]

                            size: len,

[2.812]

[2.851]

                            size: len as usize,

Replacement in src/lib.rs at line 743 [5.241245]

B:BD[3.15305] → [3.15305:15353]

                let prev_out_pos = out_tmp.pos;

[3.15305]

[4.5535]

                let (prev_out_pos, prev_in_pos) = (out_tmp.pos, self.inn.pos);

Replacement in src/lib.rs at line 760 [5.241245]

B:BD[3.16094] → [3.16094:16175]

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

[3.16094]

[3.16175]

                let forward_progress = (out_tmp.pos - prev_out_pos) as u64;
                if forward_progress == 0 {
                    no_output_progress_c += 1;
                    if no_output_progress_c > SEEKABLE_NO_OUTPUT_PROGRESS_MAX {
                        return Err(Error::SeekableIo);
                    }
                } else {
                    no_output_progress_c = 0;
                }
                self.decompressed_offset += forward_progress;
                src_bytes_read += self.inn.pos - prev_in_pos;

Insertion in src/lib.rs at line 783 [5.241245]

[3.16699]

                        // assert!(tgt_frame != self.seek_table.entries.len());

Replacement in src/lib.rs at line 803 [5.241245]
B:BD[3.17340] → [3.17340:17356]
```
        Ok(len)
```
[3.17340]
[3.17356]
```
        Ok(len as usize)
```
Insertion in src/lib.rs at line 815 [5.241245]
[3.17662]
[6.600]
```
        let size = (&input).len();
```

Replacement in src/lib.rs at line 817 [5.241245]

B:BD[6.645] → [6.645:714]

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

[6.645]

[3.17785]

        let mut seekable = Seekable::make_seekable(source, dstream, Some(size));

Replacement in src/lib.rs at line 827 [5.241245]

∅:D[6.1020] → [3.18558:18635]

B:BD[3.18558] → [3.18558:18635]

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

[6.846]

[3.18635]

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

Replacement in src/lib.rs at line 839 [5.241245]

B:BD[5.255716] → [5.255716:255768]

B:BD[5.255768] → [3.18899:18991]

    /// Offset of the frame in the compressed data.
    pub fn get_frame_compressed_offset(&self, frame_index: usize) -> Result<usize, Error> {

[5.255716]

[4.6086]


    #[inline(always)]
    fn get_frame(&'_ self, frame_index: usize) -> Result<&'_ SeekEntry, Error> {

Replacement in src/lib.rs at line 846 [5.241245]

B:BD[3.19110] → [3.19110:19172]

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

[3.19110]

[3.19172]

            Ok(&self.seek_table.entries[frame_index])

Insertion in src/lib.rs at line 848 [5.241245]

[3.19182]

[5.255935]

    }
    /// Offset of the frame in the compressed data.
    pub fn get_frame_compressed_offset(&self, frame_index: usize) -> Result<u64, Error> {
        Ok(self.get_frame(frame_index)?.c_offset)

Replacement in src/lib.rs at line 855 [5.241245]

B:BD[5.255991] → [3.19183:19273]

B:BD[3.19273] → [4.6238:6389]

∅:D[4.6389] → [3.19375:19532]

B:BD[3.19375] → [3.19375:19532]

    pub fn get_frame_compressed_size(&self, frame_index: usize) -> Result<usize, Error> {
        let max_frames = self.get_num_frames();
        if frame_index >= max_frames {
            Err(Error::FIndexTooLarge(frame_index, max_frames))
        } else {
            Ok(self.seek_table.entries[frame_index + 1].c_offset
                - self.seek_table.entries[frame_index].c_offset)
        }

[5.255991]

[5.256162]

    pub fn get_frame_compressed_size(&self, frame_index: usize) -> Result<u64, Error> {
        let entry = self.get_frame(frame_index)?;
        Ok(self.seek_table.entries[frame_index + 1].c_offset - entry.c_offset)

Replacement in src/lib.rs at line 860 [5.241245]

B:BD[5.256222] → [3.19533:19627]

B:BD[3.19627] → [4.6390:6541]

∅:D[4.6541] → [3.19729:19818]

B:BD[3.19729] → [3.19729:19818]

    pub fn get_frame_decompressed_offset(&self, frame_index: usize) -> Result<usize, Error> {
        let max_frames = self.get_num_frames();
        if frame_index >= max_frames {
            Err(Error::FIndexTooLarge(frame_index, max_frames))
        } else {
            Ok(self.seek_table.entries[frame_index].d_offset)
        }

[5.256222]

[5.256390]

    pub fn get_frame_decompressed_offset(&self, frame_index: usize) -> Result<u64, Error> {
        Ok(self.get_frame(frame_index)?.d_offset)

Replacement in src/lib.rs at line 864 [5.241245]

B:BD[5.256448] → [3.19819:19911]

B:BD[3.19911] → [4.6542:6693]

∅:D[4.6693] → [3.20012:20029]

B:BD[3.20012] → [3.20012:20029]

B:BD[3.20029] → [4.6694:6764]

B:BD[4.6764] → [2.1173:1238]

∅:D[2.1238] → [4.6825:6843]

B:BD[4.6825] → [4.6825:6843]

∅:D[4.6843] → [5.257079:257089]

∅:D[3.20159] → [5.257079:257089]

B:BD[5.257079] → [5.257079:257089]

    pub fn get_frame_decompressed_size(&self, frame_index: usize) -> Result<usize, Error> {
        let max_frames = self.get_num_frames();
        if frame_index >= max_frames {
            Err(Error::FIndexTooLarge(frame_index, max_frames))
        } else {
            let r = self.seek_table.entries[frame_index + 1].d_offset
                - self.seek_table.entries[frame_index].d_offset;
            Ok(r)
        }

[5.256448]

[5.257089]

    pub fn get_frame_decompressed_size(&self, frame_index: usize) -> Result<u64, Error> {
        let entry = self.get_frame(frame_index)?;
        Ok(self.seek_table.entries[frame_index + 1].d_offset - entry.d_offset)

Replacement in src/lib.rs at line 870 [5.241245]

B:BD[3.20233] → [3.20233:20319]

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

[3.20233]

[3.20319]

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

Replacement in src/lib.rs at line 878 [5.241245]

B:BD[3.20505] → [3.20505:20577]

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

[3.20505]

[3.20577]

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

Replacement in src/lib.rs at line 1158 [5.241245]

B:BD[5.263511] → [8.63:129]

        let size = s.get_frame_decompressed_size(frame).unwrap();

[5.263511]

[5.263568]

        let size = s.get_frame_decompressed_size(frame).unwrap() as usize;

Replacement in src/lib.rs at line 1161 [5.241245]

B:BD[5.263654] → [4.8594:8724]

        if let Err(_) = s.decompress_frame(&mut decomp[n..], frame) {
            println!("Error in frame {}", frame);
        }

[5.263654]

[5.263707]

        s.decompress_frame(&mut decomp[n..], frame).unwrap();

Replacement in src/lib.rs at line 1199 [5.241245]

B:BD[9.3453] → [9.3453:3519]

        let size = s.get_frame_decompressed_size(frame).unwrap();

[9.3453]

[2.1494]

        let size = s.get_frame_decompressed_size(frame).unwrap() as usize;

Replacement in src/bindings.rs at line 1 [10.1612]

B:BD[10.1612] → [3.26406:26469]

use libc::{c_char, c_int, c_longlong, c_uint, c_void, size_t};

[10.1612]

[11.1346]

use libc::{c_char, c_int, c_uint, c_void, size_t};

Replacement in src/bindings.rs at line 52 [10.1612]

B:BD[11.3576] → [3.26470:26552]

    pub fn ZSTD_resetCStream(zcs: *mut ZSTD_CStream, pledgedSrcSize: c_longlong);

[11.3576]

    pub fn ZSTD_CCtx_reset(cctx: *mut ZSTD_CStream, reset: c_uint) -> size_t;

Replacement in src/bindings.rs at line 66 [10.1612]

B:BD[11.4179] → [3.26553:26617]

    pub fn ZSTD_resetDStream(zds: *mut ZSTD_DStream) -> size_t;

[11.4179]

    pub fn ZSTD_DCtx_reset(dctx: *mut ZSTD_DStream, reset: c_uint) -> size_t;