forked from M-Labs/artiq-zynq
szl: implemented #96
SZL no longer do self-extraction for runtime binary, it would boot from SD/ethernet depending on the boot mode settings. This allows a larger runtime binary, so we can optimize for speed in the runtime firmware for better performance, and allow more features to be added later.netboot
parent
653d143784
commit
ccf8ae5b5d
@ -0,0 +1,399 @@ |
||||
use alloc::vec; |
||||
use alloc::vec::Vec; |
||||
use byteorder::{ByteOrder, NetworkEndian}; |
||||
use core_io::{Read, Seek}; |
||||
use libboard_zynq::{ |
||||
devc, |
||||
eth::Eth, |
||||
smoltcp::{ |
||||
self, |
||||
iface::{EthernetInterfaceBuilder, NeighborCache}, |
||||
time::Instant, |
||||
wire::IpCidr, |
||||
}, |
||||
timer::GlobalTimer, |
||||
}; |
||||
use libconfig::{bootgen, net_settings, Config}; |
||||
|
||||
enum NetConnState { |
||||
WaitCommand, |
||||
FirmwareLength(usize, u8), |
||||
FirmwareDownload(usize, usize), |
||||
FirmwareWaitO, |
||||
FirmwareWaitK, |
||||
GatewareLength(usize, u8), |
||||
GatewareDownload(usize, usize), |
||||
GatewareWaitO, |
||||
GatewareWaitK, |
||||
} |
||||
|
||||
struct NetConn { |
||||
state: NetConnState, |
||||
firmware_downloaded: bool, |
||||
gateware_downloaded: bool, |
||||
} |
||||
|
||||
impl NetConn { |
||||
pub fn new() -> NetConn { |
||||
NetConn { |
||||
state: NetConnState::WaitCommand, |
||||
firmware_downloaded: false, |
||||
gateware_downloaded: false, |
||||
} |
||||
} |
||||
|
||||
pub fn reset(&mut self) { |
||||
self.state = NetConnState::WaitCommand; |
||||
self.firmware_downloaded = false; |
||||
self.gateware_downloaded = false; |
||||
} |
||||
|
||||
fn input_partial<File: Read + Seek>( |
||||
&mut self, |
||||
bootgen_file: &mut Option<File>, |
||||
runtime_start: *mut u8, |
||||
runtime_max_len: usize, |
||||
buf: &[u8], |
||||
storage: &mut Vec<u8>, |
||||
mut boot_callback: impl FnMut(), |
||||
) -> Result<usize, ()> { |
||||
match self.state { |
||||
NetConnState::WaitCommand => match buf[0] { |
||||
b'F' => { |
||||
log::info!("Received firmware load command"); |
||||
self.state = NetConnState::FirmwareLength(0, 0); |
||||
Ok(1) |
||||
} |
||||
b'G' => { |
||||
log::info!("Received gateware load command"); |
||||
self.state = NetConnState::GatewareLength(0, 0); |
||||
storage.clear(); |
||||
Ok(1) |
||||
} |
||||
b'B' => { |
||||
if !self.gateware_downloaded { |
||||
log::info!("Gateware not loaded via netboot"); |
||||
if bootgen_file.is_none() { |
||||
log::error!("No bootgen file to load gateware"); |
||||
return Err(()); |
||||
} |
||||
log::info!("Attempting to load from SD card"); |
||||
if let Err(e) = bootgen::load_bitstream(bootgen_file.as_mut().unwrap()) { |
||||
log::error!("Gateware load failed: {:?}", e); |
||||
return Err(()); |
||||
} |
||||
} |
||||
if self.firmware_downloaded { |
||||
log::info!("Received boot command"); |
||||
boot_callback(); |
||||
self.state = NetConnState::WaitCommand; |
||||
Ok(1) |
||||
} else { |
||||
log::error!("Received boot command, but no firmware downloaded"); |
||||
Err(()) |
||||
} |
||||
} |
||||
_ => { |
||||
log::error!("Received unknown netboot command: 0x{:02x}", buf[0]); |
||||
Err(()) |
||||
} |
||||
}, |
||||
NetConnState::FirmwareLength(firmware_length, recv_bytes) => { |
||||
let firmware_length = (firmware_length << 8) | (buf[0] as usize); |
||||
let recv_bytes = recv_bytes + 1; |
||||
if recv_bytes == 4 { |
||||
if firmware_length > runtime_max_len { |
||||
log::error!( |
||||
"Runtime too large, maximum {} but requested {}", |
||||
runtime_max_len, |
||||
firmware_length |
||||
); |
||||
return Err(()); |
||||
} |
||||
self.state = NetConnState::FirmwareDownload(firmware_length, 0); |
||||
storage.clear(); |
||||
storage.reserve(firmware_length); |
||||
} else { |
||||
self.state = NetConnState::FirmwareLength(firmware_length, recv_bytes); |
||||
} |
||||
Ok(1) |
||||
} |
||||
NetConnState::FirmwareDownload(firmware_length, recv_bytes) => { |
||||
let max_length = firmware_length - recv_bytes; |
||||
let buf = if buf.len() > max_length { |
||||
&buf[..max_length] |
||||
} else { |
||||
&buf[..] |
||||
}; |
||||
let length = buf.len(); |
||||
|
||||
storage.extend_from_slice(buf); |
||||
|
||||
let recv_bytes = recv_bytes + length; |
||||
if recv_bytes == firmware_length { |
||||
self.state = NetConnState::FirmwareWaitO; |
||||
Ok(length) |
||||
} else { |
||||
self.state = NetConnState::FirmwareDownload(firmware_length, recv_bytes); |
||||
Ok(length) |
||||
} |
||||
} |
||||
NetConnState::FirmwareWaitO => { |
||||
if buf[0] == b'O' { |
||||
self.state = NetConnState::FirmwareWaitK; |
||||
Ok(1) |
||||
} else { |
||||
log::error!("End-of-firmware confirmation failed"); |
||||
Err(()) |
||||
} |
||||
} |
||||
NetConnState::FirmwareWaitK => { |
||||
if buf[0] == b'K' { |
||||
log::info!("Firmware successfully downloaded"); |
||||
self.state = NetConnState::WaitCommand; |
||||
self.firmware_downloaded = true; |
||||
{ |
||||
let dest = unsafe { |
||||
core::slice::from_raw_parts_mut(runtime_start, storage.len()) |
||||
}; |
||||
dest.copy_from_slice(storage); |
||||
} |
||||
Ok(1) |
||||
} else { |
||||
log::error!("End-of-firmware confirmation failed"); |
||||
Err(()) |
||||
} |
||||
} |
||||
|
||||
NetConnState::GatewareLength(gateware_length, recv_bytes) => { |
||||
let gateware_length = (gateware_length << 8) | (buf[0] as usize); |
||||
let recv_bytes = recv_bytes + 1; |
||||
if recv_bytes == 4 { |
||||
self.state = NetConnState::GatewareDownload(gateware_length, 0); |
||||
storage.clear(); |
||||
storage.reserve_exact(gateware_length); |
||||
} else { |
||||
self.state = NetConnState::GatewareLength(gateware_length, recv_bytes); |
||||
} |
||||
Ok(1) |
||||
} |
||||
NetConnState::GatewareDownload(gateware_length, recv_bytes) => { |
||||
let max_length = gateware_length - recv_bytes; |
||||
let buf = if buf.len() > max_length { |
||||
&buf[..max_length] |
||||
} else { |
||||
&buf[..] |
||||
}; |
||||
let length = buf.len(); |
||||
|
||||
storage.extend_from_slice(buf); |
||||
|
||||
let recv_bytes = recv_bytes + length; |
||||
if recv_bytes == gateware_length { |
||||
self.state = NetConnState::GatewareWaitO; |
||||
Ok(length) |
||||
} else { |
||||
self.state = NetConnState::GatewareDownload(gateware_length, recv_bytes); |
||||
Ok(length) |
||||
} |
||||
} |
||||
NetConnState::GatewareWaitO => { |
||||
if buf[0] == b'O' { |
||||
self.state = NetConnState::GatewareWaitK; |
||||
Ok(1) |
||||
} else { |
||||
log::error!("End-of-gateware confirmation failed"); |
||||
Err(()) |
||||
} |
||||
} |
||||
NetConnState::GatewareWaitK => { |
||||
if buf[0] == b'K' { |
||||
log::info!("Preprocessing bitstream..."); |
||||
// find sync word 0xFFFFFFFF AA995566
|
||||
let sync_word: [u8; 8] = [0xFF, 0xFF, 0xFF, 0xFF, 0xAA, 0x99, 0x55, 0x66]; |
||||
let mut i = 0; |
||||
let mut state = 0; |
||||
while i < storage.len() { |
||||
if storage[i] == sync_word[state] { |
||||
state += 1; |
||||
if state == sync_word.len() { |
||||
break; |
||||
} |
||||
} else { |
||||
// backtrack
|
||||
// not very efficient but we only have 8 elements
|
||||
'outer: while state > 0 { |
||||
state -= 1; |
||||
for j in 0..state { |
||||
if storage[i - j] != sync_word[state - j] { |
||||
continue 'outer; |
||||
} |
||||
} |
||||
break; |
||||
} |
||||
} |
||||
i += 1; |
||||
} |
||||
if state != sync_word.len() { |
||||
log::error!("Sync word not found in bitstream (corrupted?)"); |
||||
return Err(()); |
||||
} |
||||
// we need the sync word
|
||||
// i was pointing to the last element in the sync sequence
|
||||
i -= sync_word.len() - 1; |
||||
// // append no-op
|
||||
// storage.extend_from_slice(&[0x20, 0, 0, 0]);
|
||||
let bitstream = &mut storage[i..]; |
||||
{ |
||||
// swap endian
|
||||
let swap = unsafe { |
||||
core::slice::from_raw_parts_mut( |
||||
bitstream.as_mut_ptr() as usize as *mut u32, |
||||
bitstream.len() / 4, |
||||
) |
||||
}; |
||||
NetworkEndian::from_slice_u32(swap); |
||||
} |
||||
unsafe { |
||||
// align to 64 bytes
|
||||
let ptr = alloc::alloc::alloc( |
||||
alloc::alloc::Layout::from_size_align(bitstream.len(), 64).unwrap(), |
||||
); |
||||
let buffer = core::slice::from_raw_parts_mut(ptr, bitstream.len()); |
||||
buffer.copy_from_slice(bitstream); |
||||
|
||||
let mut devcfg = devc::DevC::new(); |
||||
devcfg.enable(); |
||||
let result = devcfg.program(&buffer); |
||||
core::ptr::drop_in_place(ptr); |
||||
if let Err(e) = result { |
||||
log::error!("Error during FPGA startup: {}", e); |
||||
return Err(()); |
||||
} |
||||
} |
||||
|
||||
log::info!("Gateware successfully downloaded"); |
||||
self.state = NetConnState::WaitCommand; |
||||
self.gateware_downloaded = true; |
||||
Ok(1) |
||||
} else { |
||||
log::info!("End-of-gateware confirmation failed"); |
||||
Err(()) |
||||
} |
||||
} |
||||
} |
||||
} |
||||
|
||||
fn input<File: Read + Seek>( |
||||
&mut self, |
||||
bootgen_file: &mut Option<File>, |
||||
runtime_start: *mut u8, |
||||
runtime_max_len: usize, |
||||
buf: &[u8], |
||||
storage: &mut Vec<u8>, |
||||
mut boot_callback: impl FnMut(), |
||||
) -> Result<(), ()> { |
||||
let mut remaining = &buf[..]; |
||||
while !remaining.is_empty() { |
||||
let read_cnt = self.input_partial( |
||||
bootgen_file, |
||||
runtime_start, |
||||
runtime_max_len, |
||||
remaining, |
||||
storage, |
||||
&mut boot_callback, |
||||
)?; |
||||
remaining = &remaining[read_cnt..]; |
||||
} |
||||
Ok(()) |
||||
} |
||||
} |
||||
|
||||
pub fn netboot<File: Read + Seek>( |
||||
bootgen_file: &mut Option<File>, |
||||
cfg: Config, |
||||
runtime_start: *mut u8, |
||||
runtime_max_len: usize, |
||||
) { |
||||
log::info!("Preparing network for netboot"); |
||||
let net_addresses = net_settings::get_adresses(&cfg); |
||||
log::info!("Network addresses: {}", net_addresses); |
||||
let eth = Eth::eth0(net_addresses.hardware_addr.0.clone()); |
||||
let eth = eth.start_rx(8); |
||||
let mut eth = eth.start_tx(8); |
||||
|
||||
let mut neighbor_map = [None; 2]; |
||||
let neighbor_cache = NeighborCache::new(&mut neighbor_map[..]); |
||||
let mut ip_addrs = [IpCidr::new(net_addresses.ipv4_addr, 0)]; |
||||
let mut interface = EthernetInterfaceBuilder::new(&mut eth) |
||||
.ethernet_addr(net_addresses.hardware_addr) |
||||
.ip_addrs(&mut ip_addrs[..]) |
||||
.neighbor_cache(neighbor_cache) |
||||
.finalize(); |
||||
|
||||
let mut rx_storage = vec![0; 4096]; |
||||
let mut tx_storage = vec![0; 128]; |
||||
|
||||
let mut socket_set_entries: [_; 1] = Default::default(); |
||||
let mut sockets = smoltcp::socket::SocketSet::new(&mut socket_set_entries[..]); |
||||
|
||||
let tcp_rx_buffer = smoltcp::socket::TcpSocketBuffer::new(&mut rx_storage[..]); |
||||
let tcp_tx_buffer = smoltcp::socket::TcpSocketBuffer::new(&mut tx_storage[..]); |
||||
let tcp_socket = smoltcp::socket::TcpSocket::new(tcp_rx_buffer, tcp_tx_buffer); |
||||
let tcp_handle = sockets.add(tcp_socket); |
||||
|
||||
let mut net_conn = NetConn::new(); |
||||
let mut storage = Vec::new(); |
||||
let mut boot_flag = false; |
||||
let timer = unsafe { GlobalTimer::get() }; |
||||
|
||||
log::info!("Waiting for connections..."); |
||||
loop { |
||||
let timestamp = Instant::from_millis(timer.get_time().0 as i64); |
||||
{ |
||||
let socket = &mut *sockets.get::<smoltcp::socket::TcpSocket>(tcp_handle); |
||||
|
||||
if boot_flag { |
||||
return; |
||||
} |
||||
if !socket.is_open() { |
||||
socket.listen(4269).unwrap() // 0x10ad
|
||||
} |
||||
|
||||
if socket.may_recv() { |
||||
if socket |
||||
.recv(|data| { |
||||
( |
||||
data.len(), |
||||
net_conn |
||||
.input( |
||||
bootgen_file, |
||||
runtime_start, |
||||
runtime_max_len, |
||||
data, |
||||
&mut storage, |
||||
|| { |
||||
boot_flag = true; |
||||
}, |
||||
) |
||||
.is_err(), |
||||
) |
||||
}) |
||||
.unwrap() |
||||
{ |
||||
net_conn.reset(); |
||||
socket.close(); |
||||
} |
||||
} else if socket.may_send() { |
||||
net_conn.reset(); |
||||
socket.close(); |
||||
} |
||||
} |
||||
|
||||
match interface.poll(&mut sockets, timestamp) { |
||||
Ok(_) => (), |
||||
Err(smoltcp::Error::Unrecognized) => (), |
||||
Err(err) => log::error!("Network error: {}", err), |
||||
} |
||||
} |
||||
} |
||||
@ -1,670 +0,0 @@ |
||||
/*
|
||||
*Taken from: Lzma decompressor for Linux kernel. Shamelessly snarfed |
||||
*from busybox 1.1.1 |
||||
* |
||||
*Linux kernel adaptation |
||||
*Copyright (C) 2006 Alain < alain@knaff.lu > |
||||
* |
||||
*Based on small lzma deflate implementation/Small range coder |
||||
*implementation for lzma. |
||||
*Copyright (C) 2006 Aurelien Jacobs < aurel@gnuage.org > |
||||
* |
||||
*Based on LzmaDecode.c from the LZMA SDK 4.22 (http://www.7-zip.org/)
|
||||
*Copyright (C) 1999-2005 Igor Pavlov |
||||
* |
||||
*Copyrights of the parts, see headers below. |
||||
* |
||||
* |
||||
*This program is free software; you can redistribute it and/or |
||||
*modify it under the terms of the GNU Lesser General Public |
||||
*License as published by the Free Software Foundation; either |
||||
*version 2.1 of the License, or (at your option) any later version. |
||||
* |
||||
*This program is distributed in the hope that it will be useful, |
||||
*but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
*MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
||||
*Lesser General Public License for more details. |
||||
* |
||||
*You should have received a copy of the GNU Lesser General Public |
||||
*License along with this library; if not, write to the Free Software |
||||
*Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA |
||||
*/ |
||||
|
||||
#define NULL ((void *)0) |
||||
#define alloca(size) __builtin_alloca(size) |
||||
#define malloc alloca |
||||
static inline void free(void *p) {} |
||||
|
||||
#define MIN(a, b) (((a) < (b)) ? (a) : (b)) |
||||
|
||||
static long long read_int(unsigned char *ptr, int size) |
||||
{ |
||||
int i; |
||||
long long ret = 0; |
||||
|
||||
for (i = 0; i < size; i++) |
||||
ret = (ret << 8) | ptr[size-i-1]; |
||||
return ret; |
||||
} |
||||
|
||||
#define ENDIAN_CONVERT(x) \ |
||||
x = (typeof(x))read_int((unsigned char *)&x, sizeof(x)) |
||||
|
||||
|
||||
/* Small range coder implementation for lzma.
|
||||
*Copyright (C) 2006 Aurelien Jacobs < aurel@gnuage.org > |
||||
* |
||||
*Based on LzmaDecode.c from the LZMA SDK 4.22 (http://www.7-zip.org/)
|
||||
*Copyright (c) 1999-2005 Igor Pavlov |
||||
*/ |
||||
|
||||
#define LZMA_IOBUF_SIZE 0x10000 |
||||
|
||||
struct rc { |
||||
int (*fill)(void*, unsigned int); |
||||
unsigned char *ptr; |
||||
unsigned char *buffer; |
||||
unsigned char *buffer_end; |
||||
int buffer_size; |
||||
unsigned int code; |
||||
unsigned int range; |
||||
unsigned int bound; |
||||
void (*error)(char *); |
||||
}; |
||||
|
||||
|
||||
#define RC_TOP_BITS 24 |
||||
#define RC_MOVE_BITS 5 |
||||
#define RC_MODEL_TOTAL_BITS 11 |
||||
|
||||
|
||||
static int nofill(void *buffer, unsigned int len) |
||||
{ |
||||
return -1; |
||||
} |
||||
|
||||
/* Called twice: once at startup and once in rc_normalize() */ |
||||
static void rc_read(struct rc *rc) |
||||
{ |
||||
rc->buffer_size = rc->fill((char *)rc->buffer, LZMA_IOBUF_SIZE); |
||||
if (rc->buffer_size <= 0) |
||||
rc->error("unexpected EOF"); |
||||
rc->ptr = rc->buffer; |
||||
rc->buffer_end = rc->buffer + rc->buffer_size; |
||||
} |
||||
|
||||
/* Called once */ |
||||
static inline void rc_init(struct rc *rc, |
||||
int (*fill)(void*, unsigned int), |
||||
unsigned char *buffer, int buffer_size) |
||||
{ |
||||
if (fill) |
||||
rc->fill = fill; |
||||
else |
||||
rc->fill = nofill; |
||||
rc->buffer = buffer; |
||||
rc->buffer_size = buffer_size; |
||||
rc->buffer_end = rc->buffer + rc->buffer_size; |
||||
rc->ptr = rc->buffer; |
||||
|
||||
rc->code = 0; |
||||
rc->range = 0xFFFFFFFF; |
||||
} |
||||
|
||||
static inline void rc_init_code(struct rc *rc) |
||||
{ |
||||
int i; |
||||
|
||||
for (i = 0; i < 5; i++) { |
||||
if (rc->ptr >= rc->buffer_end) |
||||
rc_read(rc); |
||||
rc->code = (rc->code << 8) | *rc->ptr++; |
||||
} |
||||
} |
||||
|
||||
|
||||
/* Called twice, but one callsite is in inline'd rc_is_bit_0_helper() */ |
||||
static void rc_do_normalize(struct rc *rc) |
||||
{ |
||||
if (rc->ptr >= rc->buffer_end) |
||||
rc_read(rc); |
||||
rc->range <<= 8; |
||||
rc->code = (rc->code << 8) | *rc->ptr++; |
||||
} |
||||
static inline void rc_normalize(struct rc *rc) |
||||
{ |
||||
if (rc->range < (1 << RC_TOP_BITS)) |
||||
rc_do_normalize(rc); |
||||
} |
||||
|
||||
/* Called 9 times */ |
||||
/* Why rc_is_bit_0_helper exists?
|
||||
*Because we want to always expose (rc->code < rc->bound) to optimizer |
||||
*/ |
||||
static inline unsigned int rc_is_bit_0_helper(struct rc *rc, unsigned short int *p) |
||||
{ |
||||
rc_normalize(rc); |
||||
rc->bound = *p * (rc->range >> RC_MODEL_TOTAL_BITS); |
||||
return rc->bound; |
||||
} |
||||
static inline int rc_is_bit_0(struct rc *rc, unsigned short int *p) |
||||
{ |
||||
unsigned int t = rc_is_bit_0_helper(rc, p); |
||||
return rc->code < t; |
||||
} |
||||
|
||||
/* Called ~10 times, but very small, thus inlined */ |
||||
static inline void rc_update_bit_0(struct rc *rc, unsigned short int *p) |
||||
{ |
||||
rc->range = rc->bound; |
||||
*p += ((1 << RC_MODEL_TOTAL_BITS) - *p) >> RC_MOVE_BITS; |
||||
} |
||||
static inline void rc_update_bit_1(struct rc *rc, unsigned short int *p) |
||||
{ |
||||
rc->range -= rc->bound; |
||||
rc->code -= rc->bound; |
||||
*p -= *p >> RC_MOVE_BITS; |
||||
} |
||||
|
||||
/* Called 4 times in unlzma loop */ |
||||
static int rc_get_bit(struct rc *rc, unsigned short int *p, int *symbol) |
||||
{ |
||||
if (rc_is_bit_0(rc, p)) { |
||||
rc_update_bit_0(rc, p); |
||||
*symbol *= 2; |
||||
return 0; |
||||
} else { |
||||
rc_update_bit_1(rc, p); |
||||
*symbol = *symbol * 2 + 1; |
||||
return 1; |
||||
} |
||||
} |
||||
|
||||
/* Called once */ |
||||
static inline int rc_direct_bit(struct rc *rc) |
||||
{ |
||||
rc_normalize(rc); |
||||
rc->range >>= 1; |
||||
if (rc->code >= rc->range) { |
||||
rc->code -= rc->range; |
||||
return 1; |
||||
} |
||||
return 0; |
||||
} |
||||
|
||||
/* Called twice */ |
||||
static inline void |
||||
rc_bit_tree_decode(struct rc *rc, unsigned short int *p, int num_levels, int *symbol) |
||||
{ |
||||
int i = num_levels; |
||||
|
||||
*symbol = 1; |
||||
while (i--) |
||||
rc_get_bit(rc, p + *symbol, symbol); |
||||
*symbol -= 1 << num_levels; |
||||
} |
||||
|
||||
|
||||
/*
|
||||
* Small lzma deflate implementation. |
||||
* Copyright (C) 2006 Aurelien Jacobs < aurel@gnuage.org > |
||||
* |
||||
* Based on LzmaDecode.c from the LZMA SDK 4.22 (http://www.7-zip.org/)
|
||||
* Copyright (C) 1999-2005 Igor Pavlov |
||||
*/ |
||||
|
||||
|
||||
struct lzma_header { |
||||
unsigned char pos; |
||||
unsigned int dict_size; |
||||
unsigned long long int dst_size; |
||||
} __attribute__ ((packed)) ; |
||||
|
||||
|
||||
#define LZMA_BASE_SIZE 1846 |
||||
#define LZMA_LIT_SIZE 768 |
||||
|
||||
#define LZMA_NUM_POS_BITS_MAX 4 |
||||
|
||||
#define LZMA_LEN_NUM_LOW_BITS 3 |
||||
#define LZMA_LEN_NUM_MID_BITS 3 |
||||
#define LZMA_LEN_NUM_HIGH_BITS 8 |
||||
|
||||
#define LZMA_LEN_CHOICE 0 |
||||
#define LZMA_LEN_CHOICE_2 (LZMA_LEN_CHOICE + 1) |
||||
#define LZMA_LEN_LOW (LZMA_LEN_CHOICE_2 + 1) |
||||
#define LZMA_LEN_MID (LZMA_LEN_LOW \ |
||||
+ (1 << (LZMA_NUM_POS_BITS_MAX + LZMA_LEN_NUM_LOW_BITS))) |
||||
#define LZMA_LEN_HIGH (LZMA_LEN_MID \ |
||||
+(1 << (LZMA_NUM_POS_BITS_MAX + LZMA_LEN_NUM_MID_BITS))) |
||||
#define LZMA_NUM_LEN_PROBS (LZMA_LEN_HIGH + (1 << LZMA_LEN_NUM_HIGH_BITS)) |
||||
|
||||
#define LZMA_NUM_STATES 12 |
||||
#define LZMA_NUM_LIT_STATES 7 |
||||
|
||||
#define LZMA_START_POS_MODEL_INDEX 4 |
||||
#define LZMA_END_POS_MODEL_INDEX 14 |
||||
#define LZMA_NUM_FULL_DISTANCES (1 << (LZMA_END_POS_MODEL_INDEX >> 1)) |
||||
|
||||
#define LZMA_NUM_POS_SLOT_BITS 6 |
||||
#define LZMA_NUM_LEN_TO_POS_STATES 4 |
||||
|
||||
#define LZMA_NUM_ALIGN_BITS 4 |
||||
|
||||
#define LZMA_MATCH_MIN_LEN 2 |
||||
|
||||
#define LZMA_IS_MATCH 0 |
||||
#define LZMA_IS_REP (LZMA_IS_MATCH + (LZMA_NUM_STATES << LZMA_NUM_POS_BITS_MAX)) |
||||
#define LZMA_IS_REP_G0 (LZMA_IS_REP + LZMA_NUM_STATES) |
||||
#define LZMA_IS_REP_G1 (LZMA_IS_REP_G0 + LZMA_NUM_STATES) |
||||
#define LZMA_IS_REP_G2 (LZMA_IS_REP_G1 + LZMA_NUM_STATES) |
||||
#define LZMA_IS_REP_0_LONG (LZMA_IS_REP_G2 + LZMA_NUM_STATES) |
||||
#define LZMA_POS_SLOT (LZMA_IS_REP_0_LONG \ |
||||
+ (LZMA_NUM_STATES << LZMA_NUM_POS_BITS_MAX)) |
||||
#define LZMA_SPEC_POS (LZMA_POS_SLOT \ |
||||
+(LZMA_NUM_LEN_TO_POS_STATES << LZMA_NUM_POS_SLOT_BITS)) |
||||
#define LZMA_ALIGN (LZMA_SPEC_POS \ |
||||
+ LZMA_NUM_FULL_DISTANCES - LZMA_END_POS_MODEL_INDEX) |
||||
#define LZMA_LEN_CODER (LZMA_ALIGN + (1 << LZMA_NUM_ALIGN_BITS)) |
||||
#define LZMA_REP_LEN_CODER (LZMA_LEN_CODER + LZMA_NUM_LEN_PROBS) |
||||
#define LZMA_LITERAL (LZMA_REP_LEN_CODER + LZMA_NUM_LEN_PROBS) |
||||
|
||||
|
||||
struct writer { |
||||
unsigned char *buffer; |
||||
unsigned char previous_byte; |
||||
int buffer_pos; |
||||
int bufsize; |
||||
int global_pos; |
||||
int(*flush)(void*, unsigned int); |
||||
struct lzma_header *header; |
||||
}; |
||||
|
||||
struct cstate { |
||||
int state; |
||||
unsigned int rep0, rep1, rep2, rep3; |
||||
}; |
||||
|
||||
static inline int get_pos(struct writer *wr) |
||||
{ |
||||
return |
||||
wr->global_pos + wr->buffer_pos; |
||||
} |
||||
|
||||
static inline unsigned char peek_old_byte(struct writer *wr, |
||||
unsigned int offs) |
||||
{ |
||||
if (!wr->flush) { |
||||
int pos; |
||||
while (offs > wr->header->dict_size) |
||||
offs -= wr->header->dict_size; |
||||
pos = wr->buffer_pos - offs; |
||||
return wr->buffer[pos]; |
||||
} else { |
||||
unsigned int pos = wr->buffer_pos - offs; |
||||
while (pos >= wr->header->dict_size) |
||||
pos += wr->header->dict_size; |
||||
return wr->buffer[pos]; |
||||
} |
||||
|
||||
} |
||||
|
||||
static inline int write_byte(struct writer *wr, unsigned char byte) |
||||
{ |
||||
wr->buffer[wr->buffer_pos++] = wr->previous_byte = byte; |
||||
if (wr->flush && wr->buffer_pos == wr->header->dict_size) { |
||||
wr->buffer_pos = 0; |
||||
wr->global_pos += wr->header->dict_size; |
||||
if (wr->flush((char *)wr->buffer, wr->header->dict_size) |
||||
!= wr->header->dict_size) |
||||
return -1; |
||||
} |
||||
return 0; |
||||
} |
||||
|
||||
|
||||
static inline int copy_byte(struct writer *wr, unsigned int offs) |
||||
{ |
||||
return write_byte(wr, peek_old_byte(wr, offs)); |
||||
} |
||||
|
||||
static inline int copy_bytes(struct writer *wr, |
||||
unsigned int rep0, int len) |
||||
{ |
||||
do { |
||||
if (copy_byte(wr, rep0)) |
||||
return -1; |
||||
len--; |
||||
} while (len != 0 && wr->buffer_pos < wr->header->dst_size); |
||||
|
||||
return len; |
||||
} |
||||
|
||||
static inline int process_bit0(struct writer *wr, struct rc *rc, |
||||
struct cstate *cst, unsigned short int *p, |
||||
int pos_state, unsigned short int *prob, |
||||
int lc, unsigned int literal_pos_mask) { |
||||
int mi = 1; |
||||
rc_update_bit_0(rc, prob); |
||||
prob = (p + LZMA_LITERAL + |
||||
(LZMA_LIT_SIZE |
||||
* (((get_pos(wr) & literal_pos_mask) << lc) |
||||
+ (wr->previous_byte >> (8 - lc)))) |
||||
); |
||||
|
||||
if (cst->state >= LZMA_NUM_LIT_STATES) { |
||||
int match_byte = peek_old_byte(wr, cst->rep0); |
||||
do { |
||||
int bit; |
||||
unsigned short int *prob_lit; |
||||
|
||||
match_byte <<= 1; |
||||
bit = match_byte & 0x100; |
||||
prob_lit = prob + 0x100 + bit + mi; |
||||
if (rc_get_bit(rc, prob_lit, &mi)) { |
||||
if (!bit) |
||||
break; |
||||
} else { |
||||
if (bit) |
||||
break; |
||||
} |
||||
} while (mi < 0x100); |
||||
} |
||||
while (mi < 0x100) { |
||||
unsigned short int *prob_lit = prob + mi; |
||||
rc_get_bit(rc, prob_lit, &mi); |
||||
} |
||||
if (cst->state < 4) |
||||
cst->state = 0; |
||||
else if (cst->state < 10) |
||||
cst->state -= 3; |
||||
else |
||||
cst->state -= 6; |
||||
|
||||
return write_byte(wr, mi); |
||||
} |
||||
|
||||
static inline int process_bit1(struct writer *wr, struct rc *rc, |
||||
struct cstate *cst, unsigned short int *p, |
||||
int pos_state, unsigned short int *prob) { |
||||
int offset; |
||||
unsigned short int *prob_len; |
||||
int num_bits; |
||||
int len; |
||||
|
||||
rc_update_bit_1(rc, prob); |
||||
prob = p + LZMA_IS_REP + cst->state; |
||||
if (rc_is_bit_0(rc, prob)) { |
||||
rc_update_bit_0(rc, prob); |
||||
cst->rep3 = cst->rep2; |
||||
cst->rep2 = cst->rep1; |
||||
cst->rep1 = cst->rep0; |
||||
cst->state = cst->state < LZMA_NUM_LIT_STATES ? 0 : 3; |
||||
prob = p + LZMA_LEN_CODER; |
||||
} else { |
||||
rc_update_bit_1(rc, prob); |
||||
prob = p + LZMA_IS_REP_G0 + cst->state; |
||||
if (rc_is_bit_0(rc, prob)) { |
||||
rc_update_bit_0(rc, prob); |
||||
prob = (p + LZMA_IS_REP_0_LONG |
||||
+ (cst->state << |
||||
LZMA_NUM_POS_BITS_MAX) + |
||||
pos_state); |
||||
if (rc_is_bit_0(rc, prob)) { |
||||
rc_update_bit_0(rc, prob); |
||||
|
||||
cst->state = cst->state < LZMA_NUM_LIT_STATES ? |
||||
9 : 11; |
||||
return copy_byte(wr, cst->rep0); |
||||
} else { |
||||
rc_update_bit_1(rc, prob); |
||||
} |
||||
} else { |
||||
unsigned int distance; |
||||
|
||||
rc_update_bit_1(rc, prob); |
||||
prob = p + LZMA_IS_REP_G1 + cst->state; |
||||
if (rc_is_bit_0(rc, prob)) { |
||||
rc_update_bit_0(rc, prob); |
||||
distance = cst->rep1; |
||||
} else { |
||||
rc_update_bit_1(rc, prob); |
||||
prob = p + LZMA_IS_REP_G2 + cst->state; |
||||
if (rc_is_bit_0(rc, prob)) { |
||||
rc_update_bit_0(rc, prob); |
||||
distance = cst->rep2; |
||||
} else { |
||||
rc_update_bit_1(rc, prob); |
||||
distance = cst->rep3; |
||||
cst->rep3 = cst->rep2; |
||||
} |
||||
cst->rep2 = cst->rep1; |
||||
} |
||||
cst->rep1 = cst->rep0; |
||||
cst->rep0 = distance; |
||||
} |
||||
cst->state = cst->state < LZMA_NUM_LIT_STATES ? 8 : 11; |
||||
prob = p + LZMA_REP_LEN_CODER; |
||||
} |
||||
|
||||
prob_len = prob + LZMA_LEN_CHOICE; |
||||
if (rc_is_bit_0(rc, prob_len)) { |
||||
rc_update_bit_0(rc, prob_len); |
||||
prob_len = (prob + LZMA_LEN_LOW |
||||
+ (pos_state << |
||||
LZMA_LEN_NUM_LOW_BITS)); |
||||
offset = 0; |
||||
num_bits = LZMA_LEN_NUM_LOW_BITS; |
||||
} else { |
||||
rc_update_bit_1(rc, prob_len); |
||||
prob_len = prob + LZMA_LEN_CHOICE_2; |
||||
if (rc_is_bit_0(rc, prob_len)) { |
||||
rc_update_bit_0(rc, prob_len); |
||||
prob_len = (prob + LZMA_LEN_MID |
||||
+ (pos_state << |
||||
LZMA_LEN_NUM_MID_BITS)); |
||||
offset = 1 << LZMA_LEN_NUM_LOW_BITS; |
||||
num_bits = LZMA_LEN_NUM_MID_BITS; |
||||
} else { |
||||
rc_update_bit_1(rc, prob_len); |
||||
prob_len = prob + LZMA_LEN_HIGH; |
||||
offset = ((1 << LZMA_LEN_NUM_LOW_BITS) |
||||
+ (1 << LZMA_LEN_NUM_MID_BITS)); |
||||
num_bits = LZMA_LEN_NUM_HIGH_BITS; |
||||
} |
||||
} |
||||
|
||||
rc_bit_tree_decode(rc, prob_len, num_bits, &len); |
||||
len += offset; |
||||
|
||||
if (cst->state < 4) { |
||||
int pos_slot; |
||||
|
||||
cst->state += LZMA_NUM_LIT_STATES; |
||||
prob = |
||||
p + LZMA_POS_SLOT + |
||||
((len < |
||||
LZMA_NUM_LEN_TO_POS_STATES ? len : |
||||
LZMA_NUM_LEN_TO_POS_STATES - 1) |
||||
<< LZMA_NUM_POS_SLOT_BITS); |
||||
rc_bit_tree_decode(rc, prob, |
||||
LZMA_NUM_POS_SLOT_BITS, |
||||
&pos_slot); |
||||
if (pos_slot >= LZMA_START_POS_MODEL_INDEX) { |
||||
int i, mi; |
||||
num_bits = (pos_slot >> 1) - 1; |
||||
cst->rep0 = 2 | (pos_slot & 1); |
||||
if (pos_slot < LZMA_END_POS_MODEL_INDEX) { |
||||
cst->rep0 <<= num_bits; |
||||
prob = p + LZMA_SPEC_POS + |
||||
cst->rep0 - pos_slot - 1; |
||||
} else { |
||||
num_bits -= LZMA_NUM_ALIGN_BITS; |
||||
while (num_bits--) |
||||
cst->rep0 = (cst->rep0 << 1) | |
||||
rc_direct_bit(rc); |
||||
prob = p + LZMA_ALIGN; |
||||
cst->rep0 <<= LZMA_NUM_ALIGN_BITS; |
||||
num_bits = LZMA_NUM_ALIGN_BITS; |
||||
} |
||||
i = 1; |
||||
mi = 1; |
||||
while (num_bits--) { |
||||
if (rc_get_bit(rc, prob + mi, &mi)) |
||||
cst->rep0 |= i; |
||||
i <<= 1; |
||||
} |
||||
} else |
||||
cst->rep0 = pos_slot; |
||||
if (++(cst->rep0) == 0) |
||||
return 0; |
||||