]> git.cworth.org Git - apitrace/blob - trace_file.cpp
Bundle Snappy source code.
[apitrace] / trace_file.cpp
1 #include "trace_file.hpp"
2
3 #include <assert.h>
4 #include <string.h>
5
6 #include <zlib.h>
7 #include <snappy.h>
8
9 #include <iostream>
10
11 using namespace Trace;
12
13 File::File(const std::string &filename,
14            File::Mode mode)
15     : m_filename(filename),
16       m_mode(mode),
17       m_isOpened(false)
18 {
19     if (!m_filename.empty()) {
20         open(m_filename, m_mode);
21     }
22 }
23
24
25 File::~File()
26 {
27     close();
28 }
29
30 bool File::isOpened() const
31 {
32     return m_isOpened;
33 }
34
35 File::Mode File::mode() const
36 {
37     return m_mode;
38 }
39
40 std::string File::filename() const
41 {
42     return m_filename;
43 }
44
45 bool File::open(const std::string &filename, File::Mode mode)
46 {
47     if (m_isOpened) {
48         close();
49     }
50     m_isOpened = rawOpen(filename, mode);
51     m_mode = mode;
52     return m_isOpened;
53 }
54
55 bool File::write(const void *buffer, int length)
56 {
57     if (!m_isOpened || m_mode != File::Write) {
58         return false;
59     }
60     return rawWrite(buffer, length);
61 }
62
63 bool File::read(void *buffer, int length)
64 {
65     if (!m_isOpened || m_mode != File::Read) {
66         return false;
67     }
68     return rawRead(buffer, length);
69 }
70
71 void File::close()
72 {
73     if (m_isOpened) {
74         rawClose();
75         m_isOpened = false;
76     }
77 }
78
79 void File::flush()
80 {
81     rawFlush();
82 }
83
84 int File::getc()
85 {
86     if (!m_isOpened || m_mode != File::Read) {
87         return 0;
88     }
89     return rawGetc();
90 }
91
92 bool File::isZLibCompressed(const std::string &filename)
93 {
94     std::fstream stream(filename.c_str(),
95                         std::fstream::binary | std::fstream::in);
96     if (!stream.is_open())
97         return false;
98
99     unsigned char byte1, byte2;
100     stream >> byte1;
101     stream >> byte2;
102     stream.close();
103
104     return (byte1 == 0x1f && byte2 == 0x8b);
105 }
106
107 ZLibFile::ZLibFile(const std::string &filename,
108                    File::Mode mode)
109     : File(filename, mode),
110       m_gzFile(NULL)
111 {
112 }
113
114 ZLibFile::~ZLibFile()
115 {
116 }
117
118 bool ZLibFile::rawOpen(const std::string &filename, File::Mode mode)
119 {
120     m_gzFile = gzopen(filename.c_str(),
121                       (mode == File::Write) ? "wb" : "rb");
122     return m_gzFile != NULL;
123 }
124
125 bool ZLibFile::rawWrite(const void *buffer, int length)
126 {
127     return gzwrite(m_gzFile, buffer, length) != -1;
128 }
129
130 bool ZLibFile::rawRead(void *buffer, int length)
131 {
132     return gzread(m_gzFile, buffer, length) != -1;
133 }
134
135 int ZLibFile::rawGetc()
136 {
137     return gzgetc(m_gzFile);
138 }
139
140 void ZLibFile::rawClose()
141 {
142     if (m_gzFile) {
143         gzclose(m_gzFile);
144         m_gzFile = NULL;
145     }
146 }
147
148 void ZLibFile::rawFlush()
149 {
150     gzflush(m_gzFile, Z_SYNC_FLUSH);
151 }
152
153 SnappyFile::SnappyFile(const std::string &filename,
154                               File::Mode mode)
155     : File(),
156       m_cache(0),
157       m_cachePtr(0),
158       m_cacheSize(0)
159 {
160     m_compressedCache = new char[SNAPPY_CHUNK_SIZE];
161 }
162
163 SnappyFile::~SnappyFile()
164 {
165     delete [] m_compressedCache;
166 }
167
168 bool SnappyFile::rawOpen(const std::string &filename, File::Mode mode)
169 {
170     std::ios_base::openmode fmode = std::fstream::binary;
171     if (mode == File::Write) {
172         fmode |= (std::fstream::out | std::fstream::trunc);
173         createCache(SNAPPY_CHUNK_SIZE);
174     } else if (mode == File::Read) {
175         fmode |= std::fstream::in;
176     }
177
178     m_stream.open(filename.c_str(), fmode);
179
180     //read in the initial buffer if we're reading
181     if (m_stream.is_open() && mode == File::Read) {
182         flushCache();
183     }
184     return m_stream.is_open();
185 }
186
187 bool SnappyFile::rawWrite(const void *buffer, int length)
188 {
189     if (freeCacheSize() > length) {
190         memcpy(m_cachePtr, buffer, length);
191         m_cachePtr += length;
192     } else if (freeCacheSize() == length) {
193         memcpy(m_cachePtr, buffer, length);
194         m_cachePtr += length;
195         flushCache();
196     } else {
197         int sizeToWrite = length;
198
199         while (sizeToWrite >= freeCacheSize()) {
200             int endSize = freeCacheSize();
201             int offset = length - sizeToWrite;
202             memcpy(m_cachePtr, (char*)buffer + offset, endSize);
203             sizeToWrite -= endSize;
204             m_cachePtr += endSize;
205             flushCache();
206         }
207         if (sizeToWrite) {
208             int offset = length - sizeToWrite;
209             memcpy(m_cachePtr, (char*)buffer + offset, sizeToWrite);
210             m_cachePtr += sizeToWrite;
211         }
212     }
213
214     return true;
215 }
216
217 bool SnappyFile::rawRead(void *buffer, int length)
218 {
219     if (m_stream.eof()) {
220         return false;
221     }
222     if (freeCacheSize() > length) {
223         memcpy(buffer, m_cachePtr, length);
224         m_cachePtr += length;
225     } else if (freeCacheSize() == length) {
226         memcpy(buffer, m_cachePtr, length);
227         m_cachePtr += length;
228         flushCache();
229     } else {
230         int sizeToRead = length;
231         int offset = 0;
232         while (sizeToRead) {
233             int chunkSize = std::min(freeCacheSize(), sizeToRead);
234             offset = length - sizeToRead;
235             memcpy((char*)buffer + offset, m_cachePtr, chunkSize);
236             m_cachePtr += chunkSize;
237             sizeToRead -= chunkSize;
238             if (sizeToRead > 0)
239                 flushCache();
240         }
241     }
242
243     return true;
244 }
245
246 int SnappyFile::rawGetc()
247 {
248     int c = 0;
249     if (!rawRead(&c, 1))
250         return -1;
251     return c;
252 }
253
254 void SnappyFile::rawClose()
255 {
256     flushCache();
257     m_stream.close();
258     delete [] m_cache;
259     m_cache = NULL;
260     m_cachePtr = NULL;
261 }
262
263 void SnappyFile::rawFlush()
264 {
265     m_stream.flush();
266 }
267
268 void SnappyFile::flushCache()
269 {
270     if (m_mode == File::Write) {
271         size_t compressedLength;
272
273         ::snappy::RawCompress(m_cache, SNAPPY_CHUNK_SIZE - freeCacheSize(),
274                               m_compressedCache, &compressedLength);
275
276         m_stream << compressedLength;
277         m_stream.write(m_compressedCache, compressedLength);
278         m_cachePtr = m_cache;
279     } else if (m_mode == File::Read) {
280         if (m_stream.eof())
281             return;
282         //assert(m_cachePtr == m_cache + m_cacheSize);
283         size_t compressedLength;
284         m_stream >> compressedLength;
285         m_stream.read((char*)m_compressedCache, compressedLength);
286         ::snappy::GetUncompressedLength(m_compressedCache, compressedLength,
287                                         &m_cacheSize);
288         if (m_cache)
289             delete [] m_cache;
290         createCache(m_cacheSize);
291         ::snappy::RawUncompress(m_compressedCache, compressedLength,
292                                 m_cache);
293     }
294 }
295
296 void SnappyFile::createCache(size_t size)
297 {
298     m_cache = new char[size];
299     m_cachePtr = m_cache;
300     m_cacheSize = size;
301 }