jbig2enc

https://docs.rs/jbig2enc/0.1.1
Admin
jbig2enc is a Rust implementation of a JBIG2 encoder for bi-level images that achieves superior...
Tokens:5,978
Snippets:94
Trust Score:9.1
Update:5 months ago
Show doc for...
Tokens:
Raw
### Multi-Page Symbol Mode Encoding

Source: https://docs.rs/jbig2enc/0.1.1/index.html

This example demonstrates multi-page encoding using symbol mode. It involves initializing a context, adding pages, and then producing the encoded page data.

```rust
use jbig2enc::encoder::Jbig2Context;
use leptonica::io::read_image;

let mut ctx = Jbig2Context::new(0.92, 0.5, 300, 300, true, -1).unwrap();
let page = read_image("page1.png").unwrap();
ctx.add_page(&page).unwrap();

let symbol_table = ctx.pages_complete().unwrap();
let page_data = ctx.produce_page(0, None, None).unwrap();
```

--------------------------------

### Deprecated Error Description for Jbig2Error

Source: https://docs.rs/jbig2enc/0.1.1/jbig2enc/error/enum.Jbig2Error.html

Deprecated method for getting a string description of the error. Use the Display implementation or to_string() instead.

```rust
fn description(&self) -> &str
```

--------------------------------

### Deprecated Error Cause for Jbig2Error

Source: https://docs.rs/jbig2enc/0.1.1/jbig2enc/error/enum.Jbig2Error.html

Deprecated method for getting the underlying error cause. Replaced by Error::source.

```rust
fn cause(&self) -> Option<&dyn Error>
```

--------------------------------

### type_id Method

Source: https://docs.rs/jbig2enc/0.1.1/jbig2enc/wire/struct.TextRegionSymInsts.html

Gets the TypeId of the current instance. This is a generic implementation provided by the Any trait.

```rust
fn type_id(&self) -> TypeId
```

--------------------------------

### deref Method

Source: https://docs.rs/jbig2enc/0.1.1/jbig2enc/wire/struct.TextRegionSymInsts.html

Dereferences the given pointer to get an immutable reference. This is an unsafe generic method provided by the Pointable trait.

```rust
unsafe fn deref<'a>(ptr: usize) -> &'a T
```

--------------------------------

### deref_mut Method

Source: https://docs.rs/jbig2enc/0.1.1/jbig2enc/wire/struct.TextRegionSymInsts.html

Mutably dereferences the given pointer to get a mutable reference. This is an unsafe generic method provided by the Pointable trait.

```rust
unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T
```

--------------------------------

### init Method

Source: https://docs.rs/jbig2enc/0.1.1/jbig2enc/wire/struct.TextRegionSymInsts.html

Initializes an object with the given initializer. This is an unsafe generic method provided by the Pointable trait.

```rust
unsafe fn init(init: <T as Pointable>::Init) -> usize
```

--------------------------------

### try_into Method

Source: https://docs.rs/jbig2enc/0.1.1/jbig2enc/encoder/struct.Jbig2Context.html

Performs the conversion from one type to another, returning a Result.

```APIDOC
## fn try_into

### Description
Performs the conversion.

### Signature
```rust
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
```

### Returns
A `Result` which is either the converted type `U` on success, or an error type on failure.
```

--------------------------------

### from Method

Source: https://docs.rs/jbig2enc/0.1.1/jbig2enc/wire/struct.TextRegionSymInsts.html

Returns the argument unchanged. This is a generic implementation provided by the From trait.

```rust
fn from(t: T) -> T
```

--------------------------------

### Nightly-Only Experimental API for Jbig2Error

Source: https://docs.rs/jbig2enc/0.1.1/jbig2enc/error/enum.Jbig2Error.html

Provides type-based access to context for error reports. This is a nightly-only experimental API.

```rust
fn provide<'a>(&'a self, request: &mut Request<'a>)
```

--------------------------------

### Display Implementation for Jbig2Error

Source: https://docs.rs/jbig2enc/0.1.1/jbig2enc/error/enum.Jbig2Error.html

Provides a human-readable string representation for Jbig2Error variants. This is the recommended way to display errors.

```rust
fn fmt(&self, f: &mut Formatter<'_>) -> Result
```

--------------------------------

### Hash-Accelerated Symbol Class Unification

Source: https://docs.rs/jbig2enc/0.1.1/src/jbig2enc/encoder/context.rs.html

Optimizes symbol class unification by using a hash table to group templates. It first calculates a hash for each template based on its properties (holes, height, width) and then performs comparisons only within buckets, significantly improving performance over the brute-force method.

```rust
    pub fn auto_threshold_using_hash(&mut self) {
        if self.classer.pixat.is_empty() {
            return;
        }

        // Phase 1: ハッシュバケット構築
        let mut buckets: HashMap<u32, Vec<usize>> = HashMap::new();
        for (i, pix) in self.classer.pixat.iter().enumerate() {
            let holes = match pix_count_components(pix, ConnectivityType::FourWay) {
                Ok(count) => count,
                Err(_) => {
                    // 連結成分数を取得できないテンプレートはバケットに入れない。
                    // Phase 2 の比較対象から外れるため、統合されずに残る。
                    continue;
                }
            };
            let w = pix.width();
            let h = pix.height();
            let hash = (holes + 10 * h + 10000 * w) % 10_000_000;
            buckets.entry(hash).or_default().push(i);
        }
    }
```

--------------------------------

### TryInto<U> for T

Source: https://docs.rs/jbig2enc/0.1.1/jbig2enc/arith/struct.ArithEncoder.html

Provides the `try_into` method for converting between types that implement `TryFrom`.

```APIDOC
## impl<T, U> TryInto<U> for T
where U: TryFrom<T>

### Associated Types
#### type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

### Methods
#### fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
```

--------------------------------

### Single-Page Lossless Encoding (Generic Region)

Source: https://docs.rs/jbig2enc/0.1.1/index.html

Use this for single-page lossless encoding in generic region mode. Requires reading an image and writing the encoded data to a file.

```rust
use jbig2enc::encoder::encode_generic;
use leptonica::io::read_image;

let pix = read_image("input.png").unwrap();
let data = encode_generic(&pix, true, 300, 300, false).unwrap();
std::fs::write("output.jbig2", &data).unwrap();
```

--------------------------------

### impl TextRegionSymInsts

Source: https://docs.rs/jbig2enc/0.1.1/jbig2enc/wire/struct.TextRegionSymInsts.html

Implementation of methods for the TextRegionSymInsts struct.

```APIDOC
## impl TextRegionSymInsts

### pub fn to_bytes(&self) -> Vec<u8>
Converts the TextRegionSymInsts struct into a byte vector.
```

--------------------------------

### into Method

Source: https://docs.rs/jbig2enc/0.1.1/jbig2enc/wire/struct.TextRegionSymInsts.html

Calls U::from(self). This is a generic implementation provided by the Into trait.

```rust
fn into(self) -> U
```

--------------------------------

### JBIG2 Comparator Success Return

Source: https://docs.rs/jbig2enc/0.1.1/src/jbig2enc/comparator/mod.rs.html

Indicates that all comparator checks have passed without detecting any issues. Returns Ok(true) signifying successful comparison.

```rust
Ok(true)
}
```

--------------------------------

### Brute-force Symbol Class Unification

Source: https://docs.rs/jbig2enc/0.1.1/src/jbig2enc/encoder/context.rs.html

Unifies visually equivalent symbol classes by comparing all template pairs using a brute-force O(n²) approach. This method is suitable when the number of templates is small.

```rust
    pub fn auto_threshold(&mut self) {
        let mut i = 0;
        while i < self.classer.pixat.len() {
            let mut j = i + 1;
            while j < self.classer.pixat.len() {
                let equivalent =
                    are_equivalent(&self.classer.pixat[i], &self.classer.pixat[j]).unwrap_or(false);

                if equivalent {
                    unite_and_remove(
                        &mut self.classer.pixat,
                        &mut self.classer.naclass,
                        &mut self.classer.nclass,
                        i,
                        j,
                    );
                    // j 位置に新しい要素が来ているのでインクリメントしない
                } else {
                    j += 1;
                }
            }
            i += 1;
        }
    }
```

--------------------------------

### ToString Implementation for Generic Types

Source: https://docs.rs/jbig2enc/0.1.1/jbig2enc/error/enum.Jbig2Error.html

Converts a value to a String. This is a blanket implementation for any type that implements Display.

```rust
fn to_string(&self) -> String
```

--------------------------------

### TryInto Implementation for Generic Types

Source: https://docs.rs/jbig2enc/0.1.1/jbig2enc/error/enum.Jbig2Error.html

Performs a fallible conversion from one type to another. The Error type is determined by the TryFrom implementation.

```rust
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
```

--------------------------------

### to_bytes Method Implementation

Source: https://docs.rs/jbig2enc/0.1.1/jbig2enc/wire/struct.TextRegionSymInsts.html

Converts the TextRegionSymInsts struct into a byte vector. This method is part of the TextRegionSymInsts implementation.

```rust
pub fn to_bytes(&self) -> Vec<u8>
```

--------------------------------

### Error Source Implementation for Jbig2Error

Source: https://docs.rs/jbig2enc/0.1.1/jbig2enc/error/enum.Jbig2Error.html

Returns the lower-level source of this error, if any. Useful for error chaining.

```rust
fn source(&self) -> Option<&(dyn Error + 'static)>
```

--------------------------------

### Generate Text Region Segment

Source: https://docs.rs/jbig2enc/0.1.1/src/jbig2enc/encoder/context.rs.html

Constructs and appends a JBIG2 immediate text region segment to the output. This includes segment header, text region data, symbol instances, and text data. It also handles optional End of Page and End of File segments based on configuration.

```rust
        let textreg_bytes = textreg.to_bytes();

        let textreg_syminsts = TextRegionSymInsts {
            sbnuminstances: comps.len() as u32,
        };
        let syminsts_bytes = textreg_syminsts.to_bytes();

        let textreg_data_length =
            textreg_bytes.len() as u32 + syminsts_bytes.len() as u32 + text_data.len() as u32;

        let mut referred_to = vec![symtab_seg];
        if has_extra_symtab {
            referred_to.push(extra_symtab_seg_num);
        }

        let seg_textreg = SegmentHeader {
            number: self.segnum,
            seg_type: SEGMENT_IMM_TEXT_REGION,
            deferred_non_retain: false,
            retain_bits: 2,
            referred_to,
            page: page_assoc,
            data_length: textreg_data_length,
        };
        self.segnum += 1;

        output.extend_from_slice(&seg_textreg.to_bytes());
        output.extend_from_slice(&textreg_bytes);
        output.extend_from_slice(&syminsts_bytes);
        output.extend_from_slice(&text_data);

        // ---- End of Page（full_headers時のみ）----
        if self.full_headers {
            let seg_eop = SegmentHeader {
                number: self.segnum,
                seg_type: SEGMENT_END_OF_PAGE,
                deferred_non_retain: false,
                retain_bits: 0,
                referred_to: vec![],
                page: page_assoc,
                data_length: 0,
            };
            self.segnum += 1;
            output.extend_from_slice(&seg_eop.to_bytes());
        }

        // ---- End of File（最終ページ + full_headers時）----
        if include_trailer {
            let seg_eof = SegmentHeader {
                number: self.segnum,
                seg_type: SEGMENT_END_OF_FILE,
                deferred_non_retain: false,
                retain_bits: 0,
                referred_to: vec![],
                page: 0,
                data_length: 0,
            };
            self.segnum += 1;
            output.extend_from_slice(&seg_eof.to_bytes());
        }

        Ok(output)
```

--------------------------------

### Re-exporting Arithmetic Coding Components

Source: https://docs.rs/jbig2enc/0.1.1/src/jbig2enc/arith/mod.rs.html

This snippet re-exports public items from submodules, making them accessible at the top level of the 'arith' module. It includes the ArithEncoder, IntProc, and StateEntry, along with the global STATE_TABLE.

```rust
1mod encoder;
2mod image;
3mod int_encode;
4mod state_table;
5
6pub use encoder::ArithEncoder;
7pub use int_encode::IntProc;
8pub use state_table::STATE_TABLE;
9pub use state_table::StateEntry;

```

--------------------------------

### Public API of arith module

Source: https://docs.rs/jbig2enc/0.1.1/src/jbig2enc/arith/mod.rs.html

This section lists the public items re-exported from the arith module, which are available for direct use by library consumers.

```APIDOC
pub use encoder::ArithEncoder;
pub use int_encode::IntProc;
pub use state_table::STATE_TABLE;
pub use state_table::StateEntry;
```

--------------------------------

### TextRegionSymInsts struct

Source: https://docs.rs/jbig2enc/0.1.1/jbig2enc/wire/struct.TextRegionSymInsts.html

Represents the number of instances of symbols in a JBIG2 text region. Corresponds to the C++ version `jbig2_text_region_syminsts`.

```APIDOC
## Struct TextRegionSymInsts

### Summary
```
pub struct TextRegionSymInsts {
    pub sbnuminstances: u32,
}
```

### Description
JBIG2テキストリージョンシンボルインスタンス数（4バイト）。
C++版 `jbig2_text_region_syminsts` に対応。

### Fields
* `sbnuminstances: u32` - The number of instances of symbols in a JBIG2 text region (4 bytes).
```

--------------------------------

### TryFrom Implementation for Generic Types

Source: https://docs.rs/jbig2enc/0.1.1/jbig2enc/error/enum.Jbig2Error.html

Performs a fallible conversion from one type to another. The Error type is Infallible, meaning the conversion always succeeds.

```rust
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
```

--------------------------------

### Detect Vertical Lines in JBIG2 Data

Source: https://docs.rs/jbig2enc/0.1.1/src/jbig2enc/comparator/mod.rs.html

Iterates through parsed image data to detect potential vertical lines based on a threshold. Returns Ok(false) if a line is detected.

```rust
for i in 0..DIVIDER - 1 {
        for j in 0..DIVIDER * 2 - 1 {
            let mut sum: i64 = 0;
            for x in 0..2 {
                for y in 0..2 {
                    sum += v_parsed[i + x][j + y] as i64;
                }
            }
            if sum >= vline_thresh {
                return Ok(false);
            }
        }
    }
```

--------------------------------

### Detect Concentrated Differences in JBIG2 Data

Source: https://docs.rs/jbig2enc/0.1.1/src/jbig2enc/comparator/mod.rs.html

Scans parsed data for concentrated differences using a threshold. Returns Ok(false) if the sum of a 2x2 block exceeds the point threshold.

```rust
for i in 0..DIVIDER - 1 {
        for j in 0..DIVIDER - 1 {
            let mut sum: f64 = 0.0;
            for x in 0..2 {
                for y in 0..2 {
                    sum += parsed[i + x][j + y] as f64;
                }
            }
            if sum >= point_thresh {
                return Ok(false);
            }
        }
    }
```

--------------------------------

### into_either Method

Source: https://docs.rs/jbig2enc/0.1.1/jbig2enc/wire/struct.TextRegionSymInsts.html

Converts self into a Left or Right variant of Either based on the into_left flag. This is a generic implementation provided by the IntoEither trait.

```rust
fn into_either(self, into_left: bool) -> Either<Self, Self>
```

--------------------------------

### into_either_with Method

Source: https://docs.rs/jbig2enc/0.1.1/jbig2enc/wire/struct.TextRegionSymInsts.html

Converts self into a Left or Right variant of Either based on a closure's boolean return value. This is a generic implementation provided by the IntoEither trait.

```rust
fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where F: FnOnce(&Self) -> bool,
```

--------------------------------

### SEGMENT_PAGE_INFORMATION Constant

Source: https://docs.rs/jbig2enc/0.1.1/jbig2enc/wire/constant.SEGMENT_PAGE_INFORMATION.html

Defines the byte value for the Page Information segment in JBIG2 encoding. This constant is used to identify this specific segment type during data processing.

```rust
pub const SEGMENT_PAGE_INFORMATION: u8 = 48;
```

--------------------------------

### borrow Method

Source: https://docs.rs/jbig2enc/0.1.1/jbig2enc/wire/struct.TextRegionSymInsts.html

Immutably borrows from an owned value. This is a generic implementation provided by the Borrow trait.

```rust
fn borrow(&self) -> &T
```

--------------------------------

### ALIGN Constant

Source: https://docs.rs/jbig2enc/0.1.1/jbig2enc/wire/struct.TextRegionSymInsts.html

The alignment of the pointer. This is a generic constant provided by the Pointable trait.

```rust
const ALIGN: usize
```

--------------------------------

### Exported Items from Encoder Module

Source: https://docs.rs/jbig2enc/0.1.1/src/jbig2enc/encoder/mod.rs.html

This snippet shows the public items re-exported from the encoder module, making them available for external use. It includes context-related types and functions.

```rust
1mod context;
2mod generic;

3pub use context::{Jbig2Context, log2up};
4pub use generic::encode_generic;

```

--------------------------------

### Detect Crossing Lines in JBIG2 Data

Source: https://docs.rs/jbig2enc/0.1.1/src/jbig2enc/comparator/mod.rs.html

Analyzes parsed data for crossing lines by summing diagonal elements. Returns Ok(false) if either left or right diagonal sum exceeds the threshold.

```rust
for i in 0..DIVIDER - 2 {
        for j in 0..DIVIDER - 2 {
            let mut left_cross: i64 = 0;
            let mut right_cross: i64 = 0;
            for x in 0..3 {
                for y in 0..3 {
                    if x == y {
                        left_cross += parsed[i + x][j + y] as i64;
                    }
                    if (2 - x) == y {
                        right_cross += parsed[i + x][j + y] as i64;
                    }
                }
            }
            if left_cross >= hline_thresh || right_cross >= hline_thresh {
                return Ok(false);
            }
        }
    }
```

--------------------------------

### Error Type

Source: https://docs.rs/jbig2enc/0.1.1/jbig2enc/encoder/struct.Jbig2Context.html

Defines the type returned when a conversion error occurs.

```APIDOC
## type Error

### Description
The type returned in the event of a conversion error.

### Type Definition
```rust
type Error = <U as TryFrom<T>>::Error
```
```

--------------------------------

### Define Jbig2Error Enum and Implement Display

Source: https://docs.rs/jbig2enc/0.1.1/src/jbig2enc/error.rs.html

Defines a custom error enum `Jbig2Error` with an `InvalidInput` variant. Implements the `fmt::Display` trait to provide a human-readable string representation of the error, and `std::error::Error` for standard Rust error handling.

```rust
use std::fmt;

#[derive(Debug)]
pub enum Jbig2Error {
    InvalidInput(String),
}

impl fmt::Display for Jbig2Error {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Jbig2Error::InvalidInput(msg) => write!(f, "invalid input: {msg}"),
        }
    }
}

impl std::error::Error for Jbig2Error {}
```

--------------------------------

### Re-export public items from wire submodules

Source: https://docs.rs/jbig2enc/0.1.1/src/jbig2enc/wire/mod.rs.html

This snippet re-exports public items from the constants, segment, and structs submodules. It makes these items available through the top-level wire module.

```rust
1mod constants;
2mod segment;
3mod structs;
4
5pub use constants::*;
6pub use segment::*;
7pub use structs::*;
```

--------------------------------

### SEGMENT_IMM_TEXT_REGION Constant Definition

Source: https://docs.rs/jbig2enc/0.1.1/jbig2enc/wire/constant.SEGMENT_IMM_TEXT_REGION.html

Defines the constant value for the Immediate Text Region segment type. This is used in JBIG2 encoding.

```rust
pub const SEGMENT_IMM_TEXT_REGION: u8 = 6;
```

--------------------------------

### Re-export Symbol Table and Text Region Encoding Functions

Source: https://docs.rs/jbig2enc/0.1.1/src/jbig2enc/symbol/mod.rs.html

This snippet re-exports essential types and functions for encoding symbol tables and text regions. It is used to make these functionalities publicly available from the symbol module.

```rust
pub use dictionary::{SymbolTableResult, encode_symbol_table};
pub use text_region::{SymbolInstance, TextRegionConfig, TextRegionResult, encode_text_region};
```

--------------------------------

### TextRegionSymInsts Struct Definition

Source: https://docs.rs/jbig2enc/0.1.1/jbig2enc/wire/struct.TextRegionSymInsts.html

Defines the TextRegionSymInsts struct, which holds the count of symbol instances in a text region. This is a direct representation of the C++ equivalent.

```rust
pub struct TextRegionSymInsts {
    pub sbnuminstances: u32,
}
```

--------------------------------

### drop Method

Source: https://docs.rs/jbig2enc/0.1.1/jbig2enc/wire/struct.TextRegionSymInsts.html

Drops the object pointed to by the given pointer. This is an unsafe generic method provided by the Pointable trait.

```rust
unsafe fn drop(ptr: usize)
```

--------------------------------

### borrow_mut Method

Source: https://docs.rs/jbig2enc/0.1.1/jbig2enc/wire/struct.TextRegionSymInsts.html

Mutably borrows from an owned value. This is a generic implementation provided by the BorrowMut trait.

```rust
fn borrow_mut(&mut self) -> &mut T
```

--------------------------------

### SEGMENT_END_OF_FILE Constant Definition

Source: https://docs.rs/jbig2enc/0.1.1/jbig2enc/wire/constant.SEGMENT_END_OF_FILE.html

Defines the byte value for the SEGMENT_END_OF_FILE marker. This constant is used to signify the end of a JBIG2 file stream.

```rust
pub const SEGMENT_END_OF_FILE: u8 = 51;
```

--------------------------------

### Error Type for TryInto

Source: https://docs.rs/jbig2enc/0.1.1/jbig2enc/wire/struct.TextRegionSymInsts.html

Defines the error type for conversions that may fail. This is a generic associated type provided by the TryInto trait.

```rust
type Error = <U as TryFrom<T>>::Error
```

--------------------------------

### Define SEGMENT_END_OF_PAGE Constant

Source: https://docs.rs/jbig2enc/0.1.1/jbig2enc/wire/constant.SEGMENT_END_OF_PAGE.html

This constant represents the byte value used to mark the end of a page segment in the JBIG2 encoding stream. It is a fundamental part of the wire protocol for segmenting page data.

```rust
pub const SEGMENT_END_OF_PAGE: u8 = 49;
```

--------------------------------

### Error Type for TryFrom

Source: https://docs.rs/jbig2enc/0.1.1/jbig2enc/wire/struct.TextRegionSymInsts.html

Defines the error type for conversions that may fail. This is a generic associated type provided by the TryFrom trait.

```rust
type Error = Infallible
```

--------------------------------

### SEGMENT_IMM_GENERIC_REGION Constant

Source: https://docs.rs/jbig2enc/0.1.1/jbig2enc/wire/constant.SEGMENT_IMM_GENERIC_REGION.html

This constant defines the segment type identifier for an immediate generic region in JBIG2 encoding. It is used to specify the type of data that follows in the encoded stream.

```rust
pub const SEGMENT_IMM_GENERIC_REGION: u8 = 38;
```

--------------------------------

### Jbig2Error Enum Definition

Source: https://docs.rs/jbig2enc/0.1.1/jbig2enc/error/enum.Jbig2Error.html

Defines the Jbig2Error enum with a variant for invalid input, which carries a String describing the error.

```rust
pub enum Jbig2Error {
    InvalidInput(String),
}
```

--------------------------------

### Jbig2Error Enum Definition

Source: https://docs.rs/jbig2enc/0.1.1/jbig2enc/error/enum.Jbig2Error.html

Defines the Jbig2Error enum, which includes a variant for invalid input that carries a string message.

```APIDOC
## Enum Jbig2Error

```rust
pub enum Jbig2Error {
    InvalidInput(String),
}
```

### Variants

#### InvalidInput(String)

Represents an error due to invalid input data, with an associated error message.
```

--------------------------------

### SEGMENT_END_OF_FILE Constant

Source: https://docs.rs/jbig2enc/0.1.1/jbig2enc/wire/constant.SEGMENT_END_OF_FILE.html

The SEGMENT_END_OF_FILE constant is a u8 value representing the end-of-file marker in the JBIG2 file format. It is used to signify the termination of the data stream.

```APIDOC
## Constant SEGMENT_END_OF_FILE

### Summary

```rust
pub const SEGMENT_END_OF_FILE: u8 = 51;
```

### Description

The `SEGMENT_END_OF_FILE` constant is defined as `51` (decimal) and is of type `u8`. It serves as a marker to indicate the end of a JBIG2 file or data stream.
```
Tokens:
Raw