Changeset 93e80d5 in rtems-tools


Ignore:
Timestamp:
Nov 29, 2012, 8:04:12 AM (7 years ago)
Author:
Chris Johns <chrisj@…>
Branches:
4.10, 4.11, master
Children:
1a5bdef
Parents:
9c70d15
Message:

Compress as blocks.

The LZ77 compressor works with blocks. Each block is prefixed with
a header that defines the output size of the block being compressed.

Location:
linkers
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • linkers/rld-compression.cpp

    r9c70d15 r93e80d5  
    5454        total_compressed (0)
    5555    {
     56      if (size > 0xffff)
     57        throw rld::error ("Size too big, 16 bits only", "compression");
     58
    5659      buffer = new uint8_t[size];
    5760      io = new uint8_t[size + (size / 10)];
     
    7073      const uint8_t* data = static_cast <const uint8_t*> (data_);
    7174
    72       if (compress)
     75      while (length)
    7376      {
    74         while (length)
    75         {
    76           size_t appending;
     77        size_t appending;
    7778
    78           if (length > (size - level))
    79             appending = size - level;
    80           else
    81             appending = length;
     79        if (length > (size - level))
     80          appending = size - level;
     81        else
     82          appending = length;
    8283
    83           ::memcpy ((void*) (buffer + level), data, appending);
     84        ::memcpy ((void*) (buffer + level), data, appending);
    8485
    85           level += appending;
    86           length -= appending;
    87           total += appending;
     86        level += appending;
     87        length -= appending;
    8888
    89           if (level >= size)
    90           {
    91             int writing =
    92               ::fastlz_compress (buffer, level, io);
    93 
    94             image.write (io, writing);
    95 
    96             total_compressed += writing;
    97             level = 0;
    98           }
    99         }
    100       }
    101       else
    102       {
    103         image.write (data, length);
    104         total += length;
     89        output ();
    10590      }
    10691    }
     
    124109        level += appending;
    125110        length -= appending;
    126         total += appending;
    127111
    128         if (level >= size)
    129         {
    130           if (compress)
    131           {
    132             int writing =
    133               ::fastlz_compress (buffer, level, io);
    134 
    135             image.write (io, writing);
    136 
    137             total_compressed += writing;
    138           }
    139           else
    140           {
    141             image.write (buffer, length);
    142           }
    143 
    144           level = 0;
    145         }
     112        output ();
    146113      }
    147114    }
     
    150117    compressor::flush ()
    151118    {
    152       if (level)
    153       {
    154         int writing =
    155           ::fastlz_compress (buffer, level, io);
    156 
    157         image.write (io, writing);
    158 
    159         total_compressed += writing;
    160         level = 0;
    161       }
     119      output (true);
    162120    }
    163121
     
    174132    }
    175133
     134    void
     135    compressor::output (bool forced)
     136    {
     137      if ((forced && level) || (level >= size))
     138      {
     139        total += level;
     140
     141        if (compress)
     142        {
     143          int     writing = ::fastlz_compress (buffer, level, io);
     144          uint8_t header[2];
     145
     146          header[0] = writing >> 8;
     147          header[1] = writing;
     148
     149          image.write (header, 2);
     150          image.write (io, writing);
     151
     152          total_compressed += 2 + writing;
     153        }
     154        else
     155        {
     156          image.write (buffer, level);
     157        }
     158
     159        level = 0;
     160      }
     161    }
     162
    176163  }
    177164}
  • linkers/rld-compression.h

    r9c70d15 r93e80d5  
    9494
    9595    private:
     96
     97      /**
     98       * Output the block of data to the output file with the block header.
     99       *
     100       * @param forced If true output the buffer.
     101       */
     102      void output (bool forced = false);
     103
    96104      files::image& image;            //< The image to read or write to or from.
    97105      size_t        size;             //< The size of the buffer.
     
    115123      T       v = value;
    116124      int     b = sizeof (T) - 1;
    117       while (b > 0)
     125      while (b >= 0)
    118126      {
    119127        bytes[b--] = (uint8_t) v;
Note: See TracChangeset for help on using the changeset viewer.