Codecs & performance values

emCompress-PRO includes well-defined, commonly used compression codecs. All codecs are implemented according to their specification or RFC, which enables interoperability with other tools and libraries.

DEFLATE

DEFLATE is the lossless compression stream format originally developed for and with the ZIP file format. It uses a combination of LZ77 and Huffman coding. DEFLATE is specified in RFC 1951.

LZMA (Lempel–Ziv–Markov chain algorithm) is the lossless compression algorithm which was first used in the 7z file format. This algorithm uses a dictionary compression scheme similar to the LZ77 algorithm and features a high compression ratio and a variable compression-dictionary size, while still maintaining decompression speed similar to other commonly used compression algorithms.

LZJU90 defines the transfer encoding for MIME compliant mail systems. It uses prefix coding of a length and distance that leaves literals uncompressed.

LZPJ is the "plain jane" implementation of LZ77.

[1]  Uncompressed input size: 182.695 KB

[2]  ns/Byte on Intel i7 @ 4.6GHz, only for comparison between codecs

API use

emCompress-PRO provides a simple zlib-like API, for incremental process of input. This interface enables the use of compression and decompression of data on the fly. It can be used to process data in chunks as they are received from a remote system instead of requiring that all data be available at once. It can also be used to process data and output chunks into a small buffer for further processing instead of requiring a large output buffer that can hold all of the  compressed or decompressed data at once. Chunk-wise input and output can be combined to ensure minimum memory buffer requirements.

Code example

/*********************************************************************
*
*       Decompress()
*
*  Function description
*    Decompress DEFLATE or LZMA blocks.
*
*  Parameters
*    pFile  - Pointer to input file.
*    pAPI   - Pointer to decompression API.
*    pParas - Pointer to decompression parameters.
*    Size   - Size of data to decompress.
*/
void Decompress(FILE* pFile, const CX_DECODE_API* pAPI, const CX_PARAS* pParas, int Size) {
  CX_DECODE_CONTEXT C;
  CX_STREAM         Stream;
  int               Status;
  U8                ByteIn;
  U8                ByteOut;
  //
  // Prepare decoder and stream.
  //
  Stream.AvailIn  = 0;
  Stream.AvailOut = 0;
  Status = CX_DECODE_Init(&C, pAPI, &_StaticAllocator, pParas);
  //
  for (;;) {
    //
    // Read next byte from input.
    //
    if (Stream.AvailIn == 0 && Size > 0) {
      fread(&ByteIn, 1, 1, pFile);
      Stream.pIn     = &ByteIn;
      Stream.AvailIn = 1;
      Size--;
    }
    //
    // Reset output buffer.
    //
    Stream.pOut     = &ByteOut;
    Stream.AvailOut = 1;
    //
    // Process stream.
    //
    Status = CX_DECODE_Process(&C, &Stream, Size == 0 ? CX_FLUSH_END : CX_FLUSH_NONE);
    if (Status < 0) {
      printf("Failed to decode: %s\n", CX_GetErrorText(Status));
      exit(100);
    }
    if (Status == 1) {
      break;
    }
  }
  //
  CX_DECODE_Exit(&C);
}

Use cases

emCompress-PRO is the allround solution for compression and decompression.

Speed up firmware updates

Modern products, in particular IoT devices, require the ability to update their firmware in the field. Most of these devices implement over-the-air (OTA) updates through their main communication channel. When a device is connected via WiFi, available bandwidth is not an issue, but other channels such as Bluetooth or Zigbee might have limited bandwidth. Also, updates via wired connections often have bandwidth restrictions, e.g. the popular CAN bus.

To speed up the update process, lossless compression of firmware images reduces the amount of data to be transferred to the device. emCompress-PRO enables firmware updates with compressed images. Its interface is suited to receive a compressed data stream and to decompress it on the fly for the update module, which processes the decompressed data afterward.

Learn more at:
https://casestudies.segger.com/size-matters-using-emcompress-to-accelerate-firmware-updates-via-can-bus/

Minimize the required memory footprint for asset storage

Most systems include digital assets for their user interface. Assets can be images, videos and fonts for a graphical user interface (GUI) on a display, sound files to be output on a speaker, web pages for a web or app interface, or any other static data. Storage space for static data, such as an external flash, can be limited. To fit more data into available memory, or even to design hardware with smaller memory, digital assets can be stored in compressed form.

emCompress-PRO enables on-demand decompression of data when it is needed. Data can be decompressed into small chunks so the entire asset doesn’t have to be held in memory before being deployed.

Process data provided by third-party compression tools

Connected devices might receive compressed data from external sources. When a device does not include its own software to manage such data, the system might need to be designed to process data created by third-party tools.

emCompress-PRO implements popular codecs, such as DEFLATE and LZMA, which provides compatibility with commonly used compression tools. A system receiving external data can select the decompressor on demand making it ready for most customer use cases.

Data is not always compressed  in a single block but may be packaged in an archive. While emCompress-PRO implements compression codecs, it also comes with sample code to handle and process common archive formats. An input archive stream can be decompressed into structured files when a file system like emFile is used.

Compress data on different kinds of targets

Most use cases require decompression on the target system. Compression of data can be done with off-the-shelf tools, such as the popular zip file archiver, or integrated in a tool or framework which also creates the data, such as a firmware update utility.

Besides data decompression emCompress-PRO provides compression functionality as well and is not limited to embedded targets. Both parts of the codecs are written in plain C and can be integrated in firmware images as well as host applications.