omnizip 0.4.7-arm-linux

data/lib/omnizip/formats/rar/compression/ppmd/encoder.rb

@@ -0,0 +1,250 @@
+# frozen_string_literal: true
+
+# Copyright (C) 2025 Ribose Inc.
+#
+# Permission is hereby granted, free of charge, to any person obtaining a
+# copy of this software and associated documentation files (the "Software"),
+# to deal in the Software without restriction, including without limitation
+# the rights to use, copy, modify, merge, publish, distribute, sublicense,
+# and/or sell copies of the Software, and to permit persons to whom the
+# Software is furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+# DEALINGS IN THE SOFTWARE.
+
+module Omnizip
+  module Formats
+    module Rar
+      module Compression
+        module PPMd
+          # RAR PPMd variant H encoder
+          #
+          # Implements encoding for RAR's PPMd variant H compression method.
+          # This adapts the standard PPMd7 algorithm for RAR-specific
+          # requirements:
+          #
+          # - Different memory model initialization
+          # - RAR-specific escape code handling
+          # - Modified context order selection
+          # - Different binary symbol encoding
+          #
+          # Responsibilities:
+          # - ONE responsibility: Encode data using RAR PPMd variant H
+          # - Manage encoder state and context
+          # - Transform original bytes to compressed bits
+          # - Maintain synchronized model state (matches decoder)
+          class Encoder < Omnizip::Algorithms::PPMd7::Encoder
+            # RAR variant H specific constants
+            RAR_MAX_ORDER = 16
+            RAR_MIN_ORDER = 2
+            RAR_DEFAULT_ORDER = 6
+
+            # RAR memory size multiplier (MB to bytes)
+            RAR_MEM_MULTIPLIER = 1024 * 1024
+
+            # Accessor for memory size (for testing)
+            def memory_size
+              @model.mem_size
+            end
+
+            # Initialize the RAR PPMd encoder
+            #
+            # @param output [IO] Output stream for compressed data
+            # @param options [Hash] Encoding options
+            # @option options [Integer] :model_order Maximum context order
+            # @option options [Integer] :mem_size Memory size in MB for RAR
+            def initialize(output, options = {})
+              @output = output
+              @options = options
+
+              # RAR uses memory size in MB, convert to bytes
+              mem_size_mb = options[:mem_size] || 16
+              mem_size_bytes = mem_size_mb * RAR_MEM_MULTIPLIER
+
+              # Initialize model with RAR parameters
+              @model = initialize_rar_model(
+                options[:model_order] || RAR_DEFAULT_ORDER,
+                mem_size_bytes,
+              )
+
+              # Use range encoder for bit output
+              @range_encoder = Omnizip::Algorithms::LZMA::RangeEncoder.new(output)
+            end
+
+            # Encode a stream to compressed bytes
+            #
+            # RAR variant H encoding process:
+            # 1. Read byte from input
+            # 2. Find symbol in current context
+            # 3. Encode using range coder with probabilities
+            # 4. Update model to stay synchronized with decoder
+            # 5. Handle RAR-specific escape codes if needed
+            #
+            # @param input [IO] Input stream to compress
+            # @param max_bytes [Integer, nil] Maximum bytes to encode
+            # @return [Integer] Number of bytes encoded
+            def encode_stream(input, max_bytes = nil)
+              bytes_encoded = 0
+
+              loop do
+                break if max_bytes && bytes_encoded >= max_bytes
+
+                byte = input.read(1)
+                break unless byte
+
+                encode_symbol(byte.ord)
+                bytes_encoded += 1
+              end
+
+              # Flush encoder to ensure all data is written
+              @range_encoder.flush
+              bytes_encoded
+            end
+
+            private
+
+            # Initialize RAR variant H PPMd model
+            #
+            # RAR uses slightly different initialization than PPMd7:
+            # - Different context creation strategy
+            # - RAR-specific memory allocation
+            # - Modified root context initialization
+            #
+            # @param max_order [Integer] Maximum context order
+            # @param memory_size [Integer] Memory size in bytes
+            # @return [Omnizip::Algorithms::PPMd7::Model] Initialized model
+            def initialize_rar_model(max_order, memory_size)
+              # Validate RAR parameters
+              unless max_order.between?(RAR_MIN_ORDER, RAR_MAX_ORDER)
+                raise ArgumentError,
+                      "RAR max_order must be between #{RAR_MIN_ORDER} and " \
+                      "#{RAR_MAX_ORDER}"
+              end
+
+              # Create model with RAR parameters
+              # Note: Using PPMd7::Model as base, but with RAR contexts
+              Omnizip::Algorithms::PPMd7::Model.new(max_order, memory_size)
+            end
+
+            # Encode a single symbol using RAR variant H
+            #
+            # RAR uses same basic encoding as PPMd7 but with
+            # different escape code handling and probability calculation.
+            #
+            # Process:
+            # 1. Get current context
+            # 2. Check if symbol exists in context
+            # 3. If yes: encode using frequency information
+            # 4. If no: encode escape + new symbol
+            # 5. Update model state
+            #
+            # @param byte [Integer] Byte value to encode (0-255)
+            # @return [void]
+            def encode_symbol(byte)
+              # Get current context
+              context = @model.current_context
+
+              # Find symbol in context (returns SymbolState or nil)
+              state = context.find_symbol(byte)
+
+              if state
+                # Encode using frequency information
+                encode_symbol_in_context(byte, state, context)
+              else
+                # Encode escape + new symbol
+                encode_escape_code
+                encode_new_symbol(byte)
+              end
+
+              # Update model to stay synchronized with decoder
+              @model.update(byte)
+            end
+
+            # Encode symbol that exists in current context
+            #
+            # Uses the frequency information from the context to
+            # calculate probability range for range encoder.
+            #
+            # @param byte [Integer] Symbol to encode
+            # @param state [SymbolState] Symbol's state
+            # @param context [Context] Current context
+            # @return [void]
+            def encode_symbol_in_context(byte, state, context)
+              # Get frequency from state
+              freq = state.freq
+              total_freq = context.total_freq
+
+              # Calculate cumulative frequency (for range low)
+              cum_freq = 0
+              context.states.each do |sym, st|
+                break if sym >= byte
+
+                cum_freq += st.freq
+              end
+
+              # Encode range using frequencies
+              encode_range(cum_freq, freq, total_freq)
+            end
+
+            # Encode RAR-specific escape code
+            #
+            # RAR variant H uses different escape code values
+            # and handling compared to standard PPMd7.
+            #
+            # The escape is encoded as part of the context's frequency range,
+            # positioned at the end (after all regular symbols).
+            #
+            # @return [void]
+            def encode_escape_code
+              # Encode escape at cumulative frequency = sum_freq
+              # with frequency = escape_freq
+              # total = sum_freq + escape_freq
+              context = @model.current_context
+              cum_freq = context.sum_freq # Escape is at the end
+              freq = context.escape_freq
+              total_freq = context.total_freq
+
+              @range_encoder.encode_freq(cum_freq, freq, total_freq)
+            end
+
+            # Encode new symbol not in current context
+            #
+            # When a symbol doesn't exist in the current context,
+            # encode it using uniform distribution (all symbols
+            # equally likely).
+            #
+            # @param byte [Integer] Symbol to encode
+            # @return [void]
+            def encode_new_symbol(byte)
+              # Encode as 8 direct bits (uniform distribution)
+              @range_encoder.encode_direct_bits(byte, 8)
+            end
+
+            # Encode a range for the symbol
+            #
+            # Converts frequency information to range and encodes
+            # using the range encoder.
+            #
+            # @param cum_freq [Integer] Cumulative frequency
+            # @param freq [Integer] Symbol frequency
+            # @param total_freq [Integer] Total frequency
+            # @return [void]
+            def encode_range(cum_freq, freq, total_freq)
+              return if total_freq.zero?
+
+              @range_encoder.encode_freq(cum_freq, freq, total_freq)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/omnizip/formats/rar/compression/ppmd.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Omnizip
+  module Formats
+    module Rar
+      module Compression
+        # PPMd compression namespace for RAR
+        module PPMd
+          autoload :Context, "omnizip/formats/rar/compression/ppmd/context"
+          autoload :Decoder, "omnizip/formats/rar/compression/ppmd/decoder"
+          autoload :Encoder, "omnizip/formats/rar/compression/ppmd/encoder"
+        end
+      end
+    end
+  end
+end

data/lib/omnizip/formats/rar/compression.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Omnizip
+  module Formats
+    module Rar
+      # Compression namespace for RAR compression algorithms
+      module Compression
+        autoload :BitStream, "omnizip/formats/rar/compression/bit_stream"
+        autoload :Dispatcher, "omnizip/formats/rar/compression/dispatcher"
+
+        # Subdirectory namespaces
+        autoload :PPMd, "omnizip/formats/rar/compression/ppmd"
+        autoload :LZ77Huffman, "omnizip/formats/rar/compression/lz77_huffman"
+      end
+    end
+  end
+end

data/lib/omnizip/formats/rar/compression_method_registry.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module Omnizip
+  module Formats
+    module Rar
+      # Registry for RAR compression methods
+      #
+      # This class manages the registration and retrieval of compression
+      # methods for RAR archives. It follows the Registry pattern to allow
+      # dynamic addition of compression methods without modifying core code.
+      #
+      # @example Registering a compression method
+      #   CompressionMethodRegistry.register(
+      #     :rar3_normal,
+      #     Rar3::Compressor,
+      #     Rar3::Decompressor
+      #   )
+      #
+      # @example Getting a compressor
+      #   compressor = CompressionMethodRegistry.compressor(:rar3_normal)
+      class CompressionMethodRegistry
+        class << self
+          # Register a compression method
+          #
+          # @param name [Symbol] The method name
+          # @param compressor [Class] The compressor class
+          # @param decompressor [Class] The decompressor class
+          # @return [void]
+          def register(name, compressor, decompressor)
+            methods[name] = {
+              compressor: compressor,
+              decompressor: decompressor,
+            }
+          end
+
+          # Get a compressor for a method
+          #
+          # @param name [Symbol] The method name
+          # @return [Class] The compressor class
+          # @raise [Error::FormatError] If method not registered
+          def compressor(name)
+            method_data = methods[name]
+            return method_data[:compressor] if method_data
+
+            raise Error::FormatError,
+                  "No compressor registered for method: #{name}"
+          end
+
+          # Get a decompressor for a method
+          #
+          # @param name [Symbol] The method name
+          # @return [Class] The decompressor class
+          # @raise [Error::FormatError] If method not registered
+          def decompressor(name)
+            method_data = methods[name]
+            return method_data[:decompressor] if method_data
+
+            raise Error::FormatError,
+                  "No decompressor registered for method: #{name}"
+          end
+
+          # Check if a method is registered
+          #
+          # @param name [Symbol] The method name
+          # @return [Boolean] True if registered
+          def registered?(name)
+            methods.key?(name)
+          end
+
+          # Get all registered method names
+          #
+          # @return [Array<Symbol>] The registered method names
+          def registered_methods
+            methods.keys
+          end
+
+          # Clear all registered methods (primarily for testing)
+          #
+          # @return [void]
+          def clear
+            @methods = {}
+          end
+
+          # Get a compression method for a RAR version and level
+          #
+          # @param version [String] The RAR version (e.g., "3.0", "5.0")
+          # @param level [Symbol] The compression level
+          # @return [Symbol] The method name
+          def method_for_version(version, level)
+            prefix = version.start_with?("5") ? "rar5" : "rar3"
+            :"#{prefix}_#{level}"
+          end
+
+          private
+
+          # Storage for registered methods
+          #
+          # @return [Hash] The methods hash
+          def methods
+            @methods ||= {}
+          end
+        end
+      end
+    end
+  end
+end

data/lib/omnizip/formats/rar/constants.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module Omnizip
+  module Formats
+    module Rar
+      # RAR format constants
+      module Constants
+        # RAR signatures
+        RAR4_SIGNATURE = [0x52, 0x61, 0x72, 0x21, 0x1A, 0x07, 0x00].freeze
+        RAR5_SIGNATURE = [0x52, 0x61, 0x72, 0x21, 0x1A, 0x07, 0x01, 0x00].freeze
+
+        # Block types (RAR4)
+        BLOCK_MARKER = 0x72
+        BLOCK_ARCHIVE = 0x73
+        BLOCK_FILE = 0x74
+        BLOCK_COMMENT = 0x75
+        BLOCK_OLD_EXTRA = 0x76
+        BLOCK_OLD_SUBBLOCK = 0x77
+        BLOCK_OLD_RECOVERY = 0x78
+        BLOCK_OLD_AUTH = 0x79
+        BLOCK_SUBBLOCK = 0x7A
+        BLOCK_ENDARC = 0x7B
+
+        # HEAD_FLAGS bit 0x8000 (LONG_BLOCK): the block carries a
+        # data area whose size is the PACK_SIZE field at offset 7
+        BLOCK_LONG = 0x8000
+
+        # Archive flags
+        ARCHIVE_VOLUME = 0x0001
+        ARCHIVE_COMMENT = 0x0002
+        ARCHIVE_LOCKED = 0x0004
+        ARCHIVE_SOLID = 0x0008
+        ARCHIVE_NEW_NAMING = 0x0010
+        ARCHIVE_AUTH_INFO = 0x0020
+        ARCHIVE_RECOVERY = 0x0040
+        ARCHIVE_ENCRYPTED = 0x0080
+        ARCHIVE_FIRST_VOLUME = 0x0100
+
+        # File flags
+        FILE_SPLIT_BEFORE = 0x0001
+        FILE_SPLIT_AFTER = 0x0002
+        FILE_ENCRYPTED = 0x0004
+        FILE_COMMENT = 0x0008
+        FILE_SOLID = 0x0010
+        FILE_DIRECTORY = 0x00E0
+        FILE_LARGE = 0x0100
+        FILE_UNICODE = 0x0200
+        FILE_SALT = 0x0400
+        FILE_VERSION = 0x0800
+        FILE_EXT_TIME = 0x1000
+
+        # RAR5 header types
+        RAR5_HEADER_MAIN = 1
+        RAR5_HEADER_FILE = 2
+        RAR5_HEADER_SERVICE = 3
+        RAR5_HEADER_ENCRYPTION = 4
+        RAR5_HEADER_END = 5
+
+        # RAR5 flags
+        RAR5_FLAG_EXTRA_AREA = 0x0001
+        RAR5_FLAG_DATA_AREA = 0x0002
+        RAR5_FLAG_UNKNOWN_BLOCKS = 0x0004
+        RAR5_FLAG_DATA_INHERITED = 0x0008
+        RAR5_FLAG_CHILD_BLOCKS = 0x0010
+        # File-header-specific flags (FileFlags field): the directory
+        # bit is 0x0001 per the RAR5 spec.
+        RAR5_FLAG_IS_DIR = 0x0001
+        RAR5_FLAG_MULTI_VOLUME = 0x0001
+
+        # Compression methods
+        METHOD_STORE = 0x30
+        METHOD_FASTEST = 0x31
+        METHOD_FAST = 0x32
+        METHOD_NORMAL = 0x33
+        METHOD_GOOD = 0x34
+        METHOD_BEST = 0x35
+
+        # Host OS
+        OS_MSDOS = 0
+        OS_OS2 = 1
+        OS_WIN32 = 2
+        OS_UNIX = 3
+        OS_MACOS = 4
+        OS_BEOS = 5
+      end
+    end
+  end
+end