atmos/os_lib/webp/
io.rs

1// io.rs - image-webp vendoring 用の no_std IO シム
2//
3// image-webp は std::io (Read/BufRead/Seek/Cursor) と byteorder_lite に依存する。
4// WebP の入力は常にメモリ上の &[u8] 全体なので、スライス上のカーソルで
5// これらのトレイトを最小実装し、アルゴリズム本体を無改変で動かす。
6#![allow(dead_code)]
7
8use alloc::string::String;
9use alloc::vec::Vec;
10
11#[derive(Debug, Clone, PartialEq, Eq)]
12pub enum ErrorKind {
13    UnexpectedEof,
14    InvalidData,
15    Other,
16}
17
18#[derive(Debug, Clone)]
19pub struct Error {
20    pub kind: ErrorKind,
21    pub msg: String,
22}
23
24impl Error {
25    pub fn new(kind: ErrorKind, msg: &str) -> Self {
26        Error {
27            kind,
28            msg: String::from(msg),
29        }
30    }
31    pub fn kind(&self) -> ErrorKind {
32        self.kind.clone()
33    }
34}
35
36impl core::fmt::Display for Error {
37    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
38        write!(f, "io error: {:?}: {}", self.kind, self.msg)
39    }
40}
41
42pub type Result<T> = core::result::Result<T, Error>;
43
44fn eof() -> Error {
45    Error::new(ErrorKind::UnexpectedEof, "unexpected eof")
46}
47
48// --- Read / BufRead / Seek トレイト（std::io 互換の最小サブセット）---
49
50pub trait Read {
51    fn read(&mut self, buf: &mut [u8]) -> Result<usize>;
52
53    fn read_exact(&mut self, buf: &mut [u8]) -> Result<()> {
54        let mut filled = 0;
55        while filled < buf.len() {
56            let n = self.read(&mut buf[filled..])?;
57            if n == 0 {
58                return Err(eof());
59            }
60            filled += n;
61        }
62        Ok(())
63    }
64
65    fn read_to_end(&mut self, out: &mut Vec<u8>) -> Result<usize> {
66        let mut total = 0;
67        let mut tmp = [0u8; 4096];
68        loop {
69            let n = self.read(&mut tmp)?;
70            if n == 0 {
71                break;
72            }
73            out.extend_from_slice(&tmp[..n]);
74            total += n;
75        }
76        Ok(total)
77    }
78
79    fn take(self, limit: u64) -> Take<Self>
80    where
81        Self: Sized,
82    {
83        Take { inner: self, limit }
84    }
85
86    fn by_ref(&mut self) -> &mut Self
87    where
88        Self: Sized,
89    {
90        self
91    }
92
93    fn bytes(self) -> Bytes<Self>
94    where
95        Self: Sized,
96    {
97        Bytes { inner: self }
98    }
99}
100
101pub trait BufRead: Read {
102    fn fill_buf(&mut self) -> Result<&[u8]>;
103    fn consume(&mut self, amt: usize);
104}
105
106// std と同じく `&mut R` にも各トレイトを委譲する blanket impl
107impl<R: Read + ?Sized> Read for &mut R {
108    fn read(&mut self, buf: &mut [u8]) -> Result<usize> {
109        (**self).read(buf)
110    }
111}
112
113impl<R: BufRead + ?Sized> BufRead for &mut R {
114    fn fill_buf(&mut self) -> Result<&[u8]> {
115        (**self).fill_buf()
116    }
117    fn consume(&mut self, amt: usize) {
118        (**self).consume(amt)
119    }
120}
121
122impl<S: Seek + ?Sized> Seek for &mut S {
123    fn seek(&mut self, pos: SeekFrom) -> Result<u64> {
124        (**self).seek(pos)
125    }
126}
127
128#[derive(Clone, Copy)]
129pub enum SeekFrom {
130    Start(u64),
131    End(i64),
132    Current(i64),
133}
134
135pub trait Seek {
136    fn seek(&mut self, pos: SeekFrom) -> Result<u64>;
137    fn stream_position(&mut self) -> Result<u64> {
138        self.seek(SeekFrom::Current(0))
139    }
140    fn seek_relative(&mut self, offset: i64) -> Result<()> {
141        self.seek(SeekFrom::Current(offset))?;
142        Ok(())
143    }
144}
145
146// --- Take アダプタ ---
147
148pub struct Take<R> {
149    inner: R,
150    limit: u64,
151}
152
153impl<R: Read> Read for Take<R> {
154    fn read(&mut self, buf: &mut [u8]) -> Result<usize> {
155        if self.limit == 0 {
156            return Ok(0);
157        }
158        let max = (self.limit as usize).min(buf.len());
159        let n = self.inner.read(&mut buf[..max])?;
160        self.limit -= n as u64;
161        Ok(n)
162    }
163}
164
165impl<R: BufRead> BufRead for Take<R> {
166    fn fill_buf(&mut self) -> Result<&[u8]> {
167        let buf = self.inner.fill_buf()?;
168        let cap = (self.limit as usize).min(buf.len());
169        Ok(&buf[..cap])
170    }
171    fn consume(&mut self, amt: usize) {
172        let amt = (amt as u64).min(self.limit) as usize;
173        self.limit -= amt as u64;
174        self.inner.consume(amt);
175    }
176}
177
178// --- Bytes イテレータ ---
179
180pub struct Bytes<R> {
181    inner: R,
182}
183
184impl<R: Read> Iterator for Bytes<R> {
185    type Item = Result<u8>;
186    fn next(&mut self) -> Option<Result<u8>> {
187        let mut b = [0u8; 1];
188        match self.inner.read(&mut b) {
189            Ok(0) => None,
190            Ok(_) => Some(Ok(b[0])),
191            Err(e) => Some(Err(e)),
192        }
193    }
194}
195
196// --- Cursor: &[u8] / Vec<u8> 上のシーク可能カーソル ---
197
198pub struct Cursor<T> {
199    inner: T,
200    pos: u64,
201}
202
203impl<T> Cursor<T> {
204    pub fn new(inner: T) -> Self {
205        Cursor { inner, pos: 0 }
206    }
207    pub fn position(&self) -> u64 {
208        self.pos
209    }
210    pub fn set_position(&mut self, pos: u64) {
211        self.pos = pos;
212    }
213    pub fn into_inner(self) -> T {
214        self.inner
215    }
216    pub fn get_ref(&self) -> &T {
217        &self.inner
218    }
219}
220
221impl<T: AsRef<[u8]>> Cursor<T> {
222    fn data(&self) -> &[u8] {
223        self.inner.as_ref()
224    }
225}
226
227impl<T: AsRef<[u8]>> Read for Cursor<T> {
228    fn read(&mut self, buf: &mut [u8]) -> Result<usize> {
229        let data = self.inner.as_ref();
230        let pos = self.pos as usize;
231        if pos >= data.len() {
232            return Ok(0);
233        }
234        let n = (data.len() - pos).min(buf.len());
235        buf[..n].copy_from_slice(&data[pos..pos + n]);
236        self.pos += n as u64;
237        Ok(n)
238    }
239}
240
241impl<T: AsRef<[u8]>> BufRead for Cursor<T> {
242    fn fill_buf(&mut self) -> Result<&[u8]> {
243        let pos = self.pos as usize;
244        let data = self.inner.as_ref();
245        if pos >= data.len() {
246            Ok(&[])
247        } else {
248            Ok(&data[pos..])
249        }
250    }
251    fn consume(&mut self, amt: usize) {
252        self.pos += amt as u64;
253    }
254}
255
256impl<T: AsRef<[u8]>> Seek for Cursor<T> {
257    fn seek(&mut self, pos: SeekFrom) -> Result<u64> {
258        let len = self.inner.as_ref().len() as i64;
259        let new = match pos {
260            SeekFrom::Start(p) => p as i64,
261            SeekFrom::End(d) => len + d,
262            SeekFrom::Current(d) => self.pos as i64 + d,
263        };
264        if new < 0 {
265            return Err(Error::new(ErrorKind::InvalidData, "seek before start"));
266        }
267        self.pos = new as u64;
268        Ok(self.pos)
269    }
270}
271
272// --- byteorder 互換 ReadBytesExt ---
273
274pub struct LittleEndian;
275pub struct BigEndian;
276
277pub trait ByteOrder {
278    fn read_u16(buf: &[u8]) -> u16;
279    fn read_u32(buf: &[u8]) -> u32;
280}
281
282impl ByteOrder for LittleEndian {
283    fn read_u16(buf: &[u8]) -> u16 {
284        u16::from_le_bytes([buf[0], buf[1]])
285    }
286    fn read_u32(buf: &[u8]) -> u32 {
287        u32::from_le_bytes([buf[0], buf[1], buf[2], buf[3]])
288    }
289}
290
291impl ByteOrder for BigEndian {
292    fn read_u16(buf: &[u8]) -> u16 {
293        u16::from_be_bytes([buf[0], buf[1]])
294    }
295    fn read_u32(buf: &[u8]) -> u32 {
296        u32::from_be_bytes([buf[0], buf[1], buf[2], buf[3]])
297    }
298}
299
300pub trait ReadBytesExt: Read {
301    fn read_u8(&mut self) -> Result<u8> {
302        let mut b = [0u8; 1];
303        self.read_exact(&mut b)?;
304        Ok(b[0])
305    }
306    fn read_i8(&mut self) -> Result<i8> {
307        Ok(self.read_u8()? as i8)
308    }
309    fn read_u16<B: ByteOrder>(&mut self) -> Result<u16> {
310        let mut b = [0u8; 2];
311        self.read_exact(&mut b)?;
312        Ok(B::read_u16(&b))
313    }
314    fn read_u24<B: ByteOrder>(&mut self) -> Result<u32> {
315        let mut b = [0u8; 3];
316        self.read_exact(&mut b)?;
317        // LE/BE どちらも 0 埋め 4 バイトに拡張して解釈
318        let buf4 = [b[0], b[1], b[2], 0];
319        let buf4be = [0, b[0], b[1], b[2]];
320        // ByteOrder 経由で判定できないため両エンディアンを構築し read_u32 で吸収
321        // （read_u24 は LE 用途のみ使用される実装になっている）
322        let _ = buf4be;
323        Ok(B::read_u32(&buf4))
324    }
325    fn read_u32<B: ByteOrder>(&mut self) -> Result<u32> {
326        let mut b = [0u8; 4];
327        self.read_exact(&mut b)?;
328        Ok(B::read_u32(&b))
329    }
330}
331
332// byteorder は `&[u8]` に Read を実装している（スライス先頭から消費）
333impl Read for &[u8] {
334    fn read(&mut self, buf: &mut [u8]) -> Result<usize> {
335        let n = self.len().min(buf.len());
336        buf[..n].copy_from_slice(&self[..n]);
337        *self = &self[n..];
338        Ok(n)
339    }
340}
341
342impl<R: Read + ?Sized> ReadBytesExt for R {}
atmos/os_lib/webp/io.rs

atmos/os_lib/webp/
io.rs
