vcs.maemo.org Git - physicsfs/blob - lzma/CPP/7zip/Archive/7z/7zDecode.cpp

   1 // 7zDecode.cpp
   2
   3 #include "StdAfx.h"
   4
   5 #include "7zDecode.h"
   6
   7 #include "../../IPassword.h"
   8 #include "../../Common/LockedStream.h"
   9 #include "../../Common/StreamObjects.h"
  10 #include "../../Common/ProgressUtils.h"
  11 #include "../../Common/LimitedStreams.h"
  12 #include "../../Common/CreateCoder.h"
  13 #include "../../Common/FilterCoder.h"
  14
  15 namespace NArchive {
  16 namespace N7z {
  17
  18 static void ConvertFolderItemInfoToBindInfo(const CFolder &folder,
  19     CBindInfoEx &bindInfo)
  20 {
  21   bindInfo.Clear();
  22   int i;
  23   for (i = 0; i < folder.BindPairs.Size(); i++)
  24   {
  25     NCoderMixer::CBindPair bindPair;
  26     bindPair.InIndex = (UInt32)folder.BindPairs[i].InIndex;
  27     bindPair.OutIndex = (UInt32)folder.BindPairs[i].OutIndex;
  28     bindInfo.BindPairs.Add(bindPair);
  29   }
  30   UInt32 outStreamIndex = 0;
  31   for (i = 0; i < folder.Coders.Size(); i++)
  32   {
  33     NCoderMixer::CCoderStreamsInfo coderStreamsInfo;
  34     const CCoderInfo &coderInfo = folder.Coders[i];
  35     coderStreamsInfo.NumInStreams = (UInt32)coderInfo.NumInStreams;
  36     coderStreamsInfo.NumOutStreams = (UInt32)coderInfo.NumOutStreams;
  37     bindInfo.Coders.Add(coderStreamsInfo);
  38     bindInfo.CoderMethodIDs.Add(coderInfo.MethodID);
  39     for (UInt32 j = 0; j < coderStreamsInfo.NumOutStreams; j++, outStreamIndex++)
  40       if (folder.FindBindPairForOutStream(outStreamIndex) < 0)
  41         bindInfo.OutStreams.Add(outStreamIndex);
  42   }
  43   for (i = 0; i < folder.PackStreams.Size(); i++)
  44     bindInfo.InStreams.Add((UInt32)folder.PackStreams[i]);
  45 }
  46
  47 static bool AreCodersEqual(const NCoderMixer::CCoderStreamsInfo &a1,
  48     const NCoderMixer::CCoderStreamsInfo &a2)
  49 {
  50   return (a1.NumInStreams == a2.NumInStreams) &&
  51     (a1.NumOutStreams == a2.NumOutStreams);
  52 }
  53
  54 static bool AreBindPairsEqual(const NCoderMixer::CBindPair &a1, const NCoderMixer::CBindPair &a2)
  55 {
  56   return (a1.InIndex == a2.InIndex) &&
  57     (a1.OutIndex == a2.OutIndex);
  58 }
  59
  60 static bool AreBindInfoExEqual(const CBindInfoEx &a1, const CBindInfoEx &a2)
  61 {
  62   if (a1.Coders.Size() != a2.Coders.Size())
  63     return false;
  64   int i;
  65   for (i = 0; i < a1.Coders.Size(); i++)
  66     if (!AreCodersEqual(a1.Coders[i], a2.Coders[i]))
  67       return false;
  68   if (a1.BindPairs.Size() != a2.BindPairs.Size())
  69     return false;
  70   for (i = 0; i < a1.BindPairs.Size(); i++)
  71     if (!AreBindPairsEqual(a1.BindPairs[i], a2.BindPairs[i]))
  72       return false;
  73   for (i = 0; i < a1.CoderMethodIDs.Size(); i++)
  74     if (a1.CoderMethodIDs[i] != a2.CoderMethodIDs[i])
  75       return false;
  76   if (a1.InStreams.Size() != a2.InStreams.Size())
  77     return false;
  78   if (a1.OutStreams.Size() != a2.OutStreams.Size())
  79     return false;
  80   return true;
  81 }
  82
  83 CDecoder::CDecoder(bool multiThread)
  84 {
  85   #ifndef _ST_MODE
  86   multiThread = true;
  87   #endif
  88   _multiThread = multiThread;
  89   _bindInfoExPrevIsDefined = false;
  90 }
  91
  92 HRESULT CDecoder::Decode(
  93     DECL_EXTERNAL_CODECS_LOC_VARS
  94     IInStream *inStream,
  95     UInt64 startPos,
  96     const UInt64 *packSizes,
  97     const CFolder &folderInfo,
  98     ISequentialOutStream *outStream,
  99     ICompressProgressInfo *compressProgress
 100     #ifndef _NO_CRYPTO
 101     , ICryptoGetTextPassword *getTextPassword
 102     #endif
 103     #ifdef COMPRESS_MT
 104     , bool mtMode, UInt32 numThreads
 105     #endif
 106     )
 107 {
 108   CObjectVector< CMyComPtr<ISequentialInStream> > inStreams;
 109
 110   CLockedInStream lockedInStream;
 111   lockedInStream.Init(inStream);
 112
 113   for (int j = 0; j < folderInfo.PackStreams.Size(); j++)
 114   {
 115     CLockedSequentialInStreamImp *lockedStreamImpSpec = new
 116         CLockedSequentialInStreamImp;
 117     CMyComPtr<ISequentialInStream> lockedStreamImp = lockedStreamImpSpec;
 118     lockedStreamImpSpec->Init(&lockedInStream, startPos);
 119     startPos += packSizes[j];
 120
 121     CLimitedSequentialInStream *streamSpec = new
 122         CLimitedSequentialInStream;
 123     CMyComPtr<ISequentialInStream> inStream = streamSpec;
 124     streamSpec->SetStream(lockedStreamImp);
 125     streamSpec->Init(packSizes[j]);
 126     inStreams.Add(inStream);
 127   }
 128
 129   int numCoders = folderInfo.Coders.Size();
 130
 131   CBindInfoEx bindInfo;
 132   ConvertFolderItemInfoToBindInfo(folderInfo, bindInfo);
 133   bool createNewCoders;
 134   if (!_bindInfoExPrevIsDefined)
 135     createNewCoders = true;
 136   else
 137     createNewCoders = !AreBindInfoExEqual(bindInfo, _bindInfoExPrev);
 138   if (createNewCoders)
 139   {
 140     int i;
 141     _decoders.Clear();
 142     // _decoders2.Clear();
 143
 144     _mixerCoder.Release();
 145
 146     if (_multiThread)
 147     {
 148       _mixerCoderMTSpec = new NCoderMixer::CCoderMixer2MT;
 149       _mixerCoder = _mixerCoderMTSpec;
 150       _mixerCoderCommon = _mixerCoderMTSpec;
 151     }
 152     else
 153     {
 154       #ifdef _ST_MODE
 155       _mixerCoderSTSpec = new NCoderMixer::CCoderMixer2ST;
 156       _mixerCoder = _mixerCoderSTSpec;
 157       _mixerCoderCommon = _mixerCoderSTSpec;
 158       #endif
 159     }
 160     RINOK(_mixerCoderCommon->SetBindInfo(bindInfo));
 161
 162     for (i = 0; i < numCoders; i++)
 163     {
 164       const CCoderInfo &coderInfo = folderInfo.Coders[i];
 165
 166
 167       CMyComPtr<ICompressCoder> decoder;
 168       CMyComPtr<ICompressCoder2> decoder2;
 169       RINOK(CreateCoder(
 170           EXTERNAL_CODECS_LOC_VARS
 171           coderInfo.MethodID, decoder, decoder2, false));
 172       CMyComPtr<IUnknown> decoderUnknown;
 173       if (coderInfo.IsSimpleCoder())
 174       {
 175         if (decoder == 0)
 176           return E_NOTIMPL;
 177
 178         decoderUnknown = (IUnknown *)decoder;
 179
 180         if (_multiThread)
 181           _mixerCoderMTSpec->AddCoder(decoder);
 182         #ifdef _ST_MODE
 183         else
 184           _mixerCoderSTSpec->AddCoder(decoder, false);
 185         #endif
 186       }
 187       else
 188       {
 189         if (decoder2 == 0)
 190           return E_NOTIMPL;
 191         decoderUnknown = (IUnknown *)decoder2;
 192         if (_multiThread)
 193           _mixerCoderMTSpec->AddCoder2(decoder2);
 194         #ifdef _ST_MODE
 195         else
 196           _mixerCoderSTSpec->AddCoder2(decoder2, false);
 197         #endif
 198       }
 199       _decoders.Add(decoderUnknown);
 200       #ifdef EXTERNAL_CODECS
 201       CMyComPtr<ISetCompressCodecsInfo> setCompressCodecsInfo;
 202       decoderUnknown.QueryInterface(IID_ISetCompressCodecsInfo, (void **)&setCompressCodecsInfo);
 203       if (setCompressCodecsInfo)
 204       {
 205         RINOK(setCompressCodecsInfo->SetCompressCodecsInfo(codecsInfo));
 206       }
 207       #endif
 208     }
 209     _bindInfoExPrev = bindInfo;
 210     _bindInfoExPrevIsDefined = true;
 211   }
 212   int i;
 213   _mixerCoderCommon->ReInit();
 214
 215   UInt32 packStreamIndex = 0, unPackStreamIndex = 0;
 216   UInt32 coderIndex = 0;
 217   // UInt32 coder2Index = 0;
 218
 219   for (i = 0; i < numCoders; i++)
 220   {
 221     const CCoderInfo &coderInfo = folderInfo.Coders[i];
 222     CMyComPtr<IUnknown> &decoder = _decoders[coderIndex];
 223
 224     {
 225       CMyComPtr<ICompressSetDecoderProperties2> setDecoderProperties;
 226       decoder.QueryInterface(IID_ICompressSetDecoderProperties2, &setDecoderProperties);
 227       if (setDecoderProperties)
 228       {
 229         const CByteBuffer &properties = coderInfo.Properties;
 230         size_t size = properties.GetCapacity();
 231         if (size > 0xFFFFFFFF)
 232           return E_NOTIMPL;
 233         if (size > 0)
 234         {
 235           RINOK(setDecoderProperties->SetDecoderProperties2((const Byte *)properties, (UInt32)size));
 236         }
 237       }
 238     }
 239
 240     #ifdef COMPRESS_MT
 241     if (mtMode)
 242     {
 243       CMyComPtr<ICompressSetCoderMt> setCoderMt;
 244       decoder.QueryInterface(IID_ICompressSetCoderMt, &setCoderMt);
 245       if (setCoderMt)
 246       {
 247         RINOK(setCoderMt->SetNumberOfThreads(numThreads));
 248       }
 249     }
 250     #endif
 251
 252     #ifndef _NO_CRYPTO
 253     {
 254       CMyComPtr<ICryptoSetPassword> cryptoSetPassword;
 255       decoder.QueryInterface(IID_ICryptoSetPassword, &cryptoSetPassword);
 256       if (cryptoSetPassword)
 257       {
 258         if (getTextPassword == 0)
 259           return E_FAIL;
 260         CMyComBSTR password;
 261         RINOK(getTextPassword->CryptoGetTextPassword(&password));
 262         CByteBuffer buffer;
 263         UString unicodePassword(password);
 264         const UInt32 sizeInBytes = unicodePassword.Length() * 2;
 265         buffer.SetCapacity(sizeInBytes);
 266         for (int i = 0; i < unicodePassword.Length(); i++)
 267         {
 268           wchar_t c = unicodePassword[i];
 269           ((Byte *)buffer)[i * 2] = (Byte)c;
 270           ((Byte *)buffer)[i * 2 + 1] = (Byte)(c >> 8);
 271         }
 272         RINOK(cryptoSetPassword->CryptoSetPassword(
 273           (const Byte *)buffer, sizeInBytes));
 274       }
 275     }
 276     #endif
 277
 278     coderIndex++;
 279
 280     UInt32 numInStreams = (UInt32)coderInfo.NumInStreams;
 281     UInt32 numOutStreams = (UInt32)coderInfo.NumOutStreams;
 282     CRecordVector<const UInt64 *> packSizesPointers;
 283     CRecordVector<const UInt64 *> unPackSizesPointers;
 284     packSizesPointers.Reserve(numInStreams);
 285     unPackSizesPointers.Reserve(numOutStreams);
 286     UInt32 j;
 287     for (j = 0; j < numOutStreams; j++, unPackStreamIndex++)
 288       unPackSizesPointers.Add(&folderInfo.UnPackSizes[unPackStreamIndex]);
 289
 290     for (j = 0; j < numInStreams; j++, packStreamIndex++)
 291     {
 292       int bindPairIndex = folderInfo.FindBindPairForInStream(packStreamIndex);
 293       if (bindPairIndex >= 0)
 294         packSizesPointers.Add(
 295         &folderInfo.UnPackSizes[(UInt32)folderInfo.BindPairs[bindPairIndex].OutIndex]);
 296       else
 297       {
 298         int index = folderInfo.FindPackStreamArrayIndex(packStreamIndex);
 299         if (index < 0)
 300           return E_FAIL;
 301         packSizesPointers.Add(&packSizes[index]);
 302       }
 303     }
 304
 305     _mixerCoderCommon->SetCoderInfo(i,
 306         &packSizesPointers.Front(),
 307         &unPackSizesPointers.Front());
 308   }
 309   UInt32 mainCoder, temp;
 310   bindInfo.FindOutStream(bindInfo.OutStreams[0], mainCoder, temp);
 311
 312   if (_multiThread)
 313     _mixerCoderMTSpec->SetProgressCoderIndex(mainCoder);
 314   /*
 315   else
 316     _mixerCoderSTSpec->SetProgressCoderIndex(mainCoder);;
 317   */
 318
 319   if (numCoders == 0)
 320     return 0;
 321   CRecordVector<ISequentialInStream *> inStreamPointers;
 322   inStreamPointers.Reserve(inStreams.Size());
 323   for (i = 0; i < inStreams.Size(); i++)
 324     inStreamPointers.Add(inStreams[i]);
 325   ISequentialOutStream *outStreamPointer = outStream;
 326   return _mixerCoder->Code(&inStreamPointers.Front(), NULL,
 327     inStreams.Size(), &outStreamPointer, NULL, 1, compressProgress);
 328 }
 329
 330 }}