react-native-update 10.34.2 → 10.34.4

package/harmony/pushy/src/main/cpp/lzma/CPP/7zip/Archive/Common/CoderMixer2.cpp

@@ -0,0 +1,1125 @@
+// CoderMixer2.cpp
+
+#include "StdAfx.h"
+
+#include "CoderMixer2.h"
+
+#ifdef USE_MIXER_ST
+
+STDMETHODIMP CSequentialInStreamCalcSize::Read(void *data, UInt32 size, UInt32 *processedSize)
+{
+  UInt32 realProcessed = 0;
+  HRESULT result = S_OK;
+  if (_stream)
+    result = _stream->Read(data, size, &realProcessed);
+  _size += realProcessed;
+  if (size != 0 && realProcessed == 0)
+    _wasFinished = true;
+  if (processedSize)
+    *processedSize = realProcessed;
+  return result;
+}
+
+
+STDMETHODIMP COutStreamCalcSize::Write(const void *data, UInt32 size, UInt32 *processedSize)
+{
+  HRESULT result = S_OK;
+  if (_stream)
+    result = _stream->Write(data, size, &size);
+  _size += size;
+  if (processedSize)
+    *processedSize = size;
+  return result;
+}
+
+STDMETHODIMP COutStreamCalcSize::OutStreamFinish()
+{
+  HRESULT result = S_OK;
+  if (_stream)
+  {
+    CMyComPtr<IOutStreamFinish> outStreamFinish;
+    _stream.QueryInterface(IID_IOutStreamFinish, &outStreamFinish);
+    if (outStreamFinish)
+      result = outStreamFinish->OutStreamFinish();
+  }
+  return result;
+}
+
+#endif
+
+
+
+
+namespace NCoderMixer2 {
+
+static void BoolVector_Fill_False(CBoolVector &v, unsigned size)
+{
+  v.ClearAndSetSize(size);
+  bool *p = &v[0];
+  for (unsigned i = 0; i < size; i++)
+    p[i] = false;
+}
+
+
+HRESULT CCoder::CheckDataAfterEnd(bool &dataAfterEnd_Error /* , bool &InternalPackSizeError */) const
+{
+  if (Coder)
+  {
+    if (PackSizePointers.IsEmpty() || !PackSizePointers[0])
+      return S_OK;
+    CMyComPtr<ICompressGetInStreamProcessedSize> getInStreamProcessedSize;
+    Coder.QueryInterface(IID_ICompressGetInStreamProcessedSize, (void **)&getInStreamProcessedSize);
+    // if (!getInStreamProcessedSize) return E_FAIL;
+    if (getInStreamProcessedSize)
+    {
+      UInt64 processed;
+      RINOK(getInStreamProcessedSize->GetInStreamProcessedSize(&processed));
+      if (processed != (UInt64)(Int64)-1)
+      {
+        const UInt64 size = PackSizes[0];
+        if (processed < size && Finish)
+          dataAfterEnd_Error = true;
+        if (processed > size)
+        {
+          // InternalPackSizeError = true;
+          // return S_FALSE;
+        }
+      }
+    }
+  }
+  else if (Coder2)
+  {
+    CMyComPtr<ICompressGetInStreamProcessedSize2> getInStreamProcessedSize2;
+    Coder2.QueryInterface(IID_ICompressGetInStreamProcessedSize2, (void **)&getInStreamProcessedSize2);
+    if (getInStreamProcessedSize2)
+    FOR_VECTOR (i, PackSizePointers)
+    {
+      if (!PackSizePointers[i])
+        continue;
+      UInt64 processed;
+      RINOK(getInStreamProcessedSize2->GetInStreamProcessedSize2(i, &processed));
+      if (processed != (UInt64)(Int64)-1)
+      {
+        const UInt64 size = PackSizes[i];
+        if (processed < size && Finish)
+          dataAfterEnd_Error = true;
+        else if (processed > size)
+        {
+          // InternalPackSizeError = true;
+          // return S_FALSE;
+        }
+      }
+    }
+  }
+
+  return S_OK;
+}
+
+
+
+class CBondsChecks
+{
+  CBoolVector _coderUsed;
+
+  bool Init();
+  bool CheckCoder(unsigned coderIndex);
+public:
+  const CBindInfo *BindInfo;
+
+  bool Check();
+};
+
+bool CBondsChecks::CheckCoder(unsigned coderIndex)
+{
+  const CCoderStreamsInfo &coder = BindInfo->Coders[coderIndex];
+
+  if (coderIndex >= _coderUsed.Size() || _coderUsed[coderIndex])
+    return false;
+  _coderUsed[coderIndex] = true;
+  
+  UInt32 start = BindInfo->Coder_to_Stream[coderIndex];
+
+  for (unsigned i = 0; i < coder.NumStreams; i++)
+  {
+    UInt32 ind = start + i;
+    
+    if (BindInfo->IsStream_in_PackStreams(ind))
+      continue;
+    
+    int bond = BindInfo->FindBond_for_PackStream(ind);
+    if (bond < 0)
+      return false;
+    if (!CheckCoder(BindInfo->Bonds[bond].UnpackIndex))
+      return false;
+  }
+  
+  return true;
+}
+
+bool CBondsChecks::Check()
+{
+  BoolVector_Fill_False(_coderUsed, BindInfo->Coders.Size());
+  
+  if (!CheckCoder(BindInfo->UnpackCoder))
+    return false;
+
+  FOR_VECTOR(i, _coderUsed)
+    if (!_coderUsed[i])
+      return false;
+
+  return true;
+}
+
+void CBindInfo::ClearMaps()
+{
+  Coder_to_Stream.Clear();
+  Stream_to_Coder.Clear();
+}
+
+bool CBindInfo::CalcMapsAndCheck()
+{
+  ClearMaps();
+
+  UInt32 numStreams = 0;
+
+  if (Coders.Size() == 0)
+    return false;
+  if (Coders.Size() - 1 != Bonds.Size())
+    return false;
+
+  FOR_VECTOR(i, Coders)
+  {
+    Coder_to_Stream.Add(numStreams);
+    
+    const CCoderStreamsInfo &c = Coders[i];
+    
+    for (unsigned j = 0; j < c.NumStreams; j++)
+      Stream_to_Coder.Add(i);
+
+    numStreams += c.NumStreams;
+  }
+
+  if (numStreams != GetNum_Bonds_and_PackStreams())
+    return false;
+
+  CBondsChecks bc;
+  bc.BindInfo = this;
+  return bc.Check();
+}
+
+
+void CCoder::SetCoderInfo(const UInt64 *unpackSize, const UInt64 * const *packSizes, bool finish)
+{
+  Finish = finish;
+
+  if (unpackSize)
+  {
+    UnpackSize = *unpackSize;
+    UnpackSizePointer = &UnpackSize;
+  }
+  else
+  {
+    UnpackSize = 0;
+    UnpackSizePointer = NULL;
+  }
+  
+  PackSizes.ClearAndSetSize((unsigned)NumStreams);
+  PackSizePointers.ClearAndSetSize((unsigned)NumStreams);
+  
+  for (unsigned i = 0; i < NumStreams; i++)
+  {
+    if (packSizes && packSizes[i])
+    {
+      PackSizes[i] = *(packSizes[i]);
+      PackSizePointers[i] = &PackSizes[i];
+    }
+    else
+    {
+      PackSizes[i] = 0;
+      PackSizePointers[i] = NULL;
+    }
+  }
+}
+
+bool CMixer::Is_UnpackSize_Correct_for_Coder(UInt32 coderIndex)
+{
+  if (coderIndex == _bi.UnpackCoder)
+    return true;
+  
+  int bond = _bi.FindBond_for_UnpackStream(coderIndex);
+  if (bond < 0)
+    throw 20150213;
+  
+  /*
+  UInt32 coderIndex, coderStreamIndex;
+  _bi.GetCoder_for_Stream(_bi.Bonds[bond].PackIndex, coderIndex, coderStreamIndex);
+  */
+  UInt32 nextCoder = _bi.Stream_to_Coder[_bi.Bonds[bond].PackIndex];
+  
+  if (!IsFilter_Vector[nextCoder])
+    return false;
+  
+  return Is_UnpackSize_Correct_for_Coder(nextCoder);
+}
+
+bool CMixer::Is_PackSize_Correct_for_Stream(UInt32 streamIndex)
+{
+  if (_bi.IsStream_in_PackStreams(streamIndex))
+    return true;
+  
+  int bond = _bi.FindBond_for_PackStream(streamIndex);
+  if (bond < 0)
+    throw 20150213;
+
+  UInt32 nextCoder = _bi.Bonds[bond].UnpackIndex;
+
+  if (!IsFilter_Vector[nextCoder])
+    return false;
+  
+  return Is_PackSize_Correct_for_Coder(nextCoder);
+}
+
+bool CMixer::Is_PackSize_Correct_for_Coder(UInt32 coderIndex)
+{
+  UInt32 startIndex = _bi.Coder_to_Stream[coderIndex];
+  UInt32 numStreams = _bi.Coders[coderIndex].NumStreams;
+  for (UInt32 i = 0; i < numStreams; i++)
+    if (!Is_PackSize_Correct_for_Stream(startIndex + i))
+      return false;
+  return true;
+}
+
+bool CMixer::IsThere_ExternalCoder_in_PackTree(UInt32 coderIndex)
+{
+  if (IsExternal_Vector[coderIndex])
+    return true;
+  UInt32 startIndex = _bi.Coder_to_Stream[coderIndex];
+  UInt32 numStreams = _bi.Coders[coderIndex].NumStreams;
+  for (UInt32 i = 0; i < numStreams; i++)
+  {
+    UInt32 si = startIndex + i;
+    if (_bi.IsStream_in_PackStreams(si))
+      continue;
+  
+    int bond = _bi.FindBond_for_PackStream(si);
+    if (bond < 0)
+      throw 20150213;
+
+    if (IsThere_ExternalCoder_in_PackTree(_bi.Bonds[bond].UnpackIndex))
+      return true;
+  }
+  return false;
+}
+
+
+
+
+#ifdef USE_MIXER_ST
+
+CMixerST::CMixerST(bool encodeMode):
+    CMixer(encodeMode)
+    {}
+
+CMixerST::~CMixerST() {}
+
+void CMixerST::AddCoder(const CCreatedCoder &cod)
+{
+  IsFilter_Vector.Add(cod.IsFilter);
+  IsExternal_Vector.Add(cod.IsExternal);
+  // const CCoderStreamsInfo &c = _bi.Coders[_coders.Size()];
+  CCoderST &c2 = _coders.AddNew();
+  c2.NumStreams = cod.NumStreams;
+  c2.Coder = cod.Coder;
+  c2.Coder2 = cod.Coder2;
+
+  /*
+  if (isFilter)
+  {
+    c2.CanRead = true;
+    c2.CanWrite = true;
+  }
+  else
+  */
+  {
+    IUnknown *unk = (cod.Coder ? (IUnknown *)cod.Coder : (IUnknown *)cod.Coder2);
+    {
+      CMyComPtr<ISequentialInStream> s;
+      unk->QueryInterface(IID_ISequentialInStream, (void**)&s);
+      c2.CanRead = (s != NULL);
+    }
+    {
+      CMyComPtr<ISequentialOutStream> s;
+      unk->QueryInterface(IID_ISequentialOutStream, (void**)&s);
+      c2.CanWrite = (s != NULL);
+    }
+  }
+}
+
+CCoder &CMixerST::GetCoder(unsigned index)
+{
+  return _coders[index];
+}
+
+void CMixerST::ReInit() {}
+
+HRESULT CMixerST::GetInStream2(
+    ISequentialInStream * const *inStreams, /* const UInt64 * const *inSizes, */
+    UInt32 outStreamIndex, ISequentialInStream **inStreamRes)
+{
+  UInt32 coderIndex = outStreamIndex, coderStreamIndex = 0;
+
+  if (EncodeMode)
+  {
+    _bi.GetCoder_for_Stream(outStreamIndex, coderIndex, coderStreamIndex);
+    if (coderStreamIndex != 0)
+      return E_NOTIMPL;
+  }
+
+  const CCoder &coder = _coders[coderIndex];
+  
+  CMyComPtr<ISequentialInStream> seqInStream;
+  coder.QueryInterface(IID_ISequentialInStream, (void **)&seqInStream);
+  if (!seqInStream)
+    return E_NOTIMPL;
+
+  UInt32 numInStreams = EncodeMode ? 1 : coder.NumStreams;
+  UInt32 startIndex = EncodeMode ? coderIndex : _bi.Coder_to_Stream[coderIndex];
+
+  bool isSet = false;
+  
+  if (numInStreams == 1)
+  {
+    CMyComPtr<ICompressSetInStream> setStream;
+    coder.QueryInterface(IID_ICompressSetInStream, (void **)&setStream);
+    if (setStream)
+    {
+      CMyComPtr<ISequentialInStream> seqInStream2;
+      RINOK(GetInStream(inStreams, /* inSizes, */ startIndex + 0, &seqInStream2));
+      RINOK(setStream->SetInStream(seqInStream2));
+      isSet = true;
+    }
+  }
+  
+  if (!isSet && numInStreams != 0)
+  {
+    CMyComPtr<ICompressSetInStream2> setStream2;
+    coder.QueryInterface(IID_ICompressSetInStream2, (void **)&setStream2);
+    if (!setStream2)
+      return E_NOTIMPL;
+    
+    for (UInt32 i = 0; i < numInStreams; i++)
+    {
+      CMyComPtr<ISequentialInStream> seqInStream2;
+      RINOK(GetInStream(inStreams, /* inSizes, */ startIndex + i, &seqInStream2));
+      RINOK(setStream2->SetInStream2(i, seqInStream2));
+    }
+  }
+
+  *inStreamRes = seqInStream.Detach();
+  return S_OK;
+}
+
+
+HRESULT CMixerST::GetInStream(
+    ISequentialInStream * const *inStreams, /* const UInt64 * const *inSizes, */
+    UInt32 inStreamIndex, ISequentialInStream **inStreamRes)
+{
+  CMyComPtr<ISequentialInStream> seqInStream;
+  
+  {
+    int index = -1;
+    if (EncodeMode)
+    {
+      if (_bi.UnpackCoder == inStreamIndex)
+        index = 0;
+    }
+    else
+      index = _bi.FindStream_in_PackStreams(inStreamIndex);
+
+    if (index >= 0)
+    {
+      seqInStream = inStreams[(unsigned)index];
+      *inStreamRes = seqInStream.Detach();
+      return S_OK;
+    }
+  }
+  
+  int bond = FindBond_for_Stream(
+      true, // forInputStream
+      inStreamIndex);
+  if (bond < 0)
+    return E_INVALIDARG;
+
+  RINOK(GetInStream2(inStreams, /* inSizes, */
+      _bi.Bonds[bond].Get_OutIndex(EncodeMode), &seqInStream));
+
+  while (_binderStreams.Size() <= (unsigned)bond)
+    _binderStreams.AddNew();
+  CStBinderStream &bs = _binderStreams[bond];
+
+  if (bs.StreamRef || bs.InStreamSpec)
+    return E_NOTIMPL;
+  
+  CSequentialInStreamCalcSize *spec = new CSequentialInStreamCalcSize;
+  bs.StreamRef = spec;
+  bs.InStreamSpec = spec;
+  
+  spec->SetStream(seqInStream);
+  spec->Init();
+  
+  seqInStream = bs.InStreamSpec;
+
+  *inStreamRes = seqInStream.Detach();
+  return S_OK;
+}
+
+
+HRESULT CMixerST::GetOutStream(
+    ISequentialOutStream * const *outStreams, /* const UInt64 * const *outSizes, */
+    UInt32 outStreamIndex, ISequentialOutStream **outStreamRes)
+{
+  CMyComPtr<ISequentialOutStream> seqOutStream;
+  
+  {
+    int index = -1;
+    if (!EncodeMode)
+    {
+      if (_bi.UnpackCoder == outStreamIndex)
+        index = 0;
+    }
+    else
+      index = _bi.FindStream_in_PackStreams(outStreamIndex);
+
+    if (index >= 0)
+    {
+      seqOutStream = outStreams[(unsigned)index];
+      *outStreamRes = seqOutStream.Detach();
+      return S_OK;
+    }
+  }
+  
+  int bond = FindBond_for_Stream(
+      false, // forInputStream
+      outStreamIndex);
+  if (bond < 0)
+    return E_INVALIDARG;
+
+  UInt32 inStreamIndex = _bi.Bonds[bond].Get_InIndex(EncodeMode);
+
+  UInt32 coderIndex = inStreamIndex;
+  UInt32 coderStreamIndex = 0;
+
+  if (!EncodeMode)
+    _bi.GetCoder_for_Stream(inStreamIndex, coderIndex, coderStreamIndex);
+
+  CCoder &coder = _coders[coderIndex];
+
+  /*
+  if (!coder.Coder)
+    return E_NOTIMPL;
+  */
+
+  coder.QueryInterface(IID_ISequentialOutStream, (void **)&seqOutStream);
+  if (!seqOutStream)
+    return E_NOTIMPL;
+
+  UInt32 numOutStreams = EncodeMode ? coder.NumStreams : 1;
+  UInt32 startIndex = EncodeMode ? _bi.Coder_to_Stream[coderIndex]: coderIndex;
+
+  bool isSet = false;
+
+  if (numOutStreams == 1)
+  {
+    CMyComPtr<ICompressSetOutStream> setOutStream;
+    coder.Coder.QueryInterface(IID_ICompressSetOutStream, &setOutStream);
+    if (setOutStream)
+    {
+      CMyComPtr<ISequentialOutStream> seqOutStream2;
+      RINOK(GetOutStream(outStreams, /* outSizes, */ startIndex + 0, &seqOutStream2));
+      RINOK(setOutStream->SetOutStream(seqOutStream2));
+      isSet = true;
+    }
+  }
+
+  if (!isSet && numOutStreams != 0)
+  {
+    return E_NOTIMPL;
+    /*
+    CMyComPtr<ICompressSetOutStream2> setStream2;
+    coder.QueryInterface(IID_ICompressSetOutStream2, (void **)&setStream2);
+    if (!setStream2)
+      return E_NOTIMPL;
+    for (UInt32 i = 0; i < numOutStreams; i++)
+    {
+      CMyComPtr<ISequentialOutStream> seqOutStream2;
+      RINOK(GetOutStream(outStreams, startIndex + i, &seqOutStream2));
+      RINOK(setStream2->SetOutStream2(i, seqOutStream2));
+    }
+    */
+  }
+
+  while (_binderStreams.Size() <= (unsigned)bond)
+    _binderStreams.AddNew();
+  CStBinderStream &bs = _binderStreams[bond];
+
+  if (bs.StreamRef || bs.OutStreamSpec)
+    return E_NOTIMPL;
+  
+  COutStreamCalcSize *spec = new COutStreamCalcSize;
+  bs.StreamRef = (ISequentialOutStream *)spec;
+  bs.OutStreamSpec = spec;
+  
+  spec->SetStream(seqOutStream);
+  spec->Init();
+
+  seqOutStream = bs.OutStreamSpec;
+  
+  *outStreamRes = seqOutStream.Detach();
+  return S_OK;
+}
+
+
+static HRESULT GetError(HRESULT res, HRESULT res2)
+{
+  if (res == res2)
+    return res;
+  if (res == S_OK)
+    return res2;
+  if (res == k_My_HRESULT_WritingWasCut)
+  {
+    if (res2 != S_OK)
+      return res2;
+  }
+  return res;
+}
+
+
+HRESULT CMixerST::FinishStream(UInt32 streamIndex)
+{
+  {
+    int index = -1;
+    if (!EncodeMode)
+    {
+      if (_bi.UnpackCoder == streamIndex)
+        index = 0;
+    }
+    else
+      index = _bi.FindStream_in_PackStreams(streamIndex);
+
+    if (index >= 0)
+      return S_OK;
+  }
+
+  int bond = FindBond_for_Stream(
+      false, // forInputStream
+      streamIndex);
+  if (bond < 0)
+    return E_INVALIDARG;
+
+  UInt32 inStreamIndex = _bi.Bonds[bond].Get_InIndex(EncodeMode);
+
+  UInt32 coderIndex = inStreamIndex;
+  UInt32 coderStreamIndex = 0;
+  if (!EncodeMode)
+    _bi.GetCoder_for_Stream(inStreamIndex, coderIndex, coderStreamIndex);
+
+  CCoder &coder = _coders[coderIndex];
+  CMyComPtr<IOutStreamFinish> finish;
+  coder.QueryInterface(IID_IOutStreamFinish, (void **)&finish);
+  HRESULT res = S_OK;
+  if (finish)
+  {
+    res = finish->OutStreamFinish();
+  }
+  return GetError(res, FinishCoder(coderIndex));
+}
+
+
+HRESULT CMixerST::FinishCoder(UInt32 coderIndex)
+{
+  CCoder &coder = _coders[coderIndex];
+
+  UInt32 numOutStreams = EncodeMode ? coder.NumStreams : 1;
+  UInt32 startIndex = EncodeMode ? _bi.Coder_to_Stream[coderIndex]: coderIndex;
+
+  HRESULT res = S_OK;
+  for (unsigned i = 0; i < numOutStreams; i++)
+    res = GetError(res, FinishStream(startIndex + i));
+  return res;
+}
+
+
+void CMixerST::SelectMainCoder(bool useFirst)
+{
+  unsigned ci = _bi.UnpackCoder;
+  
+  int firstNonFilter = -1;
+  int firstAllowed = ci;
+  
+  for (;;)
+  {
+    const CCoderST &coder = _coders[ci];
+    // break;
+    
+    if (ci != _bi.UnpackCoder)
+      if (EncodeMode ? !coder.CanWrite : !coder.CanRead)
+      {
+        firstAllowed = ci;
+        firstNonFilter = -2;
+      }
+      
+    if (coder.NumStreams != 1)
+      break;
+    
+    UInt32 st = _bi.Coder_to_Stream[ci];
+    if (_bi.IsStream_in_PackStreams(st))
+      break;
+    int bond = _bi.FindBond_for_PackStream(st);
+    if (bond < 0)
+      throw 20150213;
+    
+    if (EncodeMode ? !coder.CanRead : !coder.CanWrite)
+      break;
+    
+    if (firstNonFilter == -1 && !IsFilter_Vector[ci])
+      firstNonFilter = ci;
+    
+    ci = _bi.Bonds[bond].UnpackIndex;
+  }
+  
+  if (useFirst)
+    ci = firstAllowed;
+  else if (firstNonFilter >= 0)
+    ci = firstNonFilter;
+
+  MainCoderIndex = ci;
+}
+
+
+HRESULT CMixerST::Code(
+    ISequentialInStream * const *inStreams,
+    ISequentialOutStream * const *outStreams,
+    ICompressProgressInfo *progress,
+    bool &dataAfterEnd_Error)
+{
+  // InternalPackSizeError = false;
+  dataAfterEnd_Error = false;
+
+  _binderStreams.Clear();
+  unsigned ci = MainCoderIndex;
+ 
+  const CCoder &mainCoder = _coders[MainCoderIndex];
+
+  CObjectVector< CMyComPtr<ISequentialInStream> > seqInStreams;
+  CObjectVector< CMyComPtr<ISequentialOutStream> > seqOutStreams;
+  
+  UInt32 numInStreams  =  EncodeMode ? 1 : mainCoder.NumStreams;
+  UInt32 numOutStreams = !EncodeMode ? 1 : mainCoder.NumStreams;
+  
+  UInt32 startInIndex  =  EncodeMode ? ci : _bi.Coder_to_Stream[ci];
+  UInt32 startOutIndex = !EncodeMode ? ci : _bi.Coder_to_Stream[ci];
+  
+  UInt32 i;
+
+  for (i = 0; i < numInStreams; i++)
+  {
+    CMyComPtr<ISequentialInStream> seqInStream;
+    RINOK(GetInStream(inStreams, /* inSizes, */ startInIndex + i, &seqInStream));
+    seqInStreams.Add(seqInStream);
+  }
+  
+  for (i = 0; i < numOutStreams; i++)
+  {
+    CMyComPtr<ISequentialOutStream> seqOutStream;
+    RINOK(GetOutStream(outStreams, /* outSizes, */ startOutIndex + i, &seqOutStream));
+    seqOutStreams.Add(seqOutStream);
+  }
+  
+  CRecordVector< ISequentialInStream * > seqInStreamsSpec;
+  CRecordVector< ISequentialOutStream * > seqOutStreamsSpec;
+  
+  for (i = 0; i < numInStreams; i++)
+    seqInStreamsSpec.Add(seqInStreams[i]);
+  for (i = 0; i < numOutStreams; i++)
+    seqOutStreamsSpec.Add(seqOutStreams[i]);
+
+  for (i = 0; i < _coders.Size(); i++)
+  {
+    if (i == ci)
+      continue;
+   
+    CCoder &coder = _coders[i];
+
+    if (EncodeMode)
+    {
+      CMyComPtr<ICompressInitEncoder> initEncoder;
+      coder.QueryInterface(IID_ICompressInitEncoder, (void **)&initEncoder);
+      if (initEncoder)
+        RINOK(initEncoder->InitEncoder());
+    }
+    else
+    {
+      CMyComPtr<ICompressSetOutStreamSize> setOutStreamSize;
+      coder.QueryInterface(IID_ICompressSetOutStreamSize, (void **)&setOutStreamSize);
+      if (setOutStreamSize)
+        RINOK(setOutStreamSize->SetOutStreamSize(
+            EncodeMode ? coder.PackSizePointers[0] : coder.UnpackSizePointer));
+    }
+  }
+
+  const UInt64 * const *isSizes2 = EncodeMode ? &mainCoder.UnpackSizePointer : &mainCoder.PackSizePointers.Front();
+  const UInt64 * const *outSizes2 = EncodeMode ? &mainCoder.PackSizePointers.Front() : &mainCoder.UnpackSizePointer;
+
+  HRESULT res;
+  if (mainCoder.Coder)
+  {
+    res = mainCoder.Coder->Code(
+        seqInStreamsSpec[0], seqOutStreamsSpec[0],
+        isSizes2[0], outSizes2[0],
+        progress);
+  }
+  else
+  {
+    res = mainCoder.Coder2->Code(
+        &seqInStreamsSpec.Front(), isSizes2, numInStreams,
+        &seqOutStreamsSpec.Front(), outSizes2, numOutStreams,
+        progress);
+  }
+
+  if (res == k_My_HRESULT_WritingWasCut)
+    res = S_OK;
+
+  if (res == S_OK || res == S_FALSE)
+  {
+    res = GetError(res, FinishCoder(ci));
+  }
+
+  for (i = 0; i < _binderStreams.Size(); i++)
+  {
+    const CStBinderStream &bs = _binderStreams[i];
+    if (bs.InStreamSpec)
+      bs.InStreamSpec->ReleaseStream();
+    else
+      bs.OutStreamSpec->ReleaseStream();
+  }
+
+  if (res == k_My_HRESULT_WritingWasCut)
+    res = S_OK;
+
+  if (res != S_OK)
+    return res;
+
+  for (i = 0; i < _coders.Size(); i++)
+  {
+    RINOK(_coders[i].CheckDataAfterEnd(dataAfterEnd_Error /*, InternalPackSizeError */));
+  }
+
+  return S_OK;
+}
+
+
+HRESULT CMixerST::GetMainUnpackStream(
+    ISequentialInStream * const *inStreams,
+    ISequentialInStream **inStreamRes)
+{
+  CMyComPtr<ISequentialInStream> seqInStream;
+
+  RINOK(GetInStream2(inStreams, /* inSizes, */
+      _bi.UnpackCoder, &seqInStream))
+  
+  FOR_VECTOR (i, _coders)
+  {
+    CCoder &coder = _coders[i];
+    CMyComPtr<ICompressSetOutStreamSize> setOutStreamSize;
+    coder.QueryInterface(IID_ICompressSetOutStreamSize, (void **)&setOutStreamSize);
+    if (setOutStreamSize)
+    {
+      RINOK(setOutStreamSize->SetOutStreamSize(coder.UnpackSizePointer));
+    }
+  }
+  
+  *inStreamRes = seqInStream.Detach();
+  return S_OK;
+}
+
+
+UInt64 CMixerST::GetBondStreamSize(unsigned bondIndex) const
+{
+  const CStBinderStream &bs = _binderStreams[bondIndex];
+  if (bs.InStreamSpec)
+    return bs.InStreamSpec->GetSize();
+  return bs.OutStreamSpec->GetSize();
+}
+
+#endif
+
+
+
+
+
+
+#ifdef USE_MIXER_MT
+
+
+void CCoderMT::Execute()
+{
+  try
+  {
+    Code(NULL);
+  }
+  catch(...)
+  {
+    Result = E_FAIL;
+  }
+}
+
+void CCoderMT::Code(ICompressProgressInfo *progress)
+{
+  unsigned numInStreams = EncodeMode ? 1 : NumStreams;
+  unsigned numOutStreams = EncodeMode ? NumStreams : 1;
+
+  InStreamPointers.ClearAndReserve(numInStreams);
+  OutStreamPointers.ClearAndReserve(numOutStreams);
+
+  unsigned i;
+  
+  for (i = 0; i < numInStreams; i++)
+    InStreamPointers.AddInReserved((ISequentialInStream *)InStreams[i]);
+  
+  for (i = 0; i < numOutStreams; i++)
+    OutStreamPointers.AddInReserved((ISequentialOutStream *)OutStreams[i]);
+
+  // we suppose that UnpackSizePointer and PackSizePointers contain correct pointers.
+  /*
+  if (UnpackSizePointer)
+    UnpackSizePointer = &UnpackSize;
+  for (i = 0; i < NumStreams; i++)
+    if (PackSizePointers[i])
+      PackSizePointers[i] = &PackSizes[i];
+  */
+
+  CReleaser releaser(*this);
+  
+  if (Coder)
+    Result = Coder->Code(InStreamPointers[0], OutStreamPointers[0],
+        EncodeMode ? UnpackSizePointer : PackSizePointers[0],
+        EncodeMode ? PackSizePointers[0] : UnpackSizePointer,
+        progress);
+  else
+    Result = Coder2->Code(
+        &InStreamPointers.Front(),  EncodeMode ? &UnpackSizePointer : &PackSizePointers.Front(), numInStreams,
+        &OutStreamPointers.Front(), EncodeMode ? &PackSizePointers.Front(): &UnpackSizePointer, numOutStreams,
+        progress);
+}
+
+HRESULT CMixerMT::SetBindInfo(const CBindInfo &bindInfo)
+{
+  CMixer::SetBindInfo(bindInfo);
+  
+  _streamBinders.Clear();
+  FOR_VECTOR (i, _bi.Bonds)
+  {
+    RINOK(_streamBinders.AddNew().CreateEvents());
+  }
+  return S_OK;
+}
+
+void CMixerMT::AddCoder(const CCreatedCoder &cod)
+{
+  IsFilter_Vector.Add(cod.IsFilter);
+  IsExternal_Vector.Add(cod.IsExternal);
+  // const CCoderStreamsInfo &c = _bi.Coders[_coders.Size()];
+  CCoderMT &c2 = _coders.AddNew();
+  c2.NumStreams = cod.NumStreams;
+  c2.Coder = cod.Coder;
+  c2.Coder2 = cod.Coder2;
+  c2.EncodeMode = EncodeMode;
+}
+
+CCoder &CMixerMT::GetCoder(unsigned index)
+{
+  return _coders[index];
+}
+
+void CMixerMT::ReInit()
+{
+  FOR_VECTOR (i, _streamBinders)
+    _streamBinders[i].ReInit();
+}
+
+void CMixerMT::SelectMainCoder(bool useFirst)
+{
+  unsigned ci = _bi.UnpackCoder;
+
+  if (!useFirst)
+  for (;;)
+  {
+    if (_coders[ci].NumStreams != 1)
+      break;
+    if (!IsFilter_Vector[ci])
+      break;
+    
+    UInt32 st = _bi.Coder_to_Stream[ci];
+    if (_bi.IsStream_in_PackStreams(st))
+      break;
+    int bond = _bi.FindBond_for_PackStream(st);
+    if (bond < 0)
+      throw 20150213;
+    ci = _bi.Bonds[bond].UnpackIndex;
+  }
+  
+  MainCoderIndex = ci;
+}
+
+HRESULT CMixerMT::Init(ISequentialInStream * const *inStreams, ISequentialOutStream * const *outStreams)
+{
+  unsigned i;
+  
+  for (i = 0; i < _coders.Size(); i++)
+  {
+    CCoderMT &coderInfo = _coders[i];
+    const CCoderStreamsInfo &csi = _bi.Coders[i];
+    
+    UInt32 j;
+
+    unsigned numInStreams = EncodeMode ? 1 : csi.NumStreams;
+    unsigned numOutStreams = EncodeMode ? csi.NumStreams : 1;
+
+    coderInfo.InStreams.Clear();
+    for (j = 0; j < numInStreams; j++)
+      coderInfo.InStreams.AddNew();
+    
+    coderInfo.OutStreams.Clear();
+    for (j = 0; j < numOutStreams; j++)
+      coderInfo.OutStreams.AddNew();
+  }
+
+  for (i = 0; i < _bi.Bonds.Size(); i++)
+  {
+    const CBond &bond = _bi.Bonds[i];
+   
+    UInt32 inCoderIndex, inCoderStreamIndex;
+    UInt32 outCoderIndex, outCoderStreamIndex;
+    
+    {
+      UInt32 coderIndex, coderStreamIndex;
+      _bi.GetCoder_for_Stream(bond.PackIndex, coderIndex, coderStreamIndex);
+
+      inCoderIndex = EncodeMode ? bond.UnpackIndex : coderIndex;
+      outCoderIndex = EncodeMode ? coderIndex : bond.UnpackIndex;
+
+      inCoderStreamIndex = EncodeMode ? 0 : coderStreamIndex;
+      outCoderStreamIndex = EncodeMode ? coderStreamIndex : 0;
+    }
+
+    _streamBinders[i].CreateStreams(
+        &_coders[inCoderIndex].InStreams[inCoderStreamIndex],
+        &_coders[outCoderIndex].OutStreams[outCoderStreamIndex]);
+
+    CMyComPtr<ICompressSetBufSize> inSetSize, outSetSize;
+    _coders[inCoderIndex].QueryInterface(IID_ICompressSetBufSize, (void **)&inSetSize);
+    _coders[outCoderIndex].QueryInterface(IID_ICompressSetBufSize, (void **)&outSetSize);
+    if (inSetSize && outSetSize)
+    {
+      const UInt32 kBufSize = 1 << 19;
+      inSetSize->SetInBufSize(inCoderStreamIndex, kBufSize);
+      outSetSize->SetOutBufSize(outCoderStreamIndex, kBufSize);
+    }
+  }
+
+  {
+    CCoderMT &cod = _coders[_bi.UnpackCoder];
+    if (EncodeMode)
+      cod.InStreams[0] = inStreams[0];
+    else
+      cod.OutStreams[0] = outStreams[0];
+  }
+
+  for (i = 0; i < _bi.PackStreams.Size(); i++)
+  {
+    UInt32 coderIndex, coderStreamIndex;
+    _bi.GetCoder_for_Stream(_bi.PackStreams[i], coderIndex, coderStreamIndex);
+    CCoderMT &cod = _coders[coderIndex];
+    if (EncodeMode)
+      cod.OutStreams[coderStreamIndex] = outStreams[i];
+    else
+      cod.InStreams[coderStreamIndex] = inStreams[i];
+  }
+  
+  return S_OK;
+}
+
+HRESULT CMixerMT::ReturnIfError(HRESULT code)
+{
+  FOR_VECTOR (i, _coders)
+    if (_coders[i].Result == code)
+      return code;
+  return S_OK;
+}
+
+HRESULT CMixerMT::Code(
+    ISequentialInStream * const *inStreams,
+    ISequentialOutStream * const *outStreams,
+    ICompressProgressInfo *progress,
+    bool &dataAfterEnd_Error)
+{
+  // InternalPackSizeError = false;
+  dataAfterEnd_Error = false;
+
+  Init(inStreams, outStreams);
+
+  unsigned i;
+  for (i = 0; i < _coders.Size(); i++)
+    if (i != MainCoderIndex)
+    {
+      RINOK(_coders[i].Create());
+    }
+
+  for (i = 0; i < _coders.Size(); i++)
+    if (i != MainCoderIndex)
+      _coders[i].Start();
+
+  _coders[MainCoderIndex].Code(progress);
+
+  for (i = 0; i < _coders.Size(); i++)
+    if (i != MainCoderIndex)
+      _coders[i].WaitExecuteFinish();
+
+  RINOK(ReturnIfError(E_ABORT));
+  RINOK(ReturnIfError(E_OUTOFMEMORY));
+
+  for (i = 0; i < _coders.Size(); i++)
+  {
+    HRESULT result = _coders[i].Result;
+    if (result != S_OK
+        && result != k_My_HRESULT_WritingWasCut
+        && result != S_FALSE
+        && result != E_FAIL)
+      return result;
+  }
+
+  RINOK(ReturnIfError(S_FALSE));
+
+  for (i = 0; i < _coders.Size(); i++)
+  {
+    HRESULT result = _coders[i].Result;
+    if (result != S_OK && result != k_My_HRESULT_WritingWasCut)
+      return result;
+  }
+
+  for (i = 0; i < _coders.Size(); i++)
+  {
+    RINOK(_coders[i].CheckDataAfterEnd(dataAfterEnd_Error /* , InternalPackSizeError */));
+  }
+
+  return S_OK;
+}
+
+UInt64 CMixerMT::GetBondStreamSize(unsigned bondIndex) const
+{
+  return _streamBinders[bondIndex].ProcessedSize;
+}
+
+#endif
+
+}