[pcsx_rearmed.git] / deps / lzma-16.04 / C / XzEnc.c

/* XzEnc.c -- Xz Encode\r
2015-09-16 : Igor Pavlov : Public domain */\r
\r
#include "Precomp.h"\r
\r
#include <stdlib.h>\r
#include <string.h>\r
\r
#include "7zCrc.h"\r
#include "Alloc.h"\r
#include "Bra.h"\r
#include "CpuArch.h"\r
\r
#ifdef USE_SUBBLOCK\r
#include "Bcj3Enc.c"\r
#include "SbFind.c"\r
#include "SbEnc.c"\r
#endif\r
\r
#include "XzEnc.h"\r
\r
#define XzBlock_ClearFlags(p)       (p)->flags = 0;\r
#define XzBlock_SetNumFilters(p, n) (p)->flags |= ((n) - 1);\r
#define XzBlock_SetHasPackSize(p)   (p)->flags |= XZ_BF_PACK_SIZE;\r
#define XzBlock_SetHasUnpackSize(p) (p)->flags |= XZ_BF_UNPACK_SIZE;\r
\r
static SRes WriteBytes(ISeqOutStream *s, const void *buf, UInt32 size)\r
{\r
  return (s->Write(s, buf, size) == size) ? SZ_OK : SZ_ERROR_WRITE;\r
}\r
\r
static SRes WriteBytesAndCrc(ISeqOutStream *s, const void *buf, UInt32 size, UInt32 *crc)\r
{\r
  *crc = CrcUpdate(*crc, buf, size);\r
  return WriteBytes(s, buf, size);\r
}\r
\r
static SRes Xz_WriteHeader(CXzStreamFlags f, ISeqOutStream *s)\r
{\r
  UInt32 crc;\r
  Byte header[XZ_STREAM_HEADER_SIZE];\r
  memcpy(header, XZ_SIG, XZ_SIG_SIZE);\r
  header[XZ_SIG_SIZE] = (Byte)(f >> 8);\r
  header[XZ_SIG_SIZE + 1] = (Byte)(f & 0xFF);\r
  crc = CrcCalc(header + XZ_SIG_SIZE, XZ_STREAM_FLAGS_SIZE);\r
  SetUi32(header + XZ_SIG_SIZE + XZ_STREAM_FLAGS_SIZE, crc);\r
  return WriteBytes(s, header, XZ_STREAM_HEADER_SIZE);\r
}\r
\r
\r
static SRes XzBlock_WriteHeader(const CXzBlock *p, ISeqOutStream *s)\r
{\r
  Byte header[XZ_BLOCK_HEADER_SIZE_MAX];\r
\r
  unsigned pos = 1;\r
  unsigned numFilters, i;\r
  header[pos++] = p->flags;\r
\r
  if (XzBlock_HasPackSize(p)) pos += Xz_WriteVarInt(header + pos, p->packSize);\r
  if (XzBlock_HasUnpackSize(p)) pos += Xz_WriteVarInt(header + pos, p->unpackSize);\r
  numFilters = XzBlock_GetNumFilters(p);\r
  \r
  for (i = 0; i < numFilters; i++)\r
  {\r
    const CXzFilter *f = &p->filters[i];\r
    pos += Xz_WriteVarInt(header + pos, f->id);\r
    pos += Xz_WriteVarInt(header + pos, f->propsSize);\r
    memcpy(header + pos, f->props, f->propsSize);\r
    pos += f->propsSize;\r
  }\r
\r
  while ((pos & 3) != 0)\r
    header[pos++] = 0;\r
\r
  header[0] = (Byte)(pos >> 2);\r
  SetUi32(header + pos, CrcCalc(header, pos));\r
  return WriteBytes(s, header, pos + 4);\r
}\r
\r
\r
static SRes Xz_WriteFooter(CXzStream *p, ISeqOutStream *s)\r
{\r
  Byte buf[32];\r
  UInt64 globalPos;\r
  {\r
    UInt32 crc = CRC_INIT_VAL;\r
    unsigned pos = 1 + Xz_WriteVarInt(buf + 1, p->numBlocks);\r
    size_t i;\r
\r
    globalPos = pos;\r
    buf[0] = 0;\r
    RINOK(WriteBytesAndCrc(s, buf, pos, &crc));\r
\r
    for (i = 0; i < p->numBlocks; i++)\r
    {\r
      const CXzBlockSizes *block = &p->blocks[i];\r
      pos = Xz_WriteVarInt(buf, block->totalSize);\r
      pos += Xz_WriteVarInt(buf + pos, block->unpackSize);\r
      globalPos += pos;\r
      RINOK(WriteBytesAndCrc(s, buf, pos, &crc));\r
    }\r
    \r
    pos = ((unsigned)globalPos & 3);\r
    \r
    if (pos != 0)\r
    {\r
      buf[0] = buf[1] = buf[2] = 0;\r
      RINOK(WriteBytesAndCrc(s, buf, 4 - pos, &crc));\r
      globalPos += 4 - pos;\r
    }\r
    {\r
      SetUi32(buf, CRC_GET_DIGEST(crc));\r
      RINOK(WriteBytes(s, buf, 4));\r
      globalPos += 4;\r
    }\r
  }\r
\r
  {\r
    UInt32 indexSize = (UInt32)((globalPos >> 2) - 1);\r
    SetUi32(buf + 4, indexSize);\r
    buf[8] = (Byte)(p->flags >> 8);\r
    buf[9] = (Byte)(p->flags & 0xFF);\r
    SetUi32(buf, CrcCalc(buf + 4, 6));\r
    memcpy(buf + 10, XZ_FOOTER_SIG, XZ_FOOTER_SIG_SIZE);\r
    return WriteBytes(s, buf, 12);\r
  }\r
}\r
\r
\r
static SRes Xz_AddIndexRecord(CXzStream *p, UInt64 unpackSize, UInt64 totalSize, ISzAlloc *alloc)\r
{\r
  if (!p->blocks || p->numBlocksAllocated == p->numBlocks)\r
  {\r
    size_t num = p->numBlocks * 2 + 1;\r
    size_t newSize = sizeof(CXzBlockSizes) * num;\r
    CXzBlockSizes *blocks;\r
    if (newSize / sizeof(CXzBlockSizes) != num)\r
      return SZ_ERROR_MEM;\r
    blocks = (CXzBlockSizes *)alloc->Alloc(alloc, newSize);\r
    if (!blocks)\r
      return SZ_ERROR_MEM;\r
    if (p->numBlocks != 0)\r
    {\r
      memcpy(blocks, p->blocks, p->numBlocks * sizeof(CXzBlockSizes));\r
      alloc->Free(alloc, p->blocks);\r
    }\r
    p->blocks = blocks;\r
    p->numBlocksAllocated = num;\r
  }\r
  {\r
    CXzBlockSizes *block = &p->blocks[p->numBlocks++];\r
    block->unpackSize = unpackSize;\r
    block->totalSize = totalSize;\r
  }\r
  return SZ_OK;\r
}\r
\r
\r
/* ---------- CSeqCheckInStream ---------- */\r
\r
typedef struct\r
{\r
  ISeqInStream p;\r
  ISeqInStream *realStream;\r
  UInt64 processed;\r
  CXzCheck check;\r
} CSeqCheckInStream;\r
\r
static void SeqCheckInStream_Init(CSeqCheckInStream *p, unsigned mode)\r
{\r
  p->processed = 0;\r
  XzCheck_Init(&p->check, mode);\r
}\r
\r
static void SeqCheckInStream_GetDigest(CSeqCheckInStream *p, Byte *digest)\r
{\r
  XzCheck_Final(&p->check, digest);\r
}\r
\r
static SRes SeqCheckInStream_Read(void *pp, void *data, size_t *size)\r
{\r
  CSeqCheckInStream *p = (CSeqCheckInStream *)pp;\r
  SRes res = p->realStream->Read(p->realStream, data, size);\r
  XzCheck_Update(&p->check, data, *size);\r
  p->processed += *size;\r
  return res;\r
}\r
\r
\r
/* ---------- CSeqSizeOutStream ---------- */\r
\r
typedef struct\r
{\r
  ISeqOutStream p;\r
  ISeqOutStream *realStream;\r
  UInt64 processed;\r
} CSeqSizeOutStream;\r
\r
static size_t MyWrite(void *pp, const void *data, size_t size)\r
{\r
  CSeqSizeOutStream *p = (CSeqSizeOutStream *)pp;\r
  size = p->realStream->Write(p->realStream, data, size);\r
  p->processed += size;\r
  return size;\r
}\r
\r
\r
/* ---------- CSeqInFilter ---------- */\r
\r
#define FILTER_BUF_SIZE (1 << 20)\r
\r
typedef struct\r
{\r
  ISeqInStream p;\r
  ISeqInStream *realStream;\r
  IStateCoder StateCoder;\r
  Byte *buf;\r
  size_t curPos;\r
  size_t endPos;\r
  int srcWasFinished;\r
} CSeqInFilter;\r
\r
static SRes SeqInFilter_Read(void *pp, void *data, size_t *size)\r
{\r
  CSeqInFilter *p = (CSeqInFilter *)pp;\r
  size_t sizeOriginal = *size;\r
  if (sizeOriginal == 0)\r
    return SZ_OK;\r
  *size = 0;\r
  \r
  for (;;)\r
  {\r
    if (!p->srcWasFinished && p->curPos == p->endPos)\r
    {\r
      p->curPos = 0;\r
      p->endPos = FILTER_BUF_SIZE;\r
      RINOK(p->realStream->Read(p->realStream, p->buf, &p->endPos));\r
      if (p->endPos == 0)\r
        p->srcWasFinished = 1;\r
    }\r
    {\r
      SizeT srcLen = p->endPos - p->curPos;\r
      int wasFinished;\r
      SRes res;\r
      *size = sizeOriginal;\r
      res = p->StateCoder.Code(p->StateCoder.p, data, size, p->buf + p->curPos, &srcLen,\r
        p->srcWasFinished, CODER_FINISH_ANY, &wasFinished);\r
      p->curPos += srcLen;\r
      if (*size != 0 || srcLen == 0 || res != 0)\r
        return res;\r
    }\r
  }\r
}\r
\r
static void SeqInFilter_Construct(CSeqInFilter *p)\r
{\r
  p->buf = NULL;\r
  p->p.Read = SeqInFilter_Read;\r
}\r
\r
static void SeqInFilter_Free(CSeqInFilter *p)\r
{\r
  if (p->buf)\r
  {\r
    g_Alloc.Free(&g_Alloc, p->buf);\r
    p->buf = NULL;\r
  }\r
}\r
\r
SRes BraState_SetFromMethod(IStateCoder *p, UInt64 id, int encodeMode, ISzAlloc *alloc);\r
\r
static SRes SeqInFilter_Init(CSeqInFilter *p, const CXzFilter *props)\r
{\r
  if (!p->buf)\r
  {\r
    p->buf = g_Alloc.Alloc(&g_Alloc, FILTER_BUF_SIZE);\r
    if (!p->buf)\r
      return SZ_ERROR_MEM;\r
  }\r
  p->curPos = p->endPos = 0;\r
  p->srcWasFinished = 0;\r
  RINOK(BraState_SetFromMethod(&p->StateCoder, props->id, 1, &g_Alloc));\r
  RINOK(p->StateCoder.SetProps(p->StateCoder.p, props->props, props->propsSize, &g_Alloc));\r
  p->StateCoder.Init(p->StateCoder.p);\r
  return SZ_OK;\r
}\r
\r
\r
/* ---------- CSbEncInStream ---------- */\r
\r
#ifdef USE_SUBBLOCK\r
\r
typedef struct\r
{\r
  ISeqInStream p;\r
  ISeqInStream *inStream;\r
  CSbEnc enc;\r
} CSbEncInStream;\r
\r
static SRes SbEncInStream_Read(void *pp, void *data, size_t *size)\r
{\r
  CSbEncInStream *p = (CSbEncInStream *)pp;\r
  size_t sizeOriginal = *size;\r
  if (sizeOriginal == 0)\r
    return S_OK;\r
  \r
  for (;;)\r
  {\r
    if (p->enc.needRead && !p->enc.readWasFinished)\r
    {\r
      size_t processed = p->enc.needReadSizeMax;\r
      RINOK(p->inStream->Read(p->inStream, p->enc.buf + p->enc.readPos, &processed));\r
      p->enc.readPos += processed;\r
      if (processed == 0)\r
      {\r
        p->enc.readWasFinished = True;\r
        p->enc.isFinalFinished = True;\r
      }\r
      p->enc.needRead = False;\r
    }\r
  \r
    *size = sizeOriginal;\r
    RINOK(SbEnc_Read(&p->enc, data, size));\r
    if (*size != 0 || !p->enc.needRead)\r
      return S_OK;\r
  }\r
}\r
\r
void SbEncInStream_Construct(CSbEncInStream *p, ISzAlloc *alloc)\r
{\r
  SbEnc_Construct(&p->enc, alloc);\r
  p->p.Read = SbEncInStream_Read;\r
}\r
\r
SRes SbEncInStream_Init(CSbEncInStream *p)\r
{\r
  return SbEnc_Init(&p->enc);\r
}\r
\r
void SbEncInStream_Free(CSbEncInStream *p)\r
{\r
  SbEnc_Free(&p->enc);\r
}\r
\r
#endif\r
\r
\r
typedef struct\r
{\r
  CLzma2EncHandle lzma2;\r
  #ifdef USE_SUBBLOCK\r
  CSbEncInStream sb;\r
  #endif\r
  CSeqInFilter filter;\r
  ISzAlloc *alloc;\r
  ISzAlloc *bigAlloc;\r
} CLzma2WithFilters;\r
\r
\r
static void Lzma2WithFilters_Construct(CLzma2WithFilters *p, ISzAlloc *alloc, ISzAlloc *bigAlloc)\r
{\r
  p->alloc = alloc;\r
  p->bigAlloc = bigAlloc;\r
  p->lzma2 = NULL;\r
  #ifdef USE_SUBBLOCK\r
  SbEncInStream_Construct(&p->sb, alloc);\r
  #endif\r
  SeqInFilter_Construct(&p->filter);\r
}\r
\r
static SRes Lzma2WithFilters_Create(CLzma2WithFilters *p)\r
{\r
  p->lzma2 = Lzma2Enc_Create(p->alloc, p->bigAlloc);\r
  if (!p->lzma2)\r
    return SZ_ERROR_MEM;\r
  return SZ_OK;\r
}\r
\r
static void Lzma2WithFilters_Free(CLzma2WithFilters *p)\r
{\r
  SeqInFilter_Free(&p->filter);\r
  #ifdef USE_SUBBLOCK\r
  SbEncInStream_Free(&p->sb);\r
  #endif\r
  if (p->lzma2)\r
  {\r
    Lzma2Enc_Destroy(p->lzma2);\r
    p->lzma2 = NULL;\r
  }\r
}\r
\r
\r
void XzProps_Init(CXzProps *p)\r
{\r
  p->lzma2Props = NULL;\r
  p->filterProps = NULL;\r
  p->checkId = XZ_CHECK_CRC32;\r
}\r
\r
void XzFilterProps_Init(CXzFilterProps *p)\r
{\r
  p->id = 0;\r
  p->delta = 0;\r
  p->ip = 0;\r
  p->ipDefined = False;\r
}\r
\r
\r
static SRes Xz_Compress(CXzStream *xz, CLzma2WithFilters *lzmaf,\r
    ISeqOutStream *outStream, ISeqInStream *inStream,\r
    const CXzProps *props, ICompressProgress *progress)\r
{\r
  xz->flags = (Byte)props->checkId;\r
\r
  RINOK(Lzma2Enc_SetProps(lzmaf->lzma2, props->lzma2Props));\r
  RINOK(Xz_WriteHeader(xz->flags, outStream));\r
\r
  {\r
    CSeqCheckInStream checkInStream;\r
    CSeqSizeOutStream seqSizeOutStream;\r
    CXzBlock block;\r
    unsigned filterIndex = 0;\r
    CXzFilter *filter = NULL;\r
    const CXzFilterProps *fp = props->filterProps;\r
    \r
    XzBlock_ClearFlags(&block);\r
    XzBlock_SetNumFilters(&block, 1 + (fp ? 1 : 0));\r
    \r
    if (fp)\r
    {\r
      filter = &block.filters[filterIndex++];\r
      filter->id = fp->id;\r
      filter->propsSize = 0;\r
      \r
      if (fp->id == XZ_ID_Delta)\r
      {\r
        filter->props[0] = (Byte)(fp->delta - 1);\r
        filter->propsSize = 1;\r
      }\r
      else if (fp->ipDefined)\r
      {\r
        SetUi32(filter->props, fp->ip);\r
        filter->propsSize = 4;\r
      }\r
    }\r
\r
    {\r
      CXzFilter *f = &block.filters[filterIndex++];\r
      f->id = XZ_ID_LZMA2;\r
      f->propsSize = 1;\r
      f->props[0] = Lzma2Enc_WriteProperties(lzmaf->lzma2);\r
    }\r
\r
    seqSizeOutStream.p.Write = MyWrite;\r
    seqSizeOutStream.realStream = outStream;\r
    seqSizeOutStream.processed = 0;\r
    \r
    RINOK(XzBlock_WriteHeader(&block, &seqSizeOutStream.p));\r
    \r
    checkInStream.p.Read = SeqCheckInStream_Read;\r
    checkInStream.realStream = inStream;\r
    SeqCheckInStream_Init(&checkInStream, XzFlags_GetCheckType(xz->flags));\r
    \r
    if (fp)\r
    {\r
      #ifdef USE_SUBBLOCK\r
      if (fp->id == XZ_ID_Subblock)\r
      {\r
        lzmaf->sb.inStream = &checkInStream.p;\r
        RINOK(SbEncInStream_Init(&lzmaf->sb));\r
      }\r
      else\r
      #endif\r
      {\r
        lzmaf->filter.realStream = &checkInStream.p;\r
        RINOK(SeqInFilter_Init(&lzmaf->filter, filter));\r
      }\r
    }\r
\r
    {\r
      UInt64 packPos = seqSizeOutStream.processed;\r
      \r
      SRes res = Lzma2Enc_Encode(lzmaf->lzma2, &seqSizeOutStream.p,\r
          fp ?\r
            #ifdef USE_SUBBLOCK\r
            (fp->id == XZ_ID_Subblock) ? &lzmaf->sb.p:\r
            #endif\r
            &lzmaf->filter.p:\r
            &checkInStream.p,\r
          progress);\r
      \r
      RINOK(res);\r
      block.unpackSize = checkInStream.processed;\r
      block.packSize = seqSizeOutStream.processed - packPos;\r
    }\r
\r
    {\r
      unsigned padSize = 0;\r
      Byte buf[128];\r
      while ((((unsigned)block.packSize + padSize) & 3) != 0)\r
        buf[padSize++] = 0;\r
      SeqCheckInStream_GetDigest(&checkInStream, buf + padSize);\r
      RINOK(WriteBytes(&seqSizeOutStream.p, buf, padSize + XzFlags_GetCheckSize(xz->flags)));\r
      RINOK(Xz_AddIndexRecord(xz, block.unpackSize, seqSizeOutStream.processed - padSize, &g_Alloc));\r
    }\r
  }\r
  return Xz_WriteFooter(xz, outStream);\r
}\r
\r
\r
SRes Xz_Encode(ISeqOutStream *outStream, ISeqInStream *inStream,\r
    const CXzProps *props, ICompressProgress *progress)\r
{\r
  SRes res;\r
  CXzStream xz;\r
  CLzma2WithFilters lzmaf;\r
  Xz_Construct(&xz);\r
  Lzma2WithFilters_Construct(&lzmaf, &g_Alloc, &g_BigAlloc);\r
  res = Lzma2WithFilters_Create(&lzmaf);\r
  if (res == SZ_OK)\r
    res = Xz_Compress(&xz, &lzmaf, outStream, inStream, props, progress);\r
  Lzma2WithFilters_Free(&lzmaf);\r
  Xz_Free(&xz, &g_Alloc);\r
  return res;\r
}\r
\r
\r
SRes Xz_EncodeEmpty(ISeqOutStream *outStream)\r
{\r
  SRes res;\r
  CXzStream xz;\r
  Xz_Construct(&xz);\r
  res = Xz_WriteHeader(xz.flags, outStream);\r
  if (res == SZ_OK)\r
    res = Xz_WriteFooter(&xz, outStream);\r
  Xz_Free(&xz, &g_Alloc);\r
  return res;\r
}\r
Commit	Line	Data
ce188d4d	1	/* XzEnc.c -- Xz Encode\r
	2	2015-09-16 : Igor Pavlov : Public domain */\r
	3	\r
	4	#include "Precomp.h"\r
	5	\r
	6	#include <stdlib.h>\r
	7	#include <string.h>\r
	8	\r
	9	#include "7zCrc.h"\r
	10	#include "Alloc.h"\r
	11	#include "Bra.h"\r
	12	#include "CpuArch.h"\r
	13	\r
	14	#ifdef USE_SUBBLOCK\r
	15	#include "Bcj3Enc.c"\r
	16	#include "SbFind.c"\r
	17	#include "SbEnc.c"\r
	18	#endif\r
	19	\r
	20	#include "XzEnc.h"\r
	21	\r
	22	#define XzBlock_ClearFlags(p) (p)->flags = 0;\r
	23	#define XzBlock_SetNumFilters(p, n) (p)->flags \|= ((n) - 1);\r
	24	#define XzBlock_SetHasPackSize(p) (p)->flags \|= XZ_BF_PACK_SIZE;\r
	25	#define XzBlock_SetHasUnpackSize(p) (p)->flags \|= XZ_BF_UNPACK_SIZE;\r
	26	\r
	27	static SRes WriteBytes(ISeqOutStream s, const void buf, UInt32 size)\r
	28	{\r
	29	return (s->Write(s, buf, size) == size) ? SZ_OK : SZ_ERROR_WRITE;\r
	30	}\r
	31	\r
	32	static SRes WriteBytesAndCrc(ISeqOutStream s, const void buf, UInt32 size, UInt32 *crc)\r
	33	{\r
	34	crc = CrcUpdate(crc, buf, size);\r
	35	return WriteBytes(s, buf, size);\r
	36	}\r
	37	\r
	38	static SRes Xz_WriteHeader(CXzStreamFlags f, ISeqOutStream *s)\r
	39	{\r
	40	UInt32 crc;\r
	41	Byte header[XZ_STREAM_HEADER_SIZE];\r
	42	memcpy(header, XZ_SIG, XZ_SIG_SIZE);\r
	43	header[XZ_SIG_SIZE] = (Byte)(f >> 8);\r
	44	header[XZ_SIG_SIZE + 1] = (Byte)(f & 0xFF);\r
	45	crc = CrcCalc(header + XZ_SIG_SIZE, XZ_STREAM_FLAGS_SIZE);\r
	46	SetUi32(header + XZ_SIG_SIZE + XZ_STREAM_FLAGS_SIZE, crc);\r
	47	return WriteBytes(s, header, XZ_STREAM_HEADER_SIZE);\r
	48	}\r
	49	\r
	50	\r
	51	static SRes XzBlock_WriteHeader(const CXzBlock p, ISeqOutStream s)\r
	52	{\r
	53	Byte header[XZ_BLOCK_HEADER_SIZE_MAX];\r
	54	\r
	55	unsigned pos = 1;\r
	56	unsigned numFilters, i;\r
	57	header[pos++] = p->flags;\r
	58	\r
	59	if (XzBlock_HasPackSize(p)) pos += Xz_WriteVarInt(header + pos, p->packSize);\r
	60	if (XzBlock_HasUnpackSize(p)) pos += Xz_WriteVarInt(header + pos, p->unpackSize);\r
	61	numFilters = XzBlock_GetNumFilters(p);\r
	62	\r
	63	for (i = 0; i < numFilters; i++)\r
	64	{\r
65	const CXzFilter *f = &p->filters[i];\r
66	pos += Xz_WriteVarInt(header + pos, f->id);\r
67	pos += Xz_WriteVarInt(header + pos, f->propsSize);\r
68	memcpy(header + pos, f->props, f->propsSize);\r
69	pos += f->propsSize;\r
70	}\r
71	\r
72	while ((pos & 3) != 0)\r
73	header[pos++] = 0;\r
74	\r
75	header[0] = (Byte)(pos >> 2);\r
76	SetUi32(header + pos, CrcCalc(header, pos));\r
77	return WriteBytes(s, header, pos + 4);\r
78	}\r
79	\r
80	\r
81	static SRes Xz_WriteFooter(CXzStream p, ISeqOutStream s)\r
82	{\r
83	Byte buf[32];\r
84	UInt64 globalPos;\r
85	{\r
86	UInt32 crc = CRC_INIT_VAL;\r
87	unsigned pos = 1 + Xz_WriteVarInt(buf + 1, p->numBlocks);\r
88	size_t i;\r
89	\r
90	globalPos = pos;\r
91	buf[0] = 0;\r
92	RINOK(WriteBytesAndCrc(s, buf, pos, &crc));\r
93	\r
94	for (i = 0; i < p->numBlocks; i++)\r
95	{\r
96	const CXzBlockSizes *block = &p->blocks[i];\r
97	pos = Xz_WriteVarInt(buf, block->totalSize);\r
98	pos += Xz_WriteVarInt(buf + pos, block->unpackSize);\r
99	globalPos += pos;\r
100	RINOK(WriteBytesAndCrc(s, buf, pos, &crc));\r
101	}\r
102	\r
103	pos = ((unsigned)globalPos & 3);\r
104	\r
105	if (pos != 0)\r
106	{\r
107	buf[0] = buf[1] = buf[2] = 0;\r
108	RINOK(WriteBytesAndCrc(s, buf, 4 - pos, &crc));\r
109	globalPos += 4 - pos;\r
110	}\r
111	{\r
112	SetUi32(buf, CRC_GET_DIGEST(crc));\r
113	RINOK(WriteBytes(s, buf, 4));\r
114	globalPos += 4;\r
115	}\r
116	}\r
117	\r
118	{\r
119	UInt32 indexSize = (UInt32)((globalPos >> 2) - 1);\r
120	SetUi32(buf + 4, indexSize);\r
121	buf[8] = (Byte)(p->flags >> 8);\r
122	buf[9] = (Byte)(p->flags & 0xFF);\r
123	SetUi32(buf, CrcCalc(buf + 4, 6));\r
124	memcpy(buf + 10, XZ_FOOTER_SIG, XZ_FOOTER_SIG_SIZE);\r
125	return WriteBytes(s, buf, 12);\r
126	}\r
127	}\r
128	\r
129	\r
130	static SRes Xz_AddIndexRecord(CXzStream p, UInt64 unpackSize, UInt64 totalSize, ISzAlloc alloc)\r
131	{\r
132	if (!p->blocks \|\| p->numBlocksAllocated == p->numBlocks)\r
133	{\r
134	size_t num = p->numBlocks * 2 + 1;\r
135	size_t newSize = sizeof(CXzBlockSizes) * num;\r
136	CXzBlockSizes *blocks;\r
137	if (newSize / sizeof(CXzBlockSizes) != num)\r
138	return SZ_ERROR_MEM;\r
139	blocks = (CXzBlockSizes *)alloc->Alloc(alloc, newSize);\r
140	if (!blocks)\r
141	return SZ_ERROR_MEM;\r
142	if (p->numBlocks != 0)\r
143	{\r
144	memcpy(blocks, p->blocks, p->numBlocks * sizeof(CXzBlockSizes));\r
145	alloc->Free(alloc, p->blocks);\r
146	}\r
147	p->blocks = blocks;\r
148	p->numBlocksAllocated = num;\r
149	}\r
150	{\r
151	CXzBlockSizes *block = &p->blocks[p->numBlocks++];\r
152	block->unpackSize = unpackSize;\r
153	block->totalSize = totalSize;\r
154	}\r
155	return SZ_OK;\r
156	}\r
157	\r
158	\r
159	/* ---------- CSeqCheckInStream ---------- */\r
160	\r
161	typedef struct\r
162	{\r
163	ISeqInStream p;\r
164	ISeqInStream *realStream;\r
165	UInt64 processed;\r
166	CXzCheck check;\r
167	} CSeqCheckInStream;\r
168	\r
169	static void SeqCheckInStream_Init(CSeqCheckInStream *p, unsigned mode)\r
170	{\r
171	p->processed = 0;\r
172	XzCheck_Init(&p->check, mode);\r
173	}\r
174	\r
175	static void SeqCheckInStream_GetDigest(CSeqCheckInStream p, Byte digest)\r
176	{\r
177	XzCheck_Final(&p->check, digest);\r
178	}\r
179	\r
180	static SRes SeqCheckInStream_Read(void pp, void data, size_t *size)\r
181	{\r
182	CSeqCheckInStream p = (CSeqCheckInStream )pp;\r
183	SRes res = p->realStream->Read(p->realStream, data, size);\r
184	XzCheck_Update(&p->check, data, *size);\r
185	p->processed += *size;\r
186	return res;\r
187	}\r
188	\r
189	\r
190	/* ---------- CSeqSizeOutStream ---------- */\r
191	\r
192	typedef struct\r
193	{\r
194	ISeqOutStream p;\r
195	ISeqOutStream *realStream;\r
196	UInt64 processed;\r
197	} CSeqSizeOutStream;\r
198	\r
199	static size_t MyWrite(void pp, const void data, size_t size)\r
200	{\r
201	CSeqSizeOutStream p = (CSeqSizeOutStream )pp;\r
202	size = p->realStream->Write(p->realStream, data, size);\r
203	p->processed += size;\r
204	return size;\r
205	}\r
206	\r
207	\r
208	/* ---------- CSeqInFilter ---------- */\r
209	\r
210	#define FILTER_BUF_SIZE (1 << 20)\r
211	\r
212	typedef struct\r
213	{\r
214	ISeqInStream p;\r
215	ISeqInStream *realStream;\r
216	IStateCoder StateCoder;\r
217	Byte *buf;\r
218	size_t curPos;\r
219	size_t endPos;\r
220	int srcWasFinished;\r
221	} CSeqInFilter;\r
222	\r
223	static SRes SeqInFilter_Read(void pp, void data, size_t *size)\r
224	{\r
225	CSeqInFilter p = (CSeqInFilter )pp;\r
226	size_t sizeOriginal = *size;\r
227	if (sizeOriginal == 0)\r
228	return SZ_OK;\r
229	*size = 0;\r
230	\r
231	for (;;)\r
232	{\r
233	if (!p->srcWasFinished && p->curPos == p->endPos)\r
234	{\r
235	p->curPos = 0;\r
236	p->endPos = FILTER_BUF_SIZE;\r
237	RINOK(p->realStream->Read(p->realStream, p->buf, &p->endPos));\r
238	if (p->endPos == 0)\r
239	p->srcWasFinished = 1;\r
240	}\r
241	{\r
242	SizeT srcLen = p->endPos - p->curPos;\r
243	int wasFinished;\r
244	SRes res;\r
245	*size = sizeOriginal;\r
246	res = p->StateCoder.Code(p->StateCoder.p, data, size, p->buf + p->curPos, &srcLen,\r
247	p->srcWasFinished, CODER_FINISH_ANY, &wasFinished);\r
248	p->curPos += srcLen;\r
249	if (*size != 0 \|\| srcLen == 0 \|\| res != 0)\r
250	return res;\r
251	}\r
252	}\r
253	}\r
254	\r
255	static void SeqInFilter_Construct(CSeqInFilter *p)\r
256	{\r
257	p->buf = NULL;\r
258	p->p.Read = SeqInFilter_Read;\r
259	}\r
260	\r
261	static void SeqInFilter_Free(CSeqInFilter *p)\r
262	{\r
263	if (p->buf)\r
264	{\r
265	g_Alloc.Free(&g_Alloc, p->buf);\r
266	p->buf = NULL;\r
267	}\r
268	}\r
269	\r
270	SRes BraState_SetFromMethod(IStateCoder p, UInt64 id, int encodeMode, ISzAlloc alloc);\r
271	\r
272	static SRes SeqInFilter_Init(CSeqInFilter p, const CXzFilter props)\r
273	{\r
274	if (!p->buf)\r
275	{\r
276	p->buf = g_Alloc.Alloc(&g_Alloc, FILTER_BUF_SIZE);\r
277	if (!p->buf)\r
278	return SZ_ERROR_MEM;\r
279	}\r
280	p->curPos = p->endPos = 0;\r
281	p->srcWasFinished = 0;\r
282	RINOK(BraState_SetFromMethod(&p->StateCoder, props->id, 1, &g_Alloc));\r
283	RINOK(p->StateCoder.SetProps(p->StateCoder.p, props->props, props->propsSize, &g_Alloc));\r
284	p->StateCoder.Init(p->StateCoder.p);\r
285	return SZ_OK;\r
286	}\r
287	\r
288	\r
289	/* ---------- CSbEncInStream ---------- */\r
290	\r
291	#ifdef USE_SUBBLOCK\r
292	\r
293	typedef struct\r
294	{\r
295	ISeqInStream p;\r
296	ISeqInStream *inStream;\r
297	CSbEnc enc;\r
298	} CSbEncInStream;\r
299	\r
300	static SRes SbEncInStream_Read(void pp, void data, size_t *size)\r
301	{\r
302	CSbEncInStream p = (CSbEncInStream )pp;\r
303	size_t sizeOriginal = *size;\r
304	if (sizeOriginal == 0)\r
305	return S_OK;\r
306	\r
307	for (;;)\r
308	{\r
309	if (p->enc.needRead && !p->enc.readWasFinished)\r
310	{\r
311	size_t processed = p->enc.needReadSizeMax;\r
312	RINOK(p->inStream->Read(p->inStream, p->enc.buf + p->enc.readPos, &processed));\r
313	p->enc.readPos += processed;\r
314	if (processed == 0)\r
315	{\r
316	p->enc.readWasFinished = True;\r
317	p->enc.isFinalFinished = True;\r
318	}\r
319	p->enc.needRead = False;\r
320	}\r
321	\r
322	*size = sizeOriginal;\r
323	RINOK(SbEnc_Read(&p->enc, data, size));\r
324	if (*size != 0 \|\| !p->enc.needRead)\r
325	return S_OK;\r
326	}\r
327	}\r
328	\r
329	void SbEncInStream_Construct(CSbEncInStream p, ISzAlloc alloc)\r
330	{\r
331	SbEnc_Construct(&p->enc, alloc);\r
332	p->p.Read = SbEncInStream_Read;\r
333	}\r
334	\r
335	SRes SbEncInStream_Init(CSbEncInStream *p)\r
336	{\r
337	return SbEnc_Init(&p->enc);\r
338	}\r
339	\r
340	void SbEncInStream_Free(CSbEncInStream *p)\r
341	{\r
342	SbEnc_Free(&p->enc);\r
343	}\r
344	\r
345	#endif\r
346	\r
347	\r
348	typedef struct\r
349	{\r
350	CLzma2EncHandle lzma2;\r
351	#ifdef USE_SUBBLOCK\r
352	CSbEncInStream sb;\r
353	#endif\r
354	CSeqInFilter filter;\r
355	ISzAlloc *alloc;\r
356	ISzAlloc *bigAlloc;\r
357	} CLzma2WithFilters;\r
358	\r
359	\r
360	static void Lzma2WithFilters_Construct(CLzma2WithFilters p, ISzAlloc alloc, ISzAlloc *bigAlloc)\r
361	{\r
362	p->alloc = alloc;\r
363	p->bigAlloc = bigAlloc;\r
364	p->lzma2 = NULL;\r
365	#ifdef USE_SUBBLOCK\r
366	SbEncInStream_Construct(&p->sb, alloc);\r
367	#endif\r
368	SeqInFilter_Construct(&p->filter);\r
369	}\r
370	\r
371	static SRes Lzma2WithFilters_Create(CLzma2WithFilters *p)\r
372	{\r
373	p->lzma2 = Lzma2Enc_Create(p->alloc, p->bigAlloc);\r
374	if (!p->lzma2)\r
375	return SZ_ERROR_MEM;\r
376	return SZ_OK;\r
377	}\r
378	\r
379	static void Lzma2WithFilters_Free(CLzma2WithFilters *p)\r
380	{\r
381	SeqInFilter_Free(&p->filter);\r
382	#ifdef USE_SUBBLOCK\r
383	SbEncInStream_Free(&p->sb);\r
384	#endif\r
385	if (p->lzma2)\r
386	{\r
387	Lzma2Enc_Destroy(p->lzma2);\r
388	p->lzma2 = NULL;\r
389	}\r
390	}\r
391	\r
392	\r
393	void XzProps_Init(CXzProps *p)\r
394	{\r
395	p->lzma2Props = NULL;\r
396	p->filterProps = NULL;\r
397	p->checkId = XZ_CHECK_CRC32;\r
398	}\r
399	\r
400	void XzFilterProps_Init(CXzFilterProps *p)\r
401	{\r
402	p->id = 0;\r
403	p->delta = 0;\r
404	p->ip = 0;\r
405	p->ipDefined = False;\r
406	}\r
407	\r
408	\r
409	static SRes Xz_Compress(CXzStream xz, CLzma2WithFilters lzmaf,\r
410	ISeqOutStream outStream, ISeqInStream inStream,\r
411	const CXzProps props, ICompressProgress progress)\r
412	{\r
413	xz->flags = (Byte)props->checkId;\r
414	\r
415	RINOK(Lzma2Enc_SetProps(lzmaf->lzma2, props->lzma2Props));\r
416	RINOK(Xz_WriteHeader(xz->flags, outStream));\r
417	\r
418	{\r
419	CSeqCheckInStream checkInStream;\r
420	CSeqSizeOutStream seqSizeOutStream;\r
421	CXzBlock block;\r
422	unsigned filterIndex = 0;\r
423	CXzFilter *filter = NULL;\r
424	const CXzFilterProps *fp = props->filterProps;\r
425	\r
426	XzBlock_ClearFlags(&block);\r
427	XzBlock_SetNumFilters(&block, 1 + (fp ? 1 : 0));\r
428	\r
429	if (fp)\r
430	{\r
431	filter = &block.filters[filterIndex++];\r
432	filter->id = fp->id;\r
433	filter->propsSize = 0;\r
434	\r
435	if (fp->id == XZ_ID_Delta)\r
436	{\r
437	filter->props[0] = (Byte)(fp->delta - 1);\r
438	filter->propsSize = 1;\r
439	}\r
440	else if (fp->ipDefined)\r
441	{\r
442	SetUi32(filter->props, fp->ip);\r
443	filter->propsSize = 4;\r
444	}\r
445	}\r
446	\r
447	{\r
448	CXzFilter *f = &block.filters[filterIndex++];\r
449	f->id = XZ_ID_LZMA2;\r
450	f->propsSize = 1;\r
451	f->props[0] = Lzma2Enc_WriteProperties(lzmaf->lzma2);\r
452	}\r
453	\r
454	seqSizeOutStream.p.Write = MyWrite;\r
455	seqSizeOutStream.realStream = outStream;\r
456	seqSizeOutStream.processed = 0;\r
457	\r
458	RINOK(XzBlock_WriteHeader(&block, &seqSizeOutStream.p));\r
459	\r
460	checkInStream.p.Read = SeqCheckInStream_Read;\r
461	checkInStream.realStream = inStream;\r
462	SeqCheckInStream_Init(&checkInStream, XzFlags_GetCheckType(xz->flags));\r
463	\r
464	if (fp)\r
465	{\r
466	#ifdef USE_SUBBLOCK\r
467	if (fp->id == XZ_ID_Subblock)\r
468	{\r
469	lzmaf->sb.inStream = &checkInStream.p;\r
470	RINOK(SbEncInStream_Init(&lzmaf->sb));\r
471	}\r
472	else\r
473	#endif\r
474	{\r
475	lzmaf->filter.realStream = &checkInStream.p;\r
476	RINOK(SeqInFilter_Init(&lzmaf->filter, filter));\r
477	}\r
478	}\r
479	\r
480	{\r
481	UInt64 packPos = seqSizeOutStream.processed;\r
482	\r
483	SRes res = Lzma2Enc_Encode(lzmaf->lzma2, &seqSizeOutStream.p,\r
484	fp ?\r
485	#ifdef USE_SUBBLOCK\r
486	(fp->id == XZ_ID_Subblock) ? &lzmaf->sb.p:\r
487	#endif\r
488	&lzmaf->filter.p:\r
489	&checkInStream.p,\r
490	progress);\r
491	\r
492	RINOK(res);\r
493	block.unpackSize = checkInStream.processed;\r
494	block.packSize = seqSizeOutStream.processed - packPos;\r
495	}\r
496	\r
497	{\r
498	unsigned padSize = 0;\r
499	Byte buf[128];\r
500	while ((((unsigned)block.packSize + padSize) & 3) != 0)\r
501	buf[padSize++] = 0;\r
502	SeqCheckInStream_GetDigest(&checkInStream, buf + padSize);\r
503	RINOK(WriteBytes(&seqSizeOutStream.p, buf, padSize + XzFlags_GetCheckSize(xz->flags)));\r
504	RINOK(Xz_AddIndexRecord(xz, block.unpackSize, seqSizeOutStream.processed - padSize, &g_Alloc));\r
505	}\r
506	}\r
507	return Xz_WriteFooter(xz, outStream);\r
508	}\r
509	\r
510	\r
511	SRes Xz_Encode(ISeqOutStream outStream, ISeqInStream inStream,\r
512	const CXzProps props, ICompressProgress progress)\r
513	{\r
514	SRes res;\r
515	CXzStream xz;\r
516	CLzma2WithFilters lzmaf;\r
517	Xz_Construct(&xz);\r
518	Lzma2WithFilters_Construct(&lzmaf, &g_Alloc, &g_BigAlloc);\r
519	res = Lzma2WithFilters_Create(&lzmaf);\r
520	if (res == SZ_OK)\r
521	res = Xz_Compress(&xz, &lzmaf, outStream, inStream, props, progress);\r
522	Lzma2WithFilters_Free(&lzmaf);\r
523	Xz_Free(&xz, &g_Alloc);\r
524	return res;\r
525	}\r
526	\r
527	\r
528	SRes Xz_EncodeEmpty(ISeqOutStream *outStream)\r
529	{\r
530	SRes res;\r
531	CXzStream xz;\r
532	Xz_Construct(&xz);\r
533	res = Xz_WriteHeader(xz.flags, outStream);\r
534	if (res == SZ_OK)\r
535	res = Xz_WriteFooter(&xz, outStream);\r
536	Xz_Free(&xz, &g_Alloc);\r
537	return res;\r
538	}\r