vcs.maemo.org Git - physicsfs/blob - lzma/CPP/7zip/Archive/Common/HandlerOut.cpp

   1 // HandlerOutCommon.cpp
   2
   3 #include "StdAfx.h"
   4
   5 #include "HandlerOut.h"
   6 #include "../../../Windows/PropVariant.h"
   7 #include "../../../Common/StringToInt.h"
   8 #include "../../ICoder.h"
   9 #include "../Common/ParseProperties.h"
  10
  11 #ifdef COMPRESS_MT
  12 #include "../../../Windows/System.h"
  13 #endif
  14
  15 using namespace NWindows;
  16
  17 namespace NArchive {
  18
  19 static const wchar_t *kCopyMethod = L"Copy";
  20 static const wchar_t *kLZMAMethodName = L"LZMA";
  21 static const wchar_t *kLZMA2MethodName = L"LZMA2";
  22 static const wchar_t *kBZip2MethodName = L"BZip2";
  23 static const wchar_t *kPpmdMethodName = L"PPMd";
  24 static const wchar_t *kDeflateMethodName = L"Deflate";
  25 static const wchar_t *kDeflate64MethodName = L"Deflate64";
  26
  27 static const wchar_t *kLzmaMatchFinderX1 = L"HC4";
  28 static const wchar_t *kLzmaMatchFinderX5 = L"BT4";
  29
  30 static const UInt32 kLzmaAlgoX1 = 0;
  31 static const UInt32 kLzmaAlgoX5 = 1;
  32
  33 static const UInt32 kLzmaDicSizeX1 = 1 << 16;
  34 static const UInt32 kLzmaDicSizeX3 = 1 << 20;
  35 static const UInt32 kLzmaDicSizeX5 = 1 << 24;
  36 static const UInt32 kLzmaDicSizeX7 = 1 << 25;
  37 static const UInt32 kLzmaDicSizeX9 = 1 << 26;
  38
  39 static const UInt32 kLzmaFastBytesX1 = 32;
  40 static const UInt32 kLzmaFastBytesX7 = 64;
  41
  42 static const UInt32 kPpmdMemSizeX1 = (1 << 22);
  43 static const UInt32 kPpmdMemSizeX5 = (1 << 24);
  44 static const UInt32 kPpmdMemSizeX7 = (1 << 26);
  45 static const UInt32 kPpmdMemSizeX9 = (192 << 20);
  46
  47 static const UInt32 kPpmdOrderX1 = 4;
  48 static const UInt32 kPpmdOrderX5 = 6;
  49 static const UInt32 kPpmdOrderX7 = 16;
  50 static const UInt32 kPpmdOrderX9 = 32;
  51
  52 static const UInt32 kDeflateAlgoX1 = 0;
  53 static const UInt32 kDeflateAlgoX5 = 1;
  54
  55 static const UInt32 kDeflateFastBytesX1 = 32;
  56 static const UInt32 kDeflateFastBytesX7 = 64;
  57 static const UInt32 kDeflateFastBytesX9 = 128;
  58
  59 static const UInt32 kDeflatePassesX1 = 1;
  60 static const UInt32 kDeflatePassesX7 = 3;
  61 static const UInt32 kDeflatePassesX9 = 10;
  62
  63 static const UInt32 kBZip2NumPassesX1 = 1;
  64 static const UInt32 kBZip2NumPassesX7 = 2;
  65 static const UInt32 kBZip2NumPassesX9 = 7;
  66
  67 static const UInt32 kBZip2DicSizeX1 = 100000;
  68 static const UInt32 kBZip2DicSizeX3 = 500000;
  69 static const UInt32 kBZip2DicSizeX5 = 900000;
  70
  71 static const wchar_t *kDefaultMethodName = kLZMAMethodName;
  72
  73 static const wchar_t *kLzmaMatchFinderForHeaders = L"BT2";
  74 static const UInt32 kDictionaryForHeaders = 1 << 20;
  75 static const UInt32 kNumFastBytesForHeaders = 273;
  76 static const UInt32 kAlgorithmForHeaders = kLzmaAlgoX5;
  77
  78 static bool AreEqual(const UString &methodName, const wchar_t *s)
  79   { return (methodName.CompareNoCase(s) == 0); }
  80
  81 static inline bool IsLZMAMethod(const UString &methodName)
  82 {
  83   return
  84     AreEqual(methodName, kLZMAMethodName) ||
  85     AreEqual(methodName, kLZMA2MethodName);
  86 }
  87
  88 static inline bool IsBZip2Method(const UString &methodName)
  89   { return AreEqual(methodName, kBZip2MethodName); }
  90
  91 static inline bool IsPpmdMethod(const UString &methodName)
  92   { return AreEqual(methodName, kPpmdMethodName); }
  93
  94 static inline bool IsDeflateMethod(const UString &methodName)
  95 {
  96   return
  97     AreEqual(methodName, kDeflateMethodName) ||
  98     AreEqual(methodName, kDeflate64MethodName);
  99 }
 100
 101 struct CNameToPropID
 102 {
 103   PROPID PropID;
 104   VARTYPE VarType;
 105   const wchar_t *Name;
 106 };
 107
 108 CNameToPropID g_NameToPropID[] =
 109 {
 110   { NCoderPropID::kOrder, VT_UI4, L"O" },
 111   { NCoderPropID::kPosStateBits, VT_UI4, L"PB" },
 112   { NCoderPropID::kLitContextBits, VT_UI4, L"LC" },
 113   { NCoderPropID::kLitPosBits, VT_UI4, L"LP" },
 114   { NCoderPropID::kEndMarker, VT_BOOL, L"eos" },
 115
 116   { NCoderPropID::kNumPasses, VT_UI4, L"Pass" },
 117   { NCoderPropID::kNumFastBytes, VT_UI4, L"fb" },
 118   { NCoderPropID::kMatchFinderCycles, VT_UI4, L"mc" },
 119   { NCoderPropID::kAlgorithm, VT_UI4, L"a" },
 120   { NCoderPropID::kMatchFinder, VT_BSTR, L"mf" },
 121   { NCoderPropID::kNumThreads, VT_UI4, L"mt" }
 122 };
 123
 124 static bool ConvertProperty(PROPVARIANT srcProp, VARTYPE varType, NCOM::CPropVariant &destProp)
 125 {
 126   if (varType == srcProp.vt)
 127   {
 128     destProp = srcProp;
 129     return true;
 130   }
 131   if (varType == VT_UI1)
 132   {
 133     if (srcProp.vt == VT_UI4)
 134     {
 135       UInt32 value = srcProp.ulVal;
 136       if (value > 0xFF)
 137         return false;
 138       destProp = (Byte)value;
 139       return true;
 140     }
 141   }
 142   else if (varType == VT_BOOL)
 143   {
 144     bool res;
 145     if (SetBoolProperty(res, srcProp) != S_OK)
 146       return false;
 147     destProp = res;
 148     return true;
 149   }
 150   return false;
 151 }
 152
 153 static int FindPropIdFromStringName(const UString &name)
 154 {
 155   for (int i = 0; i < sizeof(g_NameToPropID) / sizeof(g_NameToPropID[0]); i++)
 156     if (name.CompareNoCase(g_NameToPropID[i].Name) == 0)
 157       return i;
 158   return -1;
 159 }
 160
 161 static void SetOneMethodProp(COneMethodInfo &oneMethodInfo, PROPID propID,
 162     const NWindows::NCOM::CPropVariant &value)
 163 {
 164   for (int j = 0; j < oneMethodInfo.Properties.Size(); j++)
 165     if (oneMethodInfo.Properties[j].Id == propID)
 166       return;
 167   CProp property;
 168   property.Id = propID;
 169   property.Value = value;
 170   oneMethodInfo.Properties.Add(property);
 171 }
 172
 173 void COutHandler::SetCompressionMethod2(COneMethodInfo &oneMethodInfo
 174     #ifdef COMPRESS_MT
 175     , UInt32 numThreads
 176     #endif
 177     )
 178 {
 179   UInt32 level = _level;
 180   if (oneMethodInfo.MethodName.IsEmpty())
 181     oneMethodInfo.MethodName = kDefaultMethodName;
 182
 183   if (IsLZMAMethod(oneMethodInfo.MethodName))
 184   {
 185     UInt32 dicSize =
 186       (level >= 9 ? kLzmaDicSizeX9 :
 187       (level >= 7 ? kLzmaDicSizeX7 :
 188       (level >= 5 ? kLzmaDicSizeX5 :
 189       (level >= 3 ? kLzmaDicSizeX3 :
 190                     kLzmaDicSizeX1))));
 191
 192     UInt32 algo =
 193       (level >= 5 ? kLzmaAlgoX5 :
 194                     kLzmaAlgoX1);
 195
 196     UInt32 fastBytes =
 197       (level >= 7 ? kLzmaFastBytesX7 :
 198                     kLzmaFastBytesX1);
 199
 200     const wchar_t *matchFinder =
 201       (level >= 5 ? kLzmaMatchFinderX5 :
 202                     kLzmaMatchFinderX1);
 203
 204     SetOneMethodProp(oneMethodInfo, NCoderPropID::kDictionarySize, dicSize);
 205     SetOneMethodProp(oneMethodInfo, NCoderPropID::kAlgorithm, algo);
 206     SetOneMethodProp(oneMethodInfo, NCoderPropID::kNumFastBytes, fastBytes);
 207     SetOneMethodProp(oneMethodInfo, NCoderPropID::kMatchFinder, matchFinder);
 208     #ifdef COMPRESS_MT
 209     SetOneMethodProp(oneMethodInfo, NCoderPropID::kNumThreads, numThreads);
 210     #endif
 211   }
 212   else if (IsDeflateMethod(oneMethodInfo.MethodName))
 213   {
 214     UInt32 fastBytes =
 215       (level >= 9 ? kDeflateFastBytesX9 :
 216       (level >= 7 ? kDeflateFastBytesX7 :
 217                     kDeflateFastBytesX1));
 218
 219     UInt32 numPasses =
 220       (level >= 9 ? kDeflatePassesX9 :
 221       (level >= 7 ? kDeflatePassesX7 :
 222                     kDeflatePassesX1));
 223
 224     UInt32 algo =
 225       (level >= 5 ? kDeflateAlgoX5 :
 226                     kDeflateAlgoX1);
 227
 228     SetOneMethodProp(oneMethodInfo, NCoderPropID::kAlgorithm, algo);
 229     SetOneMethodProp(oneMethodInfo, NCoderPropID::kNumFastBytes, fastBytes);
 230     SetOneMethodProp(oneMethodInfo, NCoderPropID::kNumPasses, numPasses);
 231   }
 232   else if (IsBZip2Method(oneMethodInfo.MethodName))
 233   {
 234     UInt32 numPasses =
 235       (level >= 9 ? kBZip2NumPassesX9 :
 236       (level >= 7 ? kBZip2NumPassesX7 :
 237                     kBZip2NumPassesX1));
 238
 239     UInt32 dicSize =
 240       (level >= 5 ? kBZip2DicSizeX5 :
 241       (level >= 3 ? kBZip2DicSizeX3 :
 242                     kBZip2DicSizeX1));
 243
 244     SetOneMethodProp(oneMethodInfo, NCoderPropID::kNumPasses, numPasses);
 245     SetOneMethodProp(oneMethodInfo, NCoderPropID::kDictionarySize, dicSize);
 246     #ifdef COMPRESS_MT
 247     SetOneMethodProp(oneMethodInfo, NCoderPropID::kNumThreads, numThreads);
 248     #endif
 249   }
 250   else if (IsPpmdMethod(oneMethodInfo.MethodName))
 251   {
 252     UInt32 useMemSize =
 253       (level >= 9 ? kPpmdMemSizeX9 :
 254       (level >= 7 ? kPpmdMemSizeX7 :
 255       (level >= 5 ? kPpmdMemSizeX5 :
 256                     kPpmdMemSizeX1)));
 257
 258     UInt32 order =
 259       (level >= 9 ? kPpmdOrderX9 :
 260       (level >= 7 ? kPpmdOrderX7 :
 261       (level >= 5 ? kPpmdOrderX5 :
 262                     kPpmdOrderX1)));
 263
 264     SetOneMethodProp(oneMethodInfo, NCoderPropID::kUsedMemorySize, useMemSize);
 265     SetOneMethodProp(oneMethodInfo, NCoderPropID::kOrder, order);
 266   }
 267 }
 268
 269 static void SplitParams(const UString &srcString, UStringVector &subStrings)
 270 {
 271   subStrings.Clear();
 272   UString name;
 273   int len = srcString.Length();
 274   if (len == 0)
 275     return;
 276   for (int i = 0; i < len; i++)
 277   {
 278     wchar_t c = srcString[i];
 279     if (c == L':')
 280     {
 281       subStrings.Add(name);
 282       name.Empty();
 283     }
 284     else
 285       name += c;
 286   }
 287   subStrings.Add(name);
 288 }
 289
 290 static void SplitParam(const UString &param, UString &name, UString &value)
 291 {
 292   int eqPos = param.Find(L'=');
 293   if (eqPos >= 0)
 294   {
 295     name = param.Left(eqPos);
 296     value = param.Mid(eqPos + 1);
 297     return;
 298   }
 299   for(int i = 0; i < param.Length(); i++)
 300   {
 301     wchar_t c = param[i];
 302     if (c >= L'0' && c <= L'9')
 303     {
 304       name = param.Left(i);
 305       value = param.Mid(i);
 306       return;
 307     }
 308   }
 309   name = param;
 310 }
 311
 312 HRESULT COutHandler::SetParam(COneMethodInfo &oneMethodInfo, const UString &name, const UString &value)
 313 {
 314   CProp property;
 315   if (
 316     name.CompareNoCase(L"D") == 0 ||
 317     name.CompareNoCase(L"MEM") == 0)
 318   {
 319     UInt32 dicSize;
 320     RINOK(ParsePropDictionaryValue(value, dicSize));
 321     if (name.CompareNoCase(L"D") == 0)
 322       property.Id = NCoderPropID::kDictionarySize;
 323     else
 324       property.Id = NCoderPropID::kUsedMemorySize;
 325     property.Value = dicSize;
 326     oneMethodInfo.Properties.Add(property);
 327   }
 328   else
 329   {
 330     int index = FindPropIdFromStringName(name);
 331     if (index < 0)
 332       return E_INVALIDARG;
 333
 334     const CNameToPropID &nameToPropID = g_NameToPropID[index];
 335     property.Id = nameToPropID.PropID;
 336
 337     NCOM::CPropVariant propValue;
 338
 339     if (nameToPropID.VarType == VT_BSTR)
 340       propValue = value;
 341     else if (nameToPropID.VarType == VT_BOOL)
 342     {
 343       bool res;
 344       if (!StringToBool(value, res))
 345         return E_INVALIDARG;
 346       propValue = res;
 347     }
 348     else
 349     {
 350       UInt32 number;
 351       if (ParseStringToUInt32(value, number) == value.Length())
 352         propValue = number;
 353       else
 354         propValue = value;
 355     }
 356
 357     if (!ConvertProperty(propValue, nameToPropID.VarType, property.Value))
 358       return E_INVALIDARG;
 359
 360     oneMethodInfo.Properties.Add(property);
 361   }
 362   return S_OK;
 363 }
 364
 365 HRESULT COutHandler::SetParams(COneMethodInfo &oneMethodInfo, const UString &srcString)
 366 {
 367   UStringVector params;
 368   SplitParams(srcString, params);
 369   if (params.Size() > 0)
 370     oneMethodInfo.MethodName = params[0];
 371   for (int i = 1; i < params.Size(); i++)
 372   {
 373     const UString &param = params[i];
 374     UString name, value;
 375     SplitParam(param, name, value);
 376     RINOK(SetParam(oneMethodInfo, name, value));
 377   }
 378   return S_OK;
 379 }
 380
 381 HRESULT COutHandler::SetSolidSettings(const UString &s)
 382 {
 383   bool res;
 384   if (StringToBool(s, res))
 385   {
 386     if (res)
 387       InitSolid();
 388     else
 389       _numSolidFiles = 1;
 390     return S_OK;
 391   }
 392   UString s2 = s;
 393   s2.MakeUpper();
 394   for (int i = 0; i < s2.Length();)
 395   {
 396     const wchar_t *start = ((const wchar_t *)s2) + i;
 397     const wchar_t *end;
 398     UInt64 v = ConvertStringToUInt64(start, &end);
 399     if (start == end)
 400     {
 401       if (s2[i++] != 'E')
 402         return E_INVALIDARG;
 403       _solidExtension = true;
 404       continue;
 405     }
 406     i += (int)(end - start);
 407     if (i == s2.Length())
 408       return E_INVALIDARG;
 409     wchar_t c = s2[i++];
 410     switch(c)
 411     {
 412       case 'F':
 413         if (v < 1)
 414           v = 1;
 415         _numSolidFiles = v;
 416         break;
 417       case 'B':
 418         _numSolidBytes = v;
 419         _numSolidBytesDefined = true;
 420         break;
 421       case 'K':
 422         _numSolidBytes = (v << 10);
 423         _numSolidBytesDefined = true;
 424         break;
 425       case 'M':
 426         _numSolidBytes = (v << 20);
 427         _numSolidBytesDefined = true;
 428         break;
 429       case 'G':
 430         _numSolidBytes = (v << 30);
 431         _numSolidBytesDefined = true;
 432         break;
 433       default:
 434         return E_INVALIDARG;
 435     }
 436   }
 437   return S_OK;
 438 }
 439
 440 HRESULT COutHandler::SetSolidSettings(const PROPVARIANT &value)
 441 {
 442   switch(value.vt)
 443   {
 444     case VT_EMPTY:
 445       InitSolid();
 446       return S_OK;
 447     case VT_BSTR:
 448       return SetSolidSettings(value.bstrVal);
 449     default:
 450       return E_INVALIDARG;
 451   }
 452 }
 453
 454 void COutHandler::Init()
 455 {
 456   _removeSfxBlock = false;
 457   _compressHeaders = true;
 458   _encryptHeaders = false;
 459
 460   WriteModified = true;
 461   WriteCreated = false;
 462   WriteAccessed = false;
 463
 464   #ifdef COMPRESS_MT
 465   _numThreads = NWindows::NSystem::GetNumberOfProcessors();
 466   #endif
 467
 468   _level = 5;
 469   _autoFilter = true;
 470   _volumeMode = false;
 471   _crcSize = 4;
 472   InitSolid();
 473 }
 474
 475 void COutHandler::BeforeSetProperty()
 476 {
 477   Init();
 478   #ifdef COMPRESS_MT
 479   numProcessors = NSystem::GetNumberOfProcessors();
 480   #endif
 481
 482   mainDicSize = 0xFFFFFFFF;
 483   mainDicMethodIndex = 0xFFFFFFFF;
 484   minNumber = 0;
 485   _crcSize = 4;
 486 }
 487
 488 HRESULT COutHandler::SetProperty(const wchar_t *nameSpec, const PROPVARIANT &value)
 489 {
 490   UString name = nameSpec;
 491   name.MakeUpper();
 492   if (name.IsEmpty())
 493     return E_INVALIDARG;
 494
 495   if (name[0] == 'X')
 496   {
 497     name.Delete(0);
 498     _level = 9;
 499     return ParsePropValue(name, value, _level);
 500   }
 501
 502   if (name[0] == L'S')
 503   {
 504     name.Delete(0);
 505     if (name.IsEmpty())
 506       return SetSolidSettings(value);
 507     if (value.vt != VT_EMPTY)
 508       return E_INVALIDARG;
 509     return SetSolidSettings(name);
 510   }
 511
 512   if (name == L"CRC")
 513   {
 514     _crcSize = 4;
 515     name.Delete(0, 3);
 516     return ParsePropValue(name, value, _crcSize);
 517   }
 518
 519   UInt32 number;
 520   int index = ParseStringToUInt32(name, number);
 521   UString realName = name.Mid(index);
 522   if (index == 0)
 523   {
 524     if(name.Left(2).CompareNoCase(L"MT") == 0)
 525     {
 526       #ifdef COMPRESS_MT
 527       RINOK(ParseMtProp(name.Mid(2), value, numProcessors, _numThreads));
 528       #endif
 529       return S_OK;
 530     }
 531     if (name.CompareNoCase(L"RSFX") == 0)
 532       return SetBoolProperty(_removeSfxBlock, value);
 533     if (name.CompareNoCase(L"F") == 0)
 534       return SetBoolProperty(_autoFilter, value);
 535     if (name.CompareNoCase(L"HC") == 0)
 536       return SetBoolProperty(_compressHeaders, value);
 537     if (name.CompareNoCase(L"HCF") == 0)
 538     {
 539       bool compressHeadersFull = true;
 540       RINOK(SetBoolProperty(compressHeadersFull, value));
 541       if (!compressHeadersFull)
 542         return E_INVALIDARG;
 543       return S_OK;
 544     }
 545     if (name.CompareNoCase(L"HE") == 0)
 546       return SetBoolProperty(_encryptHeaders, value);
 547     if (name.CompareNoCase(L"TM") == 0)
 548       return SetBoolProperty(WriteModified, value);
 549     if (name.CompareNoCase(L"TC") == 0)
 550       return SetBoolProperty(WriteCreated, value);
 551     if (name.CompareNoCase(L"TA") == 0)
 552       return SetBoolProperty(WriteAccessed, value);
 553     if (name.CompareNoCase(L"V") == 0)
 554       return SetBoolProperty(_volumeMode, value);
 555     number = 0;
 556   }
 557   if (number > 10000)
 558     return E_FAIL;
 559   if (number < minNumber)
 560     return E_INVALIDARG;
 561   number -= minNumber;
 562   for(int j = _methods.Size(); j <= (int)number; j++)
 563   {
 564     COneMethodInfo oneMethodInfo;
 565     _methods.Add(oneMethodInfo);
 566   }
 567
 568   COneMethodInfo &oneMethodInfo = _methods[number];
 569
 570   if (realName.Length() == 0)
 571   {
 572     if (value.vt != VT_BSTR)
 573       return E_INVALIDARG;
 574
 575     RINOK(SetParams(oneMethodInfo, value.bstrVal));
 576   }
 577   else
 578   {
 579     CProp property;
 580     if (realName.Left(1).CompareNoCase(L"D") == 0)
 581     {
 582       UInt32 dicSize;
 583       RINOK(ParsePropDictionaryValue(realName.Mid(1), value, dicSize));
 584       property.Id = NCoderPropID::kDictionarySize;
 585       property.Value = dicSize;
 586       oneMethodInfo.Properties.Add(property);
 587       if (number <= mainDicMethodIndex)
 588         mainDicSize = dicSize;
 589     }
 590     else if (realName.Left(3).CompareNoCase(L"MEM") == 0)
 591     {
 592       UInt32 dicSize;
 593       RINOK(ParsePropDictionaryValue(realName.Mid(3), value, dicSize));
 594       property.Id = NCoderPropID::kUsedMemorySize;
 595       property.Value = dicSize;
 596       oneMethodInfo.Properties.Add(property);
 597       if (number <= mainDicMethodIndex)
 598         mainDicSize = dicSize;
 599     }
 600     else
 601     {
 602       int index = FindPropIdFromStringName(realName);
 603       if (index < 0)
 604         return E_INVALIDARG;
 605
 606       const CNameToPropID &nameToPropID = g_NameToPropID[index];
 607       property.Id = nameToPropID.PropID;
 608
 609       if (!ConvertProperty(value, nameToPropID.VarType, property.Value))
 610         return E_INVALIDARG;
 611
 612       oneMethodInfo.Properties.Add(property);
 613     }
 614   }
 615   return S_OK;
 616 }
 617
 618 }