Boost GIL


device.hpp
1 //
2 // Copyright 2007-2012 Christian Henning, Andreas Pokorny
3 //
4 // Distributed under the Boost Software License, Version 1.0
5 // See accompanying file LICENSE_1_0.txt or copy at
6 // http://www.boost.org/LICENSE_1_0.txt
7 //
8 #ifndef BOOST_GIL_IO_DEVICE_HPP
9 #define BOOST_GIL_IO_DEVICE_HPP
10 
11 #include <boost/gil/detail/mp11.hpp>
12 #include <boost/gil/io/base.hpp>
13 
14 #include <cstdio>
15 #include <memory>
16 #include <type_traits>
17 
18 namespace boost { namespace gil {
19 
20 #if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
21 #pragma warning(push)
22 #pragma warning(disable:4512) //assignment operator could not be generated
23 #endif
24 
25 namespace detail {
26 
27 template < typename T > struct buff_item
28 {
29  static const unsigned int size = sizeof( T );
30 };
31 
32 template <> struct buff_item< void >
33 {
34  static const unsigned int size = 1;
35 };
36 
47 template< typename FormatTag >
49 {
50 public:
51 
52  using format_tag_t = FormatTag;
53 
54 public:
55 
57  struct read_tag {};
58  struct write_tag {};
59 
63  file_stream_device( const std::string& file_name
64  , read_tag tag = read_tag()
65  )
66  : file_stream_device(file_name.c_str(), tag)
67  {}
68 
72  file_stream_device( const char* file_name
73  , read_tag = read_tag()
74  )
75  {
76  FILE* file = nullptr;
77 
78  io_error_if( ( file = fopen( file_name, "rb" )) == nullptr
79  , "file_stream_device: failed to open file for reading"
80  );
81 
82  _file = file_ptr_t( file
83  , file_deleter
84  );
85  }
86 
90  file_stream_device( const std::string& file_name
91  , write_tag tag
92  )
93  : file_stream_device(file_name.c_str(), tag)
94  {}
95 
99  file_stream_device( const char* file_name
100  , write_tag
101  )
102  {
103  FILE* file = nullptr;
104 
105  io_error_if( ( file = fopen( file_name, "wb" )) == nullptr
106  , "file_stream_device: failed to open file for writing"
107  );
108 
109  _file = file_ptr_t( file
110  , file_deleter
111  );
112  }
113 
117  file_stream_device( FILE* file )
118  : _file( file
119  , file_deleter
120  )
121  {}
122 
123  FILE* get() { return _file.get(); }
124  const FILE* get() const { return _file.get(); }
125 
126  int getc_unchecked()
127  {
128  return std::getc( get() );
129  }
130 
131  char getc()
132  {
133  int ch;
134 
135  io_error_if( ( ch = std::getc( get() )) == EOF
136  , "file_stream_device: unexpected EOF"
137  );
138 
139  return ( char ) ch;
140  }
141 
143  std::size_t read( byte_t* data
144  , std::size_t count
145  )
146  {
147  std::size_t num_elements = fread( data
148  , 1
149  , static_cast<int>( count )
150  , get()
151  );
152 
154  io_error_if( ferror( get() )
155  , "file_stream_device: file read error"
156  );
157 
158  //libjpeg sometimes reads blocks in 4096 bytes even when the file is smaller than that.
159  //return value indicates how much was actually read
160  //returning less than "count" is not an error
161  return num_elements;
162  }
163 
165  template< typename T
166  , int N
167  >
168  void read( T (&buf)[N] )
169  {
170  io_error_if( read( buf, N ) < N
171  , "file_stream_device: file read error"
172  );
173  }
174 
176  uint8_t read_uint8()
177  {
178  byte_t m[1];
179 
180  read( m );
181  return m[0];
182  }
183 
185  uint16_t read_uint16()
186  {
187  byte_t m[2];
188 
189  read( m );
190  return (m[1] << 8) | m[0];
191  }
192 
194  uint32_t read_uint32()
195  {
196  byte_t m[4];
197 
198  read( m );
199  return (m[3] << 24) | (m[2] << 16) | (m[1] << 8) | m[0];
200  }
201 
203  template < typename T >
204  std::size_t write( const T* buf
205  , std::size_t count
206  )
207  {
208  std::size_t num_elements = fwrite( buf
209  , buff_item<T>::size
210  , count
211  , get()
212  );
213 
214  //return value indicates how much was actually written
215  //returning less than "count" is not an error
216  return num_elements;
217  }
218 
220  template < typename T
221  , std::size_t N
222  >
223  void write( const T (&buf)[N] )
224  {
225  io_error_if( write( buf, N ) < N
226  , "file_stream_device: file write error"
227  );
228  return ;
229  }
230 
232  void write_uint8( uint8_t x )
233  {
234  byte_t m[1] = { x };
235  write(m);
236  }
237 
239  void write_uint16( uint16_t x )
240  {
241  byte_t m[2];
242 
243  m[0] = byte_t( x >> 0 );
244  m[1] = byte_t( x >> 8 );
245 
246  write( m );
247  }
248 
250  void write_uint32( uint32_t x )
251  {
252  byte_t m[4];
253 
254  m[0] = byte_t( x >> 0 );
255  m[1] = byte_t( x >> 8 );
256  m[2] = byte_t( x >> 16 );
257  m[3] = byte_t( x >> 24 );
258 
259  write( m );
260  }
261 
262  void seek( long count, int whence = SEEK_SET )
263  {
264  io_error_if( fseek( get()
265  , count
266  , whence
267  ) != 0
268  , "file_stream_device: file seek error"
269  );
270  }
271 
272  long int tell()
273  {
274  long int pos = ftell( get() );
275 
276  io_error_if( pos == -1L
277  , "file_stream_device: file position error"
278  );
279 
280  return pos;
281  }
282 
283  void flush()
284  {
285  fflush( get() );
286  }
287 
289  void print_line( const std::string& line )
290  {
291  std::size_t num_elements = fwrite( line.c_str()
292  , sizeof( char )
293  , line.size()
294  , get()
295  );
296 
297  io_error_if( num_elements < line.size()
298  , "file_stream_device: line print error"
299  );
300  }
301 
302  int error()
303  {
304  return ferror( get() );
305  }
306 
307 private:
308 
309  static void file_deleter( FILE* file )
310  {
311  if( file )
312  {
313  fclose( file );
314  }
315  }
316 
317 private:
318 
319  using file_ptr_t = std::shared_ptr<FILE> ;
320  file_ptr_t _file;
321 };
322 
326 template< typename FormatTag >
328 {
329 public:
330  istream_device( std::istream& in )
331  : _in( in )
332  {
333  // does the file exists?
334  io_error_if( !in
335  , "istream_device: Stream is not valid."
336  );
337  }
338 
339  int getc_unchecked()
340  {
341  return _in.get();
342  }
343 
344  char getc()
345  {
346  int ch;
347 
348  io_error_if( ( ch = _in.get() ) == EOF
349  , "istream_device: unexpected EOF"
350  );
351 
352  return ( char ) ch;
353  }
354 
355  std::size_t read( byte_t* data
356  , std::size_t count )
357  {
358  std::streamsize cr = 0;
359 
360  do
361  {
362  _in.peek();
363  std::streamsize c = _in.readsome( reinterpret_cast< char* >( data )
364  , static_cast< std::streamsize >( count ));
365 
366  count -= static_cast< std::size_t >( c );
367  data += c;
368  cr += c;
369 
370  } while( count && _in );
371 
372  return static_cast< std::size_t >( cr );
373  }
374 
376  template<typename T, int N>
377  void read(T (&buf)[N])
378  {
379  read(buf, N);
380  }
381 
383  uint8_t read_uint8()
384  {
385  byte_t m[1];
386 
387  read( m );
388  return m[0];
389  }
390 
392  uint16_t read_uint16()
393  {
394  byte_t m[2];
395 
396  read( m );
397  return (m[1] << 8) | m[0];
398  }
399 
401  uint32_t read_uint32()
402  {
403  byte_t m[4];
404 
405  read( m );
406  return (m[3] << 24) | (m[2] << 16) | (m[1] << 8) | m[0];
407  }
408 
409  void seek( long count, int whence = SEEK_SET )
410  {
411  _in.seekg( count
412  , whence == SEEK_SET ? std::ios::beg
413  :( whence == SEEK_CUR ? std::ios::cur
414  : std::ios::end )
415  );
416  }
417 
418  void write(const byte_t*, std::size_t)
419  {
420  io_error( "istream_device: Bad io error." );
421  }
422 
423  void flush() {}
424 
425 private:
426 
427  std::istream& _in;
428 };
429 
433 template< typename FormatTag >
435 {
436 public:
437  ostream_device( std::ostream & out )
438  : _out( out )
439  {
440  }
441 
442  std::size_t read(byte_t *, std::size_t)
443  {
444  io_error( "ostream_device: Bad io error." );
445  return 0;
446  }
447 
448  void seek( long count, int whence )
449  {
450  _out.seekp( count
451  , whence == SEEK_SET
452  ? std::ios::beg
453  : ( whence == SEEK_CUR
454  ?std::ios::cur
455  :std::ios::end )
456  );
457  }
458 
459  void write( const byte_t* data
460  , std::size_t count )
461  {
462  _out.write( reinterpret_cast<char const*>( data )
463  , static_cast<std::streamsize>( count )
464  );
465  }
466 
468  template < typename T
469  , std::size_t N
470  >
471  void write( const T (&buf)[N] )
472  {
473  write( buf, N );
474  }
475 
477  void write_uint8( uint8_t x )
478  {
479  byte_t m[1] = { x };
480  write(m);
481  }
482 
484  void write_uint16( uint16_t x )
485  {
486  byte_t m[2];
487 
488  m[0] = byte_t( x >> 0 );
489  m[1] = byte_t( x >> 8 );
490 
491  write( m );
492  }
493 
495  void write_uint32( uint32_t x )
496  {
497  byte_t m[4];
498 
499  m[0] = byte_t( x >> 0 );
500  m[1] = byte_t( x >> 8 );
501  m[2] = byte_t( x >> 16 );
502  m[3] = byte_t( x >> 24 );
503 
504  write( m );
505  }
506 
507  void flush()
508  {
509  _out << std::flush;
510  }
511 
513  void print_line( const std::string& line )
514  {
515  _out << line;
516  }
517 
518 
519 
520 private:
521 
522  std::ostream& _out;
523 };
524 
525 
530 template< typename IODevice > struct is_input_device : std::false_type{};
531 template< typename FormatTag > struct is_input_device< file_stream_device< FormatTag > > : std::true_type{};
532 template< typename FormatTag > struct is_input_device< istream_device< FormatTag > > : std::true_type{};
533 
534 template< typename FormatTag
535  , typename T
536  , typename D = void
537  >
538 struct is_adaptable_input_device : std::false_type{};
539 
540 template <typename FormatTag, typename T>
541 struct is_adaptable_input_device
542 <
543  FormatTag,
544  T,
545  typename std::enable_if
546  <
547  mp11::mp_or
548  <
549  std::is_base_of<std::istream, T>,
550  std::is_same<std::istream, T>
551  >::value
552  >::type
553 > : std::true_type
554 {
555  using device_type = istream_device<FormatTag>;
556 };
557 
558 template< typename FormatTag >
559 struct is_adaptable_input_device< FormatTag
560  , FILE*
561  , void
562  >
563  : std::true_type
564 {
565  using device_type = file_stream_device<FormatTag>;
566 };
567 
571 template< typename FormatTag
572  , typename T
573  , typename D = void
574  >
575 struct is_read_device : std::false_type
576 {};
577 
578 template <typename FormatTag, typename T>
579 struct is_read_device
580 <
581  FormatTag,
582  T,
583  typename std::enable_if
584  <
585  mp11::mp_or
586  <
587  is_input_device<FormatTag>,
588  is_adaptable_input_device<FormatTag, T>
589  >::value
590  >::type
591 > : std::true_type
592 {
593 };
594 
595 
600 template<typename IODevice> struct is_output_device : std::false_type{};
601 
602 template< typename FormatTag > struct is_output_device< file_stream_device< FormatTag > > : std::true_type{};
603 template< typename FormatTag > struct is_output_device< ostream_device < FormatTag > > : std::true_type{};
604 
605 template< typename FormatTag
606  , typename IODevice
607  , typename D = void
608  >
609 struct is_adaptable_output_device : std::false_type {};
610 
611 template <typename FormatTag, typename T>
612 struct is_adaptable_output_device
613 <
614  FormatTag,
615  T,
616  typename std::enable_if
617  <
618  mp11::mp_or
619  <
620  std::is_base_of<std::ostream, T>,
621  std::is_same<std::ostream, T>
622  >::value
623  >::type
624 > : std::true_type
625 {
626  using device_type = ostream_device<FormatTag>;
627 };
628 
629 template<typename FormatTag> struct is_adaptable_output_device<FormatTag,FILE*,void>
630  : std::true_type
631 {
632  using device_type = file_stream_device<FormatTag>;
633 };
634 
635 
639 template< typename FormatTag
640  , typename T
641  , typename D = void
642  >
643 struct is_write_device : std::false_type
644 {};
645 
646 template <typename FormatTag, typename T>
647 struct is_write_device
648 <
649  FormatTag,
650  T,
651  typename std::enable_if
652  <
653  mp11::mp_or
654  <
655  is_output_device<FormatTag>,
656  is_adaptable_output_device<FormatTag, T>
657  >::value
658  >::type
659 > : std::true_type
660 {
661 };
662 
663 } // namespace detail
664 
665 template< typename Device, typename FormatTag > class scanline_reader;
666 template< typename Device, typename FormatTag, typename ConversionPolicy > class reader;
667 
668 template< typename Device, typename FormatTag, typename Log = no_log > class writer;
669 
670 template< typename Device, typename FormatTag > class dynamic_image_reader;
671 template< typename Device, typename FormatTag, typename Log = no_log > class dynamic_image_writer;
672 
673 
674 namespace detail {
675 
676 template< typename T >
677 struct is_reader : std::false_type
678 {};
679 
680 template< typename Device
681  , typename FormatTag
682  , typename ConversionPolicy
683  >
684 struct is_reader< reader< Device
685  , FormatTag
686  , ConversionPolicy
687  >
688  > : std::true_type
689 {};
690 
691 template< typename T >
692 struct is_dynamic_image_reader : std::false_type
693 {};
694 
695 template< typename Device
696  , typename FormatTag
697  >
698 struct is_dynamic_image_reader< dynamic_image_reader< Device
699  , FormatTag
700  >
701  > : std::true_type
702 {};
703 
704 template< typename T >
705 struct is_writer : std::false_type
706 {};
707 
708 template< typename Device
709  , typename FormatTag
710  >
711 struct is_writer< writer< Device
712  , FormatTag
713  >
714  > : std::true_type
715 {};
716 
717 template< typename T >
718 struct is_dynamic_image_writer : std::false_type
719 {};
720 
721 template< typename Device
722  , typename FormatTag
723  >
724 struct is_dynamic_image_writer< dynamic_image_writer< Device
725  , FormatTag
726  >
727  > : std::true_type
728 {};
729 
730 } // namespace detail
731 
732 #if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
733 #pragma warning(pop)
734 #endif
735 
736 } // namespace gil
737 } // namespace boost
738 
739 #endif
Definition: device.hpp:530
void write_uint8(uint8_t x)
Writes byte.
Definition: device.hpp:477
file_stream_device(const std::string &file_name, write_tag tag)
Definition: device.hpp:90
std::size_t read(byte_t *data, std::size_t count)
Definition: device.hpp:143
void print_line(const std::string &line)
Prints formatted ASCII text.
Definition: device.hpp:289
void read(T(&buf)[N])
Reads array.
Definition: device.hpp:377
uint16_t read_uint16()
Reads 16 bit little endian integer.
Definition: device.hpp:185
std::size_t write(const T *buf, std::size_t count)
Writes number of elements from a buffer.
Definition: device.hpp:204
uint16_t read_uint16()
Reads 16 bit little endian integer.
Definition: device.hpp:392
void write(const T(&buf)[N])
Writes array.
Definition: device.hpp:223
Definition: device.hpp:575
void write_uint32(uint32_t x)
Writes 32 bit little endian integer.
Definition: device.hpp:250
void write_uint8(uint8_t x)
Writes byte.
Definition: device.hpp:232
uint32_t read_uint32()
Reads 32 bit little endian integer.
Definition: device.hpp:194
void write_uint16(uint16_t x)
Writes 16 bit little endian integer.
Definition: device.hpp:239
uint8_t read_uint8()
Reads byte.
Definition: device.hpp:383
Used to overload the constructor.
Definition: device.hpp:57
uint8_t read_uint8()
Reads byte.
Definition: device.hpp:176
Definition: device.hpp:600
uint32_t read_uint32()
Reads 32 bit little endian integer.
Definition: device.hpp:401
file_stream_device(const char *file_name, read_tag=read_tag())
Definition: device.hpp:72
void write(const T(&buf)[N])
Writes array.
Definition: device.hpp:471
file_stream_device(const std::string &file_name, read_tag tag=read_tag())
Definition: device.hpp:63
Definition: device.hpp:643
void write_uint16(uint16_t x)
Writes 16 bit little endian integer.
Definition: device.hpp:484
Definition: device.hpp:434
Definition: device.hpp:327
file_stream_device(FILE *file)
Definition: device.hpp:117
void print_line(const std::string &line)
Prints formatted ASCII text.
Definition: device.hpp:513
void read(T(&buf)[N])
Reads array.
Definition: device.hpp:168
file_stream_device(const char *file_name, write_tag)
Definition: device.hpp:99
void write_uint32(uint32_t x)
Writes 32 bit little endian integer.
Definition: device.hpp:495