third_party/lzma_sdk/7zStream.c

   1 /* 7zStream.c -- 7z Stream functions
   2 2010-03-11 : Igor Pavlov : Public domain */
   3
   4 #include <string.h>
   5
   6 #include "Types.h"
   7
   8 SRes SeqInStream_Read2(ISeqInStream *stream, void *buf, size_t size, SRes errorType)
   9 {
  10   while (size != 0)
  11   {
  12     size_t processed = size;
  13     RINOK(stream->Read(stream, buf, &processed));
  14     if (processed == 0)
  15       return errorType;
  16     buf = (void *)((Byte *)buf + processed);
  17     size -= processed;
  18   }
  19   return SZ_OK;
  20 }
  21
  22 SRes SeqInStream_Read(ISeqInStream *stream, void *buf, size_t size)
  23 {
  24   return SeqInStream_Read2(stream, buf, size, SZ_ERROR_INPUT_EOF);
  25 }
  26
  27 SRes SeqInStream_ReadByte(ISeqInStream *stream, Byte *buf)
  28 {
  29   size_t processed = 1;
  30   RINOK(stream->Read(stream, buf, &processed));
  31   return (processed == 1) ? SZ_OK : SZ_ERROR_INPUT_EOF;
  32 }
  33
  34 SRes LookInStream_SeekTo(ILookInStream *stream, UInt64 offset)
  35 {
  36   Int64 t = offset;
  37   return stream->Seek(stream, &t, SZ_SEEK_SET);
  38 }
  39
  40 SRes LookInStream_LookRead(ILookInStream *stream, void *buf, size_t *size)
  41 {
  42   const void *lookBuf;
  43   if (*size == 0)
  44     return SZ_OK;
  45   RINOK(stream->Look(stream, &lookBuf, size));
  46   memcpy(buf, lookBuf, *size);
  47   return stream->Skip(stream, *size);
  48 }
  49
  50 SRes LookInStream_Read2(ILookInStream *stream, void *buf, size_t size, SRes errorType)
  51 {
  52   while (size != 0)
  53   {
  54     size_t processed = size;
  55     RINOK(stream->Read(stream, buf, &processed));
  56     if (processed == 0)
  57       return errorType;
  58     buf = (void *)((Byte *)buf + processed);
  59     size -= processed;
  60   }
  61   return SZ_OK;
  62 }
  63
  64 SRes LookInStream_Read(ILookInStream *stream, void *buf, size_t size)
  65 {
  66   return LookInStream_Read2(stream, buf, size, SZ_ERROR_INPUT_EOF);
  67 }
  68
  69 static SRes LookToRead_Look_Lookahead(void *pp, const void **buf, size_t *size)
  70 {
  71   SRes res = SZ_OK;
  72   CLookToRead *p = (CLookToRead *)pp;
  73   size_t size2 = p->size - p->pos;
  74   if (size2 == 0 && *size > 0)
  75   {
  76     p->pos = 0;
  77     size2 = LookToRead_BUF_SIZE;
  78     res = p->realStream->Read(p->realStream, p->buf, &size2);
  79     p->size = size2;
  80   }
  81   if (size2 < *size)
  82     *size = size2;
  83   *buf = p->buf + p->pos;
  84   return res;
  85 }
  86
  87 static SRes LookToRead_Look_Exact(void *pp, const void **buf, size_t *size)
  88 {
  89   SRes res = SZ_OK;
  90   CLookToRead *p = (CLookToRead *)pp;
  91   size_t size2 = p->size - p->pos;
  92   if (size2 == 0 && *size > 0)
  93   {
  94     p->pos = 0;
  95     if (*size > LookToRead_BUF_SIZE)
  96       *size = LookToRead_BUF_SIZE;
  97     res = p->realStream->Read(p->realStream, p->buf, size);
  98     size2 = p->size = *size;
  99   }
 100   if (size2 < *size)
 101     *size = size2;
 102   *buf = p->buf + p->pos;
 103   return res;
 104 }
 105
 106 static SRes LookToRead_Skip(void *pp, size_t offset)
 107 {
 108   CLookToRead *p = (CLookToRead *)pp;
 109   p->pos += offset;
 110   return SZ_OK;
 111 }
 112
 113 static SRes LookToRead_Read(void *pp, void *buf, size_t *size)
 114 {
 115   CLookToRead *p = (CLookToRead *)pp;
 116   size_t rem = p->size - p->pos;
 117   if (rem == 0)
 118     return p->realStream->Read(p->realStream, buf, size);
 119   if (rem > *size)
 120     rem = *size;
 121   memcpy(buf, p->buf + p->pos, rem);
 122   p->pos += rem;
 123   *size = rem;
 124   return SZ_OK;
 125 }
 126
 127 static SRes LookToRead_Seek(void *pp, Int64 *pos, ESzSeek origin)
 128 {
 129   CLookToRead *p = (CLookToRead *)pp;
 130   p->pos = p->size = 0;
 131   return p->realStream->Seek(p->realStream, pos, origin);
 132 }
 133
 134 void LookToRead_CreateVTable(CLookToRead *p, int lookahead)
 135 {
 136   p->s.Look = lookahead ?
 137       LookToRead_Look_Lookahead :
 138       LookToRead_Look_Exact;
 139   p->s.Skip = LookToRead_Skip;
 140   p->s.Read = LookToRead_Read;
 141   p->s.Seek = LookToRead_Seek;
 142 }
 143
 144 void LookToRead_Init(CLookToRead *p)
 145 {
 146   p->pos = p->size = 0;
 147 }
 148
 149 static SRes SecToLook_Read(void *pp, void *buf, size_t *size)
 150 {
 151   CSecToLook *p = (CSecToLook *)pp;
 152   return LookInStream_LookRead(p->realStream, buf, size);
 153 }
 154
 155 void SecToLook_CreateVTable(CSecToLook *p)
 156 {
 157   p->s.Read = SecToLook_Read;
 158 }
 159
 160 static SRes SecToRead_Read(void *pp, void *buf, size_t *size)
 161 {
 162   CSecToRead *p = (CSecToRead *)pp;
 163   return p->realStream->Read(p->realStream, buf, size);
 164 }
 165
 166 void SecToRead_CreateVTable(CSecToRead *p)
 167 {
 168   p->s.Read = SecToRead_Read;
 169 }