/*

 * LZFSE (un)compression functions

 *

 * Copyright (C) 2019-2026, Joachim Metz <joachim.metz@gmail.com>

 *

 * Refer to AUTHORS for acknowledgements.

 *

 * 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 3 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 General Public License for more details.

 *

 * You should have received a copy of the GNU Lesser General Public License

 * along with this program.  If not, see <https://www.gnu.org/licenses/>.

 */

#include <common.h>

#include <byte_stream.h>

#include <memory.h>

#include <types.h>

#include "libfmos_definitions.h"

#include "libfmos_libcerror.h"

#include "libfmos_libcnotify.h"

#include "libfmos_lzfse.h"

#include "libfmos_lzfse_bit_stream.h"

#include "libfmos_lzfse_decoder.h"

#include "libfmos_lzvn.h"

const uint8_t libfmos_lzfse_frequency_number_of_bits_table[ 32 ] = {

      2, 3, 2, 5, 2, 3, 2, 8, 2, 3, 2, 5, 2, 3, 2, 14,

      2, 3, 2, 5, 2, 3, 2, 8, 2, 3, 2, 5, 2, 3, 2, 14 };

const uint16_t libfmos_lzfse_frequency_value_table[ 32 ] = {

      0, 2, 1, 4, 0, 3, 1, 0xffff, 0, 2, 1, 5, 0, 3, 1, 0xffff,

      0, 2, 1, 6, 0, 3, 1, 0xffff, 0, 2, 1, 7, 0, 3, 1, 0xffff };

const uint8_t libfmos_lzfse_d_value_bits_table[ LIBFMOS_LZFSE_NUMBER_OF_D_VALUE_SYMBOLS ] = {

  0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3,

  4, 4, 4, 4, 5, 5, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7,

  8, 8, 8, 8, 9, 9, 9, 9, 10, 10, 10, 10, 11, 11, 11, 11,

  12, 12, 12, 12, 13, 13, 13, 13, 14, 14, 14, 14, 15, 15, 15, 15 };

const int32_t libfmos_lzfse_d_value_base_table[ LIBFMOS_LZFSE_NUMBER_OF_D_VALUE_SYMBOLS ] = {

  0, 1, 2, 3, 4, 6, 8, 10, 12, 16, 20, 24, 28, 36, 44, 52,

        60, 76, 92, 108, 124, 156, 188, 220, 252, 316, 380, 444, 508, 636, 764, 892,

        1020, 1276, 1532, 1788, 2044, 2556, 3068, 3580, 4092, 5116, 6140, 7164, 8188, 10236, 12284, 14332,

        16380, 20476, 24572, 28668, 32764, 40956, 49148, 57340, 65532, 81916, 98300, 114684, 131068, 163836, 196604, 229372 };

const uint8_t libfmos_lzfse_l_value_bits_table[ LIBFMOS_LZFSE_NUMBER_OF_L_VALUE_SYMBOLS ] = {

  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

  2, 3, 5, 8 };

const int32_t libfmos_lzfse_l_value_base_table[ LIBFMOS_LZFSE_NUMBER_OF_L_VALUE_SYMBOLS ] = {

  0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,

        16, 20, 28, 60 };

const uint8_t libfmos_lzfse_m_value_bits_table[ LIBFMOS_LZFSE_NUMBER_OF_M_VALUE_SYMBOLS ] = {

  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

        3, 5, 8, 11 };

const int32_t libfmos_lzfse_m_value_base_table[ LIBFMOS_LZFSE_NUMBER_OF_M_VALUE_SYMBOLS ] = {

  0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,

        16, 24, 56, 312 };

#if defined( _MSC_VER )

#if defined( _M_ARM ) || defined( _M_ARM64 )

#define libfmos_lzfse_count_leading_zeros( value, result ) \

  result = 32; \

  if ( value > 0 ) { \

    unsigned long bit_index = 0; \

    _BitScanReverse( &bit_index, (unsigned int) value ); \

    result -= bit_index + 1; \

  }

#else

#define libfmos_lzfse_count_leading_zeros( value, result ) \

  result = (int) __lzcnt( (unsigned int) value )

#endif /* defined( _M_ARM ) || defined( _M_ARM64 ) */

#else

#define libfmos_lzfse_count_leading_zeros( value, result ) \

  result = (int) __builtin_clz( (unsigned int) value )

#endif /* defined( _MSC_VER ) */

/* Builds a decoder table

 * Returns 1 on success or -1 on error

 */

int libfmos_lzfse_build_decoder_table(

     int number_of_states,

     uint16_t number_of_symbols,

     const uint16_t *frequency_table,

     libfmos_lzfse_decoder_entry_t *decoder_table,

     libcerror_error_t **error )

{

  libfmos_lzfse_decoder_entry_t *decoder_entry = NULL;

  static char *function                        = "libfmos_lzfse_build_decoder_table";

  uint16_t symbol                              = 0;

  int16_t delta                                = 0;

  int base_decoder_weight                      = 0;

  int decoder_weight                           = 0;

  int decoder_table_index                      = 0;

  int frequency                                = 0;

  int number_of_bits                           = 0;

  int number_of_leading_zeros                  = 0;

  int sum_of_frequencies                       = 0;

  if( number_of_symbols > 256 )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_ARGUMENTS,

     LIBCERROR_ARGUMENT_ERROR_VALUE_OUT_OF_BOUNDS,

     "%s: invalid number of symbols value out of bounds.",

     function );

    return( -1 );

  }

  if( frequency_table == NULL )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_ARGUMENTS,

     LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,

     "%s: invalid frequency table.",

     function );

    return( -1 );

  }

  if( decoder_table == NULL )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_ARGUMENTS,

     LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,

     "%s: invalid decoder table.",

     function );

    return( -1 );

  }

  libfmos_lzfse_count_leading_zeros(

   number_of_states,

   number_of_leading_zeros );

  for( symbol = 0;

       symbol < number_of_symbols;

       symbol++ )

  {

    frequency = frequency_table[ symbol ];

    /* 0 occurrences of the symbol

     */

    if( frequency == 0 )

    {

      continue;

    }

    sum_of_frequencies += frequency;

    if( sum_of_frequencies > number_of_states )

    {

      libcerror_error_set(

       error,

       LIBCERROR_ERROR_DOMAIN_RUNTIME,

       LIBCERROR_RUNTIME_ERROR_VALUE_OUT_OF_BOUNDS,

       "%s: invalid sum of frequencies value out of bounds.",

       function );

      return( -1 );

    }

    libfmos_lzfse_count_leading_zeros(

     frequency,

     number_of_bits );

    number_of_bits -= number_of_leading_zeros;

    base_decoder_weight = ( ( 2 * number_of_states ) >> number_of_bits ) - frequency;

    for( decoder_weight = 0;

         decoder_weight < frequency;

         decoder_weight++ )

    {

      decoder_entry = &( decoder_table[ decoder_table_index++ ] );

      decoder_entry->number_of_bits = (int8_t) number_of_bits;

      decoder_entry->symbol         = (uint8_t) symbol;

      if( decoder_weight < base_decoder_weight )

      {

        delta = (int16_t) ( ( ( frequency + decoder_weight ) << number_of_bits ) - number_of_states );

      }

      else

      {

        decoder_entry->number_of_bits -= 1;

        delta = (int16_t) ( ( decoder_weight - base_decoder_weight ) << ( number_of_bits - 1 ) );

      }

      decoder_entry->delta = delta;

    }

  }

  return( 1 );

}

/* Builds a value decoder table

 * Returns 1 on success or -1 on error

 */

int libfmos_lzfse_build_value_decoder_table(

     int number_of_states,

     uint16_t number_of_symbols,

     const uint16_t *frequency_table,

     const uint8_t *value_bits_table,

     const int32_t *value_base_table,

     libfmos_lzfse_value_decoder_entry_t *value_decoder_table,

     libcerror_error_t **error )

{

  libfmos_lzfse_value_decoder_entry_t *value_decoder_entry = NULL;

  static char *function                                    = "libfmos_lzfse_build_value_decoder_table";

  int32_t value_base                                       = 0;

  uint16_t symbol                                          = 0;

  int16_t delta                                            = 0;

  uint8_t value_bits                                       = 0;

  int base_decoder_weight                                  = 0;

  int decoder_weight                                       = 0;

  int decoder_table_index                                  = 0;

  int frequency                                            = 0;

  int number_of_bits                                       = 0;

  int number_of_leading_zeros                              = 0;

  int sum_of_frequencies                                   = 0;

  if( number_of_symbols > 256 )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_ARGUMENTS,

     LIBCERROR_ARGUMENT_ERROR_VALUE_OUT_OF_BOUNDS,

     "%s: invalid number of symbols value out of bounds.",

     function );

    return( -1 );

  }

  if( frequency_table == NULL )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_ARGUMENTS,

     LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,

     "%s: invalid frequency table.",

     function );

    return( -1 );

  }

  if( value_bits_table == NULL )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_ARGUMENTS,

     LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,

     "%s: invalid value bits table.",

     function );

    return( -1 );

  }

  if( value_base_table == NULL )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_ARGUMENTS,

     LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,

     "%s: invalid value base table.",

     function );

    return( -1 );

  }

  if( value_decoder_table == NULL )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_ARGUMENTS,

     LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,

     "%s: invalid value decoder table.",

     function );

    return( -1 );

  }

  libfmos_lzfse_count_leading_zeros(

   number_of_states,

   number_of_leading_zeros );

  for( symbol = 0;

       symbol < number_of_symbols;

       symbol++ )

  {

    frequency = frequency_table[ symbol ];

    /* 0 occurrences of the symbol

     */

    if( frequency == 0 )

    {

      continue;

    }

    sum_of_frequencies += frequency;

    if( sum_of_frequencies > number_of_states )

    {

      libcerror_error_set(

       error,

       LIBCERROR_ERROR_DOMAIN_RUNTIME,

       LIBCERROR_RUNTIME_ERROR_VALUE_OUT_OF_BOUNDS,

       "%s: invalid sum of frequencies value out of bounds.",

       function );

      return( -1 );

    }

    libfmos_lzfse_count_leading_zeros(

     frequency,

     number_of_bits );

          number_of_bits -= number_of_leading_zeros;

    base_decoder_weight = ( ( 2 * number_of_states ) >> number_of_bits ) - frequency;

    value_bits = value_bits_table[ symbol ];

    value_base = value_base_table[ symbol ];

    for( decoder_weight = 0;

         decoder_weight < frequency;

         decoder_weight++ )

    {

      value_decoder_entry = &( value_decoder_table[ decoder_table_index++ ] );

      value_decoder_entry->value_bits     = value_bits;

      value_decoder_entry->value_base     = value_base;

      value_decoder_entry->value_bitmask  = ( (uint32_t) 1UL << value_bits ) - 1;

      value_decoder_entry->number_of_bits = (uint8_t) ( number_of_bits + value_bits );

      if( decoder_weight < base_decoder_weight )

      {

        delta = (int16_t) ( ( ( frequency + decoder_weight ) << number_of_bits ) - number_of_states );

      }

      else

      {

        value_decoder_entry->number_of_bits -= 1;

        delta = (int16_t) ( ( decoder_weight - base_decoder_weight ) << ( number_of_bits - 1 ) );

      }

      value_decoder_entry->delta = delta;

    }

  }

  return( 1 );

}

/* Reads a LZFSE compressed block header with uncompressed tables (version 1)

 * Returns 1 on success or -1 on error

 */

int libfmos_lzfse_read_block_v1_header(

     libfmos_lzfse_decoder_t *decoder,

     const uint8_t *compressed_data,

     size_t compressed_data_size,

     size_t *compressed_data_offset,

     uint16_t *frequency_table,

     libcerror_error_t **error )

{

  static char *function              = "libfmos_lzfse_read_block_v1_header";

  size_t safe_compressed_data_offset = 0;

  uint32_t literal_bits              = 0;

  uint32_t lmd_values_bits           = 0;

  uint16_t table_index               = 0;

  uint8_t literal_decoder_index      = 0;

#if defined( HAVE_DEBUG_OUTPUT )

  uint32_t compressed_block_size     = 0;

#endif

  if( decoder == NULL )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_ARGUMENTS,

     LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,

     "%s: invalid decoder.",

     function );

    return( -1 );

  }

  if( compressed_data == NULL )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_ARGUMENTS,

     LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,

     "%s: invalid compressed data.",

     function );

    return( -1 );

  }

  if( ( compressed_data_size < 762 )

   || ( compressed_data_size > (size_t) SSIZE_MAX ) )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_ARGUMENTS,

     LIBCERROR_ARGUMENT_ERROR_VALUE_OUT_OF_BOUNDS,

     "%s: invalid compressed data size value out of bounds.",

     function );

    return( -1 );

  }

  if( compressed_data_offset == NULL )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_ARGUMENTS,

     LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,

     "%s: invalid compressed data offset.",

     function );

    return( -1 );

  }

  safe_compressed_data_offset = *compressed_data_offset;

  if( safe_compressed_data_offset > ( compressed_data_size - 762 ) )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_RUNTIME,

     LIBCERROR_RUNTIME_ERROR_VALUE_OUT_OF_BOUNDS,

     "%s: invalid compressed data offset value out of bounds.",

     function );

    return( -1 );

  }

  if( frequency_table == NULL )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_ARGUMENTS,

     LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,

     "%s: invalid frequency table.",

     function );

    return( -1 );

  }

#if defined( HAVE_DEBUG_OUTPUT )

  if( libcnotify_verbose != 0 )

  {

    libcnotify_printf(

     "%s: v1 block header data:\n",

     function );

    libcnotify_print_data(

     &( compressed_data[ safe_compressed_data_offset ] ),

     762,

     0 );

  }

#endif

#if defined( HAVE_DEBUG_OUTPUT )

  byte_stream_copy_to_uint32_little_endian(

   &( compressed_data[ safe_compressed_data_offset ] ),

   compressed_block_size );

#endif

  safe_compressed_data_offset += 4;

  byte_stream_copy_to_uint32_little_endian(

   &( compressed_data[ safe_compressed_data_offset ] ),

   decoder->number_of_literals );

  safe_compressed_data_offset += 4;

  byte_stream_copy_to_uint32_little_endian(

   &( compressed_data[ safe_compressed_data_offset ] ),

   decoder->number_of_lmd_values );

  safe_compressed_data_offset += 4;

  byte_stream_copy_to_uint32_little_endian(

   &( compressed_data[ safe_compressed_data_offset ] ),

   decoder->literals_data_size );

  safe_compressed_data_offset += 4;

  byte_stream_copy_to_uint32_little_endian(

   &( compressed_data[ safe_compressed_data_offset ] ),

   decoder->lmd_values_data_size );

  safe_compressed_data_offset += 4;

  byte_stream_copy_to_uint32_little_endian(

   &( compressed_data[ safe_compressed_data_offset ] ),

   literal_bits );

  safe_compressed_data_offset += 4;

  for( literal_decoder_index = 0;

       literal_decoder_index < 4;

       literal_decoder_index++ )

  {

    byte_stream_copy_to_uint16_little_endian(

     &( compressed_data[ safe_compressed_data_offset ] ),

     decoder->literal_states[ literal_decoder_index ] );

    safe_compressed_data_offset += 2;

  }

  byte_stream_copy_to_uint32_little_endian(

   &( compressed_data[ safe_compressed_data_offset ] ),

   lmd_values_bits );

  safe_compressed_data_offset += 4;

  byte_stream_copy_to_uint16_little_endian(

   &( compressed_data[ safe_compressed_data_offset ] ),

   decoder->l_value_state );

  safe_compressed_data_offset += 2;

  byte_stream_copy_to_uint16_little_endian(

   &( compressed_data[ safe_compressed_data_offset ] ),

   decoder->m_value_state );

  safe_compressed_data_offset += 2;

  byte_stream_copy_to_uint16_little_endian(

   &( compressed_data[ safe_compressed_data_offset ] ),

   decoder->d_value_state );

  safe_compressed_data_offset += 2;

  for( table_index = 0;

       table_index < 360;

       table_index++ )

  {

    byte_stream_copy_to_uint16_little_endian(

     &( compressed_data[ safe_compressed_data_offset ] ),

     frequency_table[ table_index ] );

    safe_compressed_data_offset += 2;

  }

#if defined( HAVE_DEBUG_OUTPUT )

  if( libcnotify_verbose != 0 )

  {

    libcnotify_printf(

     "%s: compressed block size\t\t: %" PRIu32 "\n",

     function,

     compressed_block_size );

    libcnotify_printf(

     "%s: number of literals\t\t\t: %" PRIu32 "\n",

     function,

     decoder->number_of_literals );

    libcnotify_printf(

     "%s: number of L, M, D values\t\t: %" PRIu32 "\n",

     function,

     decoder->number_of_lmd_values );

    libcnotify_printf(

     "%s: literals data size\t\t\t: %" PRIu32 "\n",

     function,

     decoder->literals_data_size );

    libcnotify_printf(

     "%s: L, M, D values data size\t\t: %" PRIu32 "\n",

     function,

     decoder->lmd_values_data_size );

    libcnotify_printf(

     "%s: literal_bits\t\t\t: %" PRIi32 "\n",

     function,

     (int32_t) literal_bits );

    for( literal_decoder_index = 0;

         literal_decoder_index < 4;

         literal_decoder_index++ )

    {

      libcnotify_printf(

       "%s: literal_state[ %" PRIu8 " ]\t\t\t: %" PRIu16 "\n",

       function,

       literal_decoder_index,

       decoder->literal_states[ literal_decoder_index ] );

    }

    libcnotify_printf(

     "%s: lmd_values_bits\t\t\t: %" PRIi32 "\n",

     function,

     (int32_t) lmd_values_bits );

    libcnotify_printf(

     "%s: L value state\t\t\t: %" PRIu16 "\n",

     function,

     decoder->l_value_state );

    libcnotify_printf(

     "%s: M value state\t\t\t: %" PRIu16 "\n",

     function,

     decoder->m_value_state );

    libcnotify_printf(

     "%s: D value state\t\t\t: %" PRIu16 "\n",

     function,

     decoder->d_value_state );

    for( table_index = 0;

         table_index < 360;

         table_index++ )

    {

      if( frequency_table[ table_index ] != 0 )

      {

        libcnotify_printf(

         "%s: frequency table: %d value\t\t: %" PRIu16 "\n",

         function,

         table_index,

         frequency_table[ table_index ] );

      }

    }

    libcnotify_printf(

     "\n" );

  }

#endif /* defined( HAVE_DEBUG_OUTPUT ) */

  decoder->literal_bits    = (int32_t) literal_bits;

  decoder->lmd_values_bits = (int32_t) lmd_values_bits;

  *compressed_data_offset = safe_compressed_data_offset;

  return( 1 );

}

/* Reads a LZFSE compressed block header with compressed tables (version 2)

 * Returns 1 on success or -1 on error

 */

int libfmos_lzfse_read_block_v2_header(

     libfmos_lzfse_decoder_t *decoder,

     const uint8_t *compressed_data,

     size_t compressed_data_size,

     size_t *compressed_data_offset,

     uint16_t *frequency_table,

     libcerror_error_t **error )

{

  static char *function              = "libfmos_lzfse_read_block_v2_header";

  size_t safe_compressed_data_offset = 0;

  uint64_t packed_fields1            = 0;

  uint64_t packed_fields2            = 0;

  uint64_t packed_fields3            = 0;

  uint32_t header_size               = 0;

#if defined( HAVE_DEBUG_OUTPUT )

  uint16_t table_index               = 0;

  uint8_t literal_decoder_index      = 0;

#endif

  if( decoder == NULL )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_ARGUMENTS,

     LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,

     "%s: invalid decoder.",

     function );

    return( -1 );

  }

  if( compressed_data == NULL )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_ARGUMENTS,

     LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,

     "%s: invalid compressed data.",

     function );

    return( -1 );

  }

  if( ( compressed_data_size < 24 )

   || ( compressed_data_size > (size_t) SSIZE_MAX ) )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_ARGUMENTS,

     LIBCERROR_ARGUMENT_ERROR_VALUE_OUT_OF_BOUNDS,

     "%s: invalid compressed data size value out of bounds.",

     function );

    return( -1 );

  }

  if( compressed_data_offset == NULL )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_ARGUMENTS,

     LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,

     "%s: invalid compressed data offset.",

     function );

    return( -1 );

  }

  safe_compressed_data_offset = *compressed_data_offset;

  if( safe_compressed_data_offset > ( compressed_data_size - 24 ) )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_RUNTIME,

     LIBCERROR_RUNTIME_ERROR_VALUE_OUT_OF_BOUNDS,

     "%s: invalid compressed data offset value out of bounds.",

     function );

    return( -1 );

  }

  if( frequency_table == NULL )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_ARGUMENTS,

     LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,

     "%s: invalid frequency table.",

     function );

    return( -1 );

  }

#if defined( HAVE_DEBUG_OUTPUT )

  if( libcnotify_verbose != 0 )

  {

    libcnotify_printf(

     "%s: v2 block header data:\n",

     function );

    libcnotify_print_data(

     &( compressed_data[ safe_compressed_data_offset ] ),

     24,

     0 );

  }

#endif

  byte_stream_copy_to_uint64_little_endian(

   &( compressed_data[ safe_compressed_data_offset ] ),

   packed_fields1 );

  safe_compressed_data_offset += 8;

  byte_stream_copy_to_uint64_little_endian(

   &( compressed_data[ safe_compressed_data_offset ] ),

   packed_fields2 );

  safe_compressed_data_offset += 8;

  byte_stream_copy_to_uint64_little_endian(

   &( compressed_data[ safe_compressed_data_offset ] ),

   packed_fields3 );

  safe_compressed_data_offset += 8;

#if defined( HAVE_DEBUG_OUTPUT )

  if( libcnotify_verbose != 0 )

  {

    libcnotify_printf(

     "%s: packed fields 1\t\t\t: 0x%08" PRIx64 "\n",

     function,

     packed_fields1 );

    libcnotify_printf(

     "%s: packed fields 2\t\t\t: 0x%08" PRIx64 "\n",

     function,

     packed_fields2 );

    libcnotify_printf(

     "%s: packed fields 3\t\t\t: 0x%08" PRIx64 "\n",

     function,

     packed_fields3 );

  }

#endif /* defined( HAVE_DEBUG_OUTPUT ) */

  decoder->number_of_literals   = (uint32_t) ( packed_fields1 & 0x000fffffUL );

  decoder->literals_data_size   = (uint32_t) ( ( packed_fields1 >> 20 ) & 0x000fffffUL );

  decoder->number_of_lmd_values = (uint32_t) ( ( packed_fields1 >> 40 ) & 0x000fffffUL );

  decoder->literal_bits         = (int32_t) ( ( packed_fields1 >> 60 ) & 0x00000007UL ) - 7;

  decoder->literal_states[ 0 ]  = (uint16_t) ( packed_fields2 & 0x000003ffUL );

  decoder->literal_states[ 1 ]  = (uint16_t) ( ( packed_fields2 >> 10 ) & 0x000003ffUL );

  decoder->literal_states[ 2 ]  = (uint16_t) ( ( packed_fields2 >> 20 ) & 0x000003ffUL );

  decoder->literal_states[ 3 ]  = (uint16_t) ( ( packed_fields2 >> 30 ) & 0x000003ffUL );

  decoder->lmd_values_data_size = (uint32_t) ( ( packed_fields2 >> 40 ) & 0x000fffffUL );

  decoder->lmd_values_bits      = (int32_t) ( ( packed_fields2 >> 60 ) & 0x00000007UL ) - 7;

  header_size                   = (uint32_t) ( packed_fields3 & 0xffffffffUL );

  decoder->l_value_state        = (uint16_t) ( ( packed_fields3 >> 32 ) & 0x000003ffUL );

  decoder->m_value_state        = (uint16_t) ( ( packed_fields3 >> 42 ) & 0x000003ffUL );

  decoder->d_value_state        = (uint16_t) ( ( packed_fields3 >> 52 ) & 0x000003ffUL );

  if( ( header_size < 32 )

   || ( header_size > 720 ) )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_RUNTIME,

     LIBCERROR_RUNTIME_ERROR_VALUE_OUT_OF_BOUNDS,

     "%s: invalid header size value out of bounds.",

     function );

    return( -1 );

  }

  if( header_size > 32 )

  {

#if defined( HAVE_DEBUG_OUTPUT )

    if( libcnotify_verbose != 0 )

    {

      libcnotify_printf(

       "%s: compressed frequency table data:\n",

       function );

      libcnotify_print_data(

       &( compressed_data[ safe_compressed_data_offset ] ),

       header_size - 32,

       0 );

    }

#endif

    if( ( header_size > compressed_data_size )

     || ( safe_compressed_data_offset > ( compressed_data_size - header_size ) ) )

    {

      libcerror_error_set(

       error,

       LIBCERROR_ERROR_DOMAIN_ARGUMENTS,

       LIBCERROR_ARGUMENT_ERROR_VALUE_TOO_SMALL,

       "%s: compressed data size value too small.",

       function );

      return( -1 );

    }

    if( libfmos_lzfse_read_compressed_frequency_table(

         &( compressed_data[ safe_compressed_data_offset ] ),

         header_size - 32,

         frequency_table,

         error ) != 1 )

    {

      libcerror_error_set(

       error,

       LIBCERROR_ERROR_DOMAIN_IO,

       LIBCERROR_IO_ERROR_READ_FAILED,

       "%s: unable to read compressed frequency table.",

       function );

      return( -1 );

    }

    safe_compressed_data_offset += (size_t) header_size - 32;

  }

#if defined( HAVE_DEBUG_OUTPUT )

  if( libcnotify_verbose != 0 )

  {

    libcnotify_printf(

     "%s: number of literals\t\t\t: %" PRIu32 "\n",

     function,

     decoder->number_of_literals );

    libcnotify_printf(

     "%s: number of L, M, D values\t\t: %" PRIu32 "\n",

     function,

     decoder->number_of_lmd_values );

    libcnotify_printf(

     "%s: literals data size\t\t\t: %" PRIu32 "\n",

     function,

     decoder->literals_data_size );

    libcnotify_printf(

     "%s: L, M, D values data size\t\t: %" PRIu32 "\n",

     function,

     decoder->lmd_values_data_size );

    libcnotify_printf(

     "%s: literal_bits\t\t\t: %" PRIi32 "\n",

     function,

     decoder->literal_bits );

    for( literal_decoder_index = 0;

         literal_decoder_index < 4;

         literal_decoder_index++ )

    {

      libcnotify_printf(

       "%s: literal_states[ %" PRIu8 " ]\t\t\t: %" PRIu16 "\n",

       function,

       literal_decoder_index,

       decoder->literal_states[ literal_decoder_index ] );

    }

    libcnotify_printf(

     "%s: lmd_bits\t\t\t\t: %" PRIi32 "\n",

     function,

     decoder->lmd_values_bits );

    libcnotify_printf(

     "%s: header size\t\t\t\t: %" PRIu32 "\n",

     function,

     header_size );

    libcnotify_printf(

     "%s: L value state\t\t\t: %" PRIu16 "\n",

     function,

     decoder->l_value_state );

    libcnotify_printf(

     "%s: M value state\t\t\t: %" PRIu16 "\n",

     function,

     decoder->m_value_state );

    libcnotify_printf(

     "%s: D value state\t\t\t: %" PRIu16 "\n",

     function,

     decoder->d_value_state );

    for( table_index = 0;

         table_index < 360;

         table_index++ )

    {

      if( frequency_table[ table_index ] != 0 )

      {

        libcnotify_printf(

         "%s: frequency table: %d value\t\t: %" PRIu16 "\n",

         function,

         table_index,

         frequency_table[ table_index ] );

      }

    }

    libcnotify_printf(

     "\n" );

  }

#endif /* defined( HAVE_DEBUG_OUTPUT ) */

  *compressed_data_offset = safe_compressed_data_offset;

  return( 1 );

}

/* Reads a compressed frequency table bit stream

 * Returns 1 on success or -1 on error

 */

int libfmos_lzfse_read_compressed_frequency_table(

     const uint8_t *compressed_data,

     size_t compressed_data_size,

     uint16_t *frequency_table,

     libcerror_error_t **error )

{

  static char *function         = "libfmos_lzfse_read_compressed_frequency_table";

  size_t compressed_data_offset = 0;

  uint32_t value_32bit          = 0;

  uint16_t frequency_value      = 0;

  int16_t table_index           = 0;

  uint8_t frequency_value_size  = 0;

  uint8_t lookup_index          = 0;

  uint8_t number_of_bits        = 0;

  if( compressed_data == NULL )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_ARGUMENTS,

     LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,

     "%s: invalid compressed data.",

     function );

    return( -1 );

  }

  if( ( compressed_data_size < 4 )

   || ( compressed_data_size > (size_t) SSIZE_MAX ) )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_ARGUMENTS,

     LIBCERROR_ARGUMENT_ERROR_VALUE_OUT_OF_BOUNDS,

     "%s: invalid compressed data size value out of bounds.",

     function );

    return( -1 );

  }

  if( frequency_table == NULL )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_ARGUMENTS,

     LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,

     "%s: invalid frequency table.",

     function );

    return( -1 );

  }

  for( table_index = 0;

       table_index < 360;

       table_index++ )

  {

    while( ( number_of_bits <= 24 )

        && ( compressed_data_offset < compressed_data_size ) )

    {

      value_32bit    |= (uint32_t) compressed_data[ compressed_data_offset++ ] << number_of_bits;

      number_of_bits += 8;

    }

    lookup_index         = (uint8_t) ( value_32bit & 0x0000001fUL );

    frequency_value_size = libfmos_lzfse_frequency_number_of_bits_table[ lookup_index ];

    if( frequency_value_size == 8 )

    {

      frequency_value = (uint16_t) ( ( value_32bit >> 4 ) & 0x0000000fUL ) + 8;

    }

    else if( frequency_value_size == 14 )

    {

      frequency_value = (uint16_t) ( ( value_32bit >> 4 ) & 0x000003ffUL ) + 24;

    }

    else

    {

      frequency_value = libfmos_lzfse_frequency_value_table[ lookup_index ];

    }

    frequency_table[ table_index ] = frequency_value;

    value_32bit   >>= frequency_value_size;

    number_of_bits -= frequency_value_size;

  }

  return( 1 );

}

/* Reads a LZFSE compressed block

 * Returns 1 on success or -1 on error

 */

int libfmos_lzfse_read_block(

     libfmos_lzfse_decoder_t *decoder,

     const uint8_t *compressed_data,

     size_t compressed_data_size,

     size_t *compressed_data_offset,

     uint8_t *uncompressed_data,

     size_t uncompressed_data_size,

     size_t *uncompressed_data_offset,

     libcerror_error_t **error )

{

  uint8_t literal_values[ LIBFMOS_LZFSE_LITERALS_PER_BLOCK + 64 ];

  libfmos_lzfse_bit_stream_t *bit_stream = NULL;

  static char *function                   = "libfmos_lzfse_read_block";

  size_t safe_compressed_data_offset      = 0;

  if( decoder == NULL )

  {

    libcerror_error_set(

     error,