include cstdio to fix build with gcc 4.4
[enigma2.git] / lib / base / rawfile.cpp
1 #include <cstdio>
2 #include <unistd.h>
3 #include <fcntl.h>
4 #include <lib/base/rawfile.h>
5 #include <lib/base/eerror.h>
6
7 eRawFile::eRawFile()
8 {
9         m_fd = -1;
10         m_file = 0;
11         m_splitsize = 0;
12         m_totallength = 0;
13         m_current_offset = 0;
14         m_base_offset = 0;
15         m_last_offset = 0;
16         m_nrfiles = 0;
17         m_current_file = 0;
18 }
19
20 eRawFile::~eRawFile()
21 {
22         close();
23 }
24
25 int eRawFile::open(const char *filename, int cached)
26 {
27         close();
28         m_cached = cached;
29         m_basename = filename;
30         scan();
31         m_current_offset = 0;
32         m_last_offset = 0;
33         if (!m_cached)
34         {
35                 m_fd = ::open(filename, O_RDONLY | O_LARGEFILE);
36                 return m_fd;
37         } else
38         {
39                 m_file = ::fopen64(filename, "rb");
40                 if (!m_file)
41                         return -1;
42                 return 0;
43         }
44 }
45
46 void eRawFile::setfd(int fd)
47 {
48         close();
49         m_cached = 0;
50         m_nrfiles = 1;
51         m_fd = fd;
52 }
53
54 off_t eRawFile::lseek(off_t offset, int whence)
55 {
56 //      eDebug("lseek: %lld, %d", offset, whence);
57                 /* if there is only one file, use the native lseek - the file could be growing! */
58         if (m_nrfiles < 2)
59         {
60                 if (!m_cached)
61                         return ::lseek(m_fd, offset, whence);
62                 else
63                 {
64                         ::fseeko(m_file, offset, whence);
65                         return ::ftello(m_file);
66                 }
67         }
68         switch (whence)
69         {
70         case SEEK_SET:
71                 m_current_offset = offset;
72                 break;
73         case SEEK_CUR:
74                 m_current_offset += offset;
75                 break;
76         case SEEK_END:
77                 m_current_offset = m_totallength + offset;
78                 break;
79         }
80
81         if (m_current_offset < 0)
82                 m_current_offset = 0;
83         return m_current_offset;
84 }
85
86 int eRawFile::close()
87 {
88         if (m_cached)
89         {
90                 if (!m_file)
91                         return -1;
92                 ::fclose(m_file);
93                 m_file = 0;
94                 return 0;
95         } else
96         {
97                 int ret = ::close(m_fd);
98                 m_fd = -1;
99                 return ret;
100         }
101 }
102
103 ssize_t eRawFile::read(void *buf, size_t count)
104 {
105 //      eDebug("read: %p, %d", buf, count);
106         switchOffset(m_current_offset);
107         
108         if (m_nrfiles >= 2)
109         {
110                 if (m_current_offset + count > m_totallength)
111                         count = m_totallength - m_current_offset;
112                 if (count < 0)
113                         return 0;
114         }
115         
116         int ret;
117         
118         if (!m_cached)
119                 ret = ::read(m_fd, buf, count);
120         else
121                 ret = ::fread(buf, 1, count, m_file);
122
123         if (ret > 0)
124                 m_current_offset = m_last_offset += ret;
125         return ret;
126 }
127
128 int eRawFile::valid()
129 {
130         if (!m_cached)
131                 return m_fd != -1;
132         else
133                 return !!m_file;
134 }
135
136 void eRawFile::scan()
137 {
138         m_nrfiles = 0;
139         m_totallength = 0;
140         while (m_nrfiles < 1000) /* .999 is the last possible */
141         {
142                 if (!m_cached)
143                 {
144                         int f = openFileUncached(m_nrfiles);
145                         if (f < 0)
146                                 break;
147                         if (!m_nrfiles)
148                                 m_splitsize = ::lseek(f, 0, SEEK_END);
149                         m_totallength += ::lseek(f, 0, SEEK_END);
150                         ::close(f);
151                 } else
152                 {
153                         FILE *f = openFileCached(m_nrfiles);
154                         if (!f)
155                                 break;
156                         ::fseeko(f, 0, SEEK_END);
157                         if (!m_nrfiles)
158                                 m_splitsize = ::ftello(f);
159                         m_totallength += ::ftello(f);
160                         ::fclose(f);
161                 }
162                 
163                 ++m_nrfiles;
164         }
165 //      eDebug("found %d files, splitsize: %llx, totallength: %llx", m_nrfiles, m_splitsize, m_totallength);
166 }
167
168 int eRawFile::switchOffset(off_t off)
169 {
170         if (m_splitsize)
171         {
172                 int filenr = off / m_splitsize;
173                 if (filenr >= m_nrfiles)
174                         filenr = m_nrfiles - 1;
175                 if (filenr != m_current_file)
176                 {       
177 //                      eDebug("-> %d", filenr);
178                         close();
179                         if (!m_cached)
180                                 m_fd = openFileUncached(filenr);
181                         else
182                                 m_file = openFileCached(filenr);
183                         m_last_offset = m_base_offset = m_splitsize * filenr;
184                         m_current_file = filenr;
185                 }
186         } else
187                 m_base_offset = 0;
188         
189         if (off != m_last_offset)
190         {
191                 if (!m_cached)
192                         m_last_offset = ::lseek(m_fd, off - m_base_offset, SEEK_SET) + m_base_offset;
193                 else
194                 {
195                         ::fseeko(m_file, off - m_base_offset, SEEK_SET);
196                         m_last_offset = ::ftello(m_file) + m_base_offset;
197                 }
198                 return m_last_offset;
199         } else
200         {
201                 return m_last_offset;
202         }
203 }
204
205 /* m_cached */
206 FILE *eRawFile::openFileCached(int nr)
207 {
208         std::string filename = m_basename;
209         if (nr)
210         {
211                 char suffix[5];
212                 snprintf(suffix, 5, ".%03d", nr);
213                 filename += suffix;
214         }
215         return ::fopen64(filename.c_str(), "rb");
216 }
217
218 /* !m_cached */
219 int eRawFile::openFileUncached(int nr)
220 {
221         std::string filename = m_basename;
222         if (nr)
223         {
224                 char suffix[5];
225                 snprintf(suffix, 5, ".%03d", nr);
226                 filename += suffix;
227         }
228         return ::open(filename.c_str(), O_RDONLY | O_LARGEFILE);
229 }