ak/rxing
1
0
Fork 0
mirror of https://github.com/starovoid/rxing.git synced 2026-07-27 21:02:35 +00:00
Code Issues Packages Projects Releases Wiki Activity

fix some high level eci parsing

Browse Source
This commit is contained in:
Henry Schimke
2023-01-29 16:07:37 -06:00
parent f38e294481
commit fb8d534f9e
3 changed files with 97 additions and 83 deletions
Download Patch File Download Diff File Expand all files Collapse all files

53
src/common/eci_string_builder.rs
View File

@@ -107,8 +107,9 @@ impl ECIStringBuilder {
self.encodeCurrentBytesIfAny(); self.encodeCurrentBytesIfAny();
if let Ok(character_set_eci) = CharacterSetECI::getCharacterSetECIByValue(value) { if let Ok(character_set_eci) = CharacterSetECI::getCharacterSetECIByValue(value) {
dbg!(character_set_eci, CharacterSetECI::getCharset(&character_set_eci).name(), CharacterSetECI::getCharset(&character_set_eci).whatwg_name());
self.current_charset = Some(CharacterSetECI::getCharset(&character_set_eci)); self.current_charset = Some(CharacterSetECI::getCharset(&character_set_eci));
}else { } else {
self.current_charset = None self.current_charset = None
} }
@@ -118,35 +119,35 @@ impl ECIStringBuilder {
pub fn encodeCurrentBytesIfAny(&mut self) { pub fn encodeCurrentBytesIfAny(&mut self) {
if let Some(encoder) = self.current_charset { if let Some(encoder) = self.current_charset {
if encoder.name() == encoding::all::UTF_8.name() { if encoder.name() == encoding::all::UTF_8.name() {
if !self.current_bytes.is_empty() { if !self.current_bytes.is_empty() {
// if result == null { // if result == null {
// result = currentBytes; // result = currentBytes;
// currentBytes = new StringBuilder(); // currentBytes = new StringBuilder();
// } else { // } else {
self.result self.result
.push_str(&String::from_utf8(self.current_bytes.clone()).unwrap()); .push_str(&String::from_utf8(std::mem::take(&mut self.current_bytes)).unwrap());
self.current_bytes.clear();
// }
}
} else if !self.current_bytes.is_empty() {
let bytes = std::mem::take(&mut self.current_bytes);
self.current_bytes.clear(); self.current_bytes.clear();
// } // if (result == null) {
// result = new StringBuilder(new String(bytes, currentCharset));
// } else {
let encoded_value = encoder
.decode(&bytes, encoding::DecoderTrap::Strict)
.unwrap();
self.result.push_str(&encoded_value);
// }
}
} else {
for byte in &self.current_bytes {
self.result.push(char::from(*byte))
} }
} else if !self.current_bytes.is_empty() {
let bytes = self.current_bytes.clone();
self.current_bytes.clear(); self.current_bytes.clear();
// if (result == null) {
// result = new StringBuilder(new String(bytes, currentCharset));
// } else {
let encoded_value = encoder
.decode(&bytes, encoding::DecoderTrap::Replace)
.unwrap();
self.result.push_str(&encoded_value);
// }
} }
}else {
for byte in &self.current_bytes {
self.result.push(char::from(*byte))
}
self.current_bytes.clear();
}
} }
/** /**

124
src/datamatrix/decoder/decoded_bit_stream_parser.rs
View File

@@ -121,30 +121,43 @@ pub fn decode(bytes: &[u8]) -> Result<DecoderRXingResult, Exceptions> {
let symbologyModifier; let symbologyModifier;
let mut isECIencoded = false; let mut isECIencoded = false;
loop { loop {
if mode == Mode::ASCII_ENCODE { match mode {
mode = decodeAsciiSegment( Mode::ASCII_ENCODE => {
&mut bits, mode = decodeAsciiSegment(
&mut result, &mut bits,
&mut resultTrailer, &mut result,
&mut fnc1Positions, &mut resultTrailer,
)?; &mut fnc1Positions,
} else { )?
match mode { }
Mode::C40_ENCODE => decodeC40Segment(&mut bits, &mut result, &mut fnc1Positions)?, Mode::C40_ENCODE => {
Mode::TEXT_ENCODE => decodeTextSegment(&mut bits, &mut result, &mut fnc1Positions)?, decodeC40Segment(&mut bits, &mut result, &mut fnc1Positions)?;
Mode::ANSIX12_ENCODE => decodeAnsiX12Segment(&mut bits, &mut result)?, mode = Mode::ASCII_ENCODE;
Mode::EDIFACT_ENCODE => decodeEdifactSegment(&mut bits, &mut result)?, }
Mode::BASE256_ENCODE => { Mode::TEXT_ENCODE => {
decodeBase256Segment(&mut bits, &mut result, &mut byteSegments)? decodeTextSegment(&mut bits, &mut result, &mut fnc1Positions)?;
} mode = Mode::ASCII_ENCODE;
Mode::ECI_ENCODE => { }
decodeECISegment(&mut bits, &mut result)?; Mode::ANSIX12_ENCODE => {
isECIencoded = true; // ECI detection only, atm continue decoding as ASCII decodeAnsiX12Segment(&mut bits, &mut result)?;
} mode = Mode::ASCII_ENCODE;
_ => return Err(Exceptions::FormatException(None)), }
}; Mode::EDIFACT_ENCODE => {
mode = Mode::ASCII_ENCODE; decodeEdifactSegment(&mut bits, &mut result)?;
mode = Mode::ASCII_ENCODE;
}
Mode::BASE256_ENCODE => {
decodeBase256Segment(&mut bits, &mut result, &mut byteSegments)?;
mode = Mode::ASCII_ENCODE;
}
Mode::ECI_ENCODE => {
decodeECISegment(&mut bits, &mut result)?;
isECIencoded = true; // ECI detection only, atm continue decoding as ASCII
mode = Mode::ASCII_ENCODE;
}
_ => return Err(Exceptions::FormatException(None)),
} }
if !(mode != Mode::PAD_ENCODE && bits.available() > 0) { if !(mode != Mode::PAD_ENCODE && bits.available() > 0) {
break; break;
} }
@@ -200,31 +213,29 @@ fn decodeAsciiSegment(
let mut sai = StructuredAppendInfo::default(); let mut sai = StructuredAppendInfo::default();
loop { loop {
let mut oneByte = bits.readBits(8)?; let mut oneByte = bits.readBits(8)?;
if oneByte == 0 { match oneByte {
return Err(Exceptions::FormatException(None)); 0 => return Err(Exceptions::FormatException(None)),
} else if oneByte <= 128 { 1..=128 => {
// ASCII data (ASCII value + 1) // ASCII data (ASCII value + 1)
if upperShift { if upperShift {
oneByte += 128; oneByte += 128;
//upperShift = false; //upperShift = false;
} }
result.append_char(char::from_u32(oneByte - 1).unwrap()); result.append_char(char::from_u32(oneByte - 1).unwrap());
return Ok(Mode::ASCII_ENCODE); return Ok(Mode::ASCII_ENCODE);
} else if oneByte == 129 { },
// Pad 129 => return Ok(Mode::PAD_ENCODE), // Pad
return Ok(Mode::PAD_ENCODE); 129..=229 => {
} else if oneByte <= 229 { // 2-digit data 00-99 (Numeric Value + 130)
// 2-digit data 00-99 (Numeric Value + 130) let value = oneByte - 130;
let value = oneByte - 130; if value < 10 {
if value < 10 { // pad with '0' for single digit values
// pad with '0' for single digit values result.append_char('0');
result.append_char('0'); }
} //result.append_char(char::from_u32(value).unwrap());
//result.append_char(char::from_u32(value).unwrap()); result.append_string(&format!("{value}"));
result.append_string(&format!("{value}")); },
} else { 230=> // Latch to C40 encodation
match oneByte {
230=> // Latch to C40 encodation
return Ok(Mode::C40_ENCODE), return Ok(Mode::C40_ENCODE),
231=> // Latch to Base 256 encodation 231=> // Latch to Base 256 encodation
return Ok(Mode::BASE256_ENCODE), return Ok(Mode::BASE256_ENCODE),
@@ -237,16 +248,17 @@ fn decodeAsciiSegment(
{fnc1positions.push(result.len()); {fnc1positions.push(result.len());
result.append_char( 29 as char); }// translate as ASCII 29 result.append_char( 29 as char); }// translate as ASCII 29
}, },
233| // Structured Append 233 => // Structured Append
{
if !firstCodeword // Must be first ISO 16022:2006 5.6.1
{return Err(Exceptions::FormatException(Some("structured append tag must be first code word".to_owned())));}
parse_structured_append(bits, &mut sai)?;
firstFNC1Position = 5;
},
234=> // Reader Programming 234=> // Reader Programming
// Ignore these symbols for now // Ignore these symbols for now
//throw ReaderException.getInstance(); //throw ReaderException.getInstance();
{ {},
if !firstCodeword // Must be first ISO 16022:2006 5.6.1
{return Err(Exceptions::FormatException(Some("structured append tag must be first code word".to_owned())));}
parse_structured_append(bits, &mut sai)?;
firstFNC1Position = 5;
},
235=> // Upper Shift (shift to Extended ASCII) 235=> // Upper Shift (shift to Extended ASCII)
upperShift = true, upperShift = true,
236=> {// 05 Macro 236=> {// 05 Macro
@@ -274,7 +286,7 @@ fn decodeAsciiSegment(
return Err(Exceptions::FormatException(None)) return Err(Exceptions::FormatException(None))
}}, }},
} }
}
if bits.available() == 0 { if bits.available() == 0 {
break; break;
} }

1
test_resources/blackbox/datamatrix-1/eci-mixed.txt Normal file
View File

@@ -0,0 +1 @@
á¡¡ĦĦͱ𐌶@@@@@@@@@@_