/gme/Data_Reader.cpp

http://game-music-emu.googlecode.com/ · C++ · 315 lines · 239 code · 59 blank · 17 comment · 37 complexity · e74925ddca850ec1d9940eb5e2fa398b MD5 · raw file

  1. // File_Extractor 0.4.0. http://www.slack.net/~ant/
  2. #include "Data_Reader.h"
  3. #include "blargg_endian.h"
  4. #include <assert.h>
  5. #include <string.h>
  6. #include <stdio.h>
  7. /* Copyright (C) 2005-2006 Shay Green. This module is free software; you
  8. can redistribute it and/or modify it under the terms of the GNU Lesser
  9. General Public License as published by the Free Software Foundation; either
  10. version 2.1 of the License, or (at your option) any later version. This
  11. module is distributed in the hope that it will be useful, but WITHOUT ANY
  12. WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
  13. FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
  14. details. You should have received a copy of the GNU Lesser General Public
  15. License along with this module; if not, write to the Free Software Foundation,
  16. Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */
  17. #include "blargg_source.h"
  18. const char Data_Reader::eof_error [] = "Unexpected end of file";
  19. blargg_err_t Data_Reader::read( void* p, long s )
  20. {
  21. long result = read_avail( p, s );
  22. if ( result != s )
  23. {
  24. if ( result >= 0 && result < s )
  25. return eof_error;
  26. return "Read error";
  27. }
  28. return 0;
  29. }
  30. blargg_err_t Data_Reader::skip( long count )
  31. {
  32. char buf [512];
  33. while ( count )
  34. {
  35. long n = sizeof buf;
  36. if ( n > count )
  37. n = count;
  38. count -= n;
  39. RETURN_ERR( read( buf, n ) );
  40. }
  41. return 0;
  42. }
  43. long File_Reader::remain() const { return size() - tell(); }
  44. blargg_err_t File_Reader::skip( long n )
  45. {
  46. assert( n >= 0 );
  47. if ( !n )
  48. return 0;
  49. return seek( tell() + n );
  50. }
  51. // Subset_Reader
  52. Subset_Reader::Subset_Reader( Data_Reader* dr, long size )
  53. {
  54. in = dr;
  55. remain_ = dr->remain();
  56. if ( remain_ > size )
  57. remain_ = size;
  58. }
  59. long Subset_Reader::remain() const { return remain_; }
  60. long Subset_Reader::read_avail( void* p, long s )
  61. {
  62. if ( s > remain_ )
  63. s = remain_;
  64. remain_ -= s;
  65. return in->read_avail( p, s );
  66. }
  67. // Remaining_Reader
  68. Remaining_Reader::Remaining_Reader( void const* h, long size, Data_Reader* r )
  69. {
  70. header = (char const*) h;
  71. header_end = header + size;
  72. in = r;
  73. }
  74. long Remaining_Reader::remain() const { return header_end - header + in->remain(); }
  75. long Remaining_Reader::read_first( void* out, long count )
  76. {
  77. long first = header_end - header;
  78. if ( first )
  79. {
  80. if ( first > count )
  81. first = count;
  82. void const* old = header;
  83. header += first;
  84. memcpy( out, old, first );
  85. }
  86. return first;
  87. }
  88. long Remaining_Reader::read_avail( void* out, long count )
  89. {
  90. long first = read_first( out, count );
  91. long second = count - first;
  92. if ( second )
  93. {
  94. second = in->read_avail( (char*) out + first, second );
  95. if ( second <= 0 )
  96. return second;
  97. }
  98. return first + second;
  99. }
  100. blargg_err_t Remaining_Reader::read( void* out, long count )
  101. {
  102. long first = read_first( out, count );
  103. long second = count - first;
  104. if ( !second )
  105. return 0;
  106. return in->read( (char*) out + first, second );
  107. }
  108. // Mem_File_Reader
  109. Mem_File_Reader::Mem_File_Reader( const void* p, long s ) :
  110. begin( (const char*) p ),
  111. size_( s )
  112. {
  113. pos = 0;
  114. }
  115. long Mem_File_Reader::size() const { return size_; }
  116. long Mem_File_Reader::read_avail( void* p, long s )
  117. {
  118. long r = remain();
  119. if ( s > r )
  120. s = r;
  121. memcpy( p, begin + pos, s );
  122. pos += s;
  123. return s;
  124. }
  125. long Mem_File_Reader::tell() const { return pos; }
  126. blargg_err_t Mem_File_Reader::seek( long n )
  127. {
  128. if ( n > size_ )
  129. return eof_error;
  130. pos = n;
  131. return 0;
  132. }
  133. // Callback_Reader
  134. Callback_Reader::Callback_Reader( callback_t c, long size, void* d ) :
  135. callback( c ),
  136. data( d )
  137. {
  138. remain_ = size;
  139. }
  140. long Callback_Reader::remain() const { return remain_; }
  141. long Callback_Reader::read_avail( void* out, long count )
  142. {
  143. if ( count > remain_ )
  144. count = remain_;
  145. if ( Callback_Reader::read( out, count ) )
  146. count = -1;
  147. return count;
  148. }
  149. blargg_err_t Callback_Reader::read( void* out, long count )
  150. {
  151. if ( count > remain_ )
  152. return eof_error;
  153. return callback( data, out, count );
  154. }
  155. // Std_File_Reader
  156. Std_File_Reader::Std_File_Reader() : file_( 0 ) { }
  157. Std_File_Reader::~Std_File_Reader() { close(); }
  158. blargg_err_t Std_File_Reader::open( const char* path )
  159. {
  160. file_ = fopen( path, "rb" );
  161. if ( !file_ )
  162. return "Couldn't open file";
  163. return 0;
  164. }
  165. long Std_File_Reader::size() const
  166. {
  167. long pos = tell();
  168. fseek( (FILE*) file_, 0, SEEK_END );
  169. long result = tell();
  170. fseek( (FILE*) file_, pos, SEEK_SET );
  171. return result;
  172. }
  173. long Std_File_Reader::read_avail( void* p, long s )
  174. {
  175. return fread( p, 1, s, (FILE*) file_ );
  176. }
  177. blargg_err_t Std_File_Reader::read( void* p, long s )
  178. {
  179. if ( s == (long) fread( p, 1, s, (FILE*) file_ ) )
  180. return 0;
  181. if ( feof( (FILE*) file_ ) )
  182. return eof_error;
  183. return "Couldn't read from file";
  184. }
  185. long Std_File_Reader::tell() const { return ftell( (FILE*) file_ ); }
  186. blargg_err_t Std_File_Reader::seek( long n )
  187. {
  188. if ( !fseek( (FILE*) file_, n, SEEK_SET ) )
  189. return 0;
  190. if ( n > size() )
  191. return eof_error;
  192. return "Error seeking in file";
  193. }
  194. void Std_File_Reader::close()
  195. {
  196. if ( file_ )
  197. {
  198. fclose( (FILE*) file_ );
  199. file_ = 0;
  200. }
  201. }
  202. // Gzip_File_Reader
  203. #ifdef HAVE_ZLIB_H
  204. #include "zlib.h"
  205. static const char* get_gzip_eof( const char* path, long* eof )
  206. {
  207. FILE* file = fopen( path, "rb" );
  208. if ( !file )
  209. return "Couldn't open file";
  210. unsigned char buf [4];
  211. if ( fread( buf, 2, 1, file ) > 0 && buf [0] == 0x1F && buf [1] == 0x8B )
  212. {
  213. fseek( file, -4, SEEK_END );
  214. fread( buf, 4, 1, file );
  215. *eof = get_le32( buf );
  216. }
  217. else
  218. {
  219. fseek( file, 0, SEEK_END );
  220. *eof = ftell( file );
  221. }
  222. const char* err = (ferror( file ) || feof( file )) ? "Couldn't get file size" : 0;
  223. fclose( file );
  224. return err;
  225. }
  226. Gzip_File_Reader::Gzip_File_Reader() : file_( 0 ) { }
  227. Gzip_File_Reader::~Gzip_File_Reader() { close(); }
  228. blargg_err_t Gzip_File_Reader::open( const char* path )
  229. {
  230. close();
  231. RETURN_ERR( get_gzip_eof( path, &size_ ) );
  232. file_ = gzopen( path, "rb" );
  233. if ( !file_ )
  234. return "Couldn't open file";
  235. return 0;
  236. }
  237. long Gzip_File_Reader::size() const { return size_; }
  238. long Gzip_File_Reader::read_avail( void* p, long s ) { return gzread( file_, p, s ); }
  239. long Gzip_File_Reader::tell() const { return gztell( file_ ); }
  240. blargg_err_t Gzip_File_Reader::seek( long n )
  241. {
  242. if ( gzseek( file_, n, SEEK_SET ) >= 0 )
  243. return 0;
  244. if ( n > size_ )
  245. return eof_error;
  246. return "Error seeking in file";
  247. }
  248. void Gzip_File_Reader::close()
  249. {
  250. if ( file_ )
  251. {
  252. gzclose( file_ );
  253. file_ = 0;
  254. }
  255. }
  256. #endif