← Back to branch summary

~ubuntu-branches/debian/sid/mame/sid

« back to all changes in this revision

Viewing changes to src/lib/lib7z/7zStream.c

  • Committer: Package Import Robot
  • Author(s): Jordi Mallach, Emmanuel Kasper, Jordi Mallach
  • Date: 2012-06-05 20:02:23 UTC
  • mfrom: (0.3.1) (0.1.4)
  • Revision ID: package-import@ubuntu.com-20120605200223-gnlpogjrg6oqe9md
Tags: 0.146-1
[ Emmanuel Kasper ]
* New upstream release
* Drop patch to fix man pages section and patches to link with flac 
  and jpeg system lib: all this has been pushed upstream by Cesare Falco
* Add DM-Upload-Allowed: yes field.

[ Jordi Mallach ]
* Create a "gnu" TARGETOS stanza that defines NO_AFFINITY_NP.
* Stop setting TARGETOS to "unix" in d/rules. It should be autodetected,
  and set to the appropriate value.
* mame_manpage_section.patch: Change mame's manpage section to 6 (games),
  in the TH declaration.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/lib/lib7z/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
}