misc/libphysfs/lzma/CPP/7zip/Compress/Branch/x86_2.h
changeset 12218 bb5522e88ab2
equal deleted inserted replaced
12217:ea891871f481 12218:bb5522e88ab2
       
     1 // x86_2.h
       
     2 
       
     3 #ifndef __BRANCH_X86_2_H
       
     4 #define __BRANCH_X86_2_H
       
     5 
       
     6 #include "../../../Common/MyCom.h"
       
     7 #include "../RangeCoder/RangeCoderBit.h"
       
     8 #include "../../ICoder.h"
       
     9 
       
    10 namespace NCompress {
       
    11 namespace NBcj2 {
       
    12 
       
    13 const int kNumMoveBits = 5;
       
    14 
       
    15 #ifndef EXTRACT_ONLY
       
    16 
       
    17 class CEncoder:
       
    18   public ICompressCoder2,
       
    19   public CMyUnknownImp
       
    20 {
       
    21   Byte *_buffer;
       
    22 public:
       
    23   CEncoder(): _buffer(0) {};
       
    24   ~CEncoder();
       
    25   bool Create();
       
    26 
       
    27   COutBuffer _mainStream;
       
    28   COutBuffer _callStream;
       
    29   COutBuffer _jumpStream;
       
    30   NCompress::NRangeCoder::CEncoder _rangeEncoder;
       
    31   NCompress::NRangeCoder::CBitEncoder<kNumMoveBits> _statusEncoder[256 + 2];
       
    32 
       
    33   HRESULT Flush();
       
    34   void ReleaseStreams()
       
    35   {
       
    36     _mainStream.ReleaseStream();
       
    37     _callStream.ReleaseStream();
       
    38     _jumpStream.ReleaseStream();
       
    39     _rangeEncoder.ReleaseStream();
       
    40   }
       
    41 
       
    42   class CCoderReleaser
       
    43   {
       
    44     CEncoder *_coder;
       
    45   public:
       
    46     CCoderReleaser(CEncoder *coder): _coder(coder) {}
       
    47     ~CCoderReleaser() {  _coder->ReleaseStreams(); }
       
    48   };
       
    49 
       
    50 public: 
       
    51 
       
    52   MY_UNKNOWN_IMP
       
    53 
       
    54   HRESULT CodeReal(ISequentialInStream **inStreams,
       
    55       const UInt64 **inSizes,
       
    56       UInt32 numInStreams,
       
    57       ISequentialOutStream **outStreams,
       
    58       const UInt64 **outSizes,
       
    59       UInt32 numOutStreams,
       
    60       ICompressProgressInfo *progress);
       
    61   STDMETHOD(Code)(ISequentialInStream **inStreams,
       
    62       const UInt64 **inSizes,
       
    63       UInt32 numInStreams,
       
    64       ISequentialOutStream **outStreams,
       
    65       const UInt64 **outSizes,
       
    66       UInt32 numOutStreams,
       
    67       ICompressProgressInfo *progress);
       
    68 }; 
       
    69 
       
    70 #endif
       
    71 
       
    72 class CDecoder:
       
    73   public ICompressCoder2,
       
    74   public CMyUnknownImp
       
    75 { 
       
    76 public:
       
    77   CInBuffer _mainInStream;
       
    78   CInBuffer _callStream;
       
    79   CInBuffer _jumpStream;
       
    80   NCompress::NRangeCoder::CDecoder _rangeDecoder;
       
    81   NCompress::NRangeCoder::CBitDecoder<kNumMoveBits> _statusDecoder[256 + 2];
       
    82 
       
    83   COutBuffer _outStream;
       
    84 
       
    85   void ReleaseStreams()
       
    86   {
       
    87     _mainInStream.ReleaseStream();
       
    88     _callStream.ReleaseStream();
       
    89     _jumpStream.ReleaseStream();
       
    90     _rangeDecoder.ReleaseStream();
       
    91     _outStream.ReleaseStream();
       
    92   }
       
    93 
       
    94   HRESULT Flush() { return _outStream.Flush(); }
       
    95   class CCoderReleaser
       
    96   {
       
    97     CDecoder *_coder;
       
    98   public:
       
    99     CCoderReleaser(CDecoder *coder): _coder(coder) {}
       
   100     ~CCoderReleaser()  { _coder->ReleaseStreams(); }
       
   101   };
       
   102 
       
   103 public: 
       
   104   MY_UNKNOWN_IMP
       
   105   HRESULT CodeReal(ISequentialInStream **inStreams,
       
   106       const UInt64 **inSizes,
       
   107       UInt32 numInStreams,
       
   108       ISequentialOutStream **outStreams,
       
   109       const UInt64 **outSizes,
       
   110       UInt32 numOutStreams,
       
   111       ICompressProgressInfo *progress);
       
   112   STDMETHOD(Code)(ISequentialInStream **inStreams,
       
   113       const UInt64 **inSizes,
       
   114       UInt32 numInStreams,
       
   115       ISequentialOutStream **outStreams,
       
   116       const UInt64 **outSizes,
       
   117       UInt32 numOutStreams,
       
   118       ICompressProgressInfo *progress);
       
   119 }; 
       
   120 
       
   121 }}
       
   122 
       
   123 #endif