Line data    Source code

       1             : /*******************************************************************************
       2             :  *  Project: libopencad
       3             :  *  Purpose: OpenSource CAD formats support library
       4             :  *  Author: Alexandr Borzykh, mush3d at gmail.com
       5             :  *  Author: Dmitry Baryshnikov, bishop.dev@gmail.com
       6             :  *  Language: C++
       7             :  *******************************************************************************
       8             :  *  The MIT License (MIT)
       9             :  *
      10             :  *  Copyright (c) 2016 Alexandr Borzykh
      11             :  *  Copyright (c) 2016 NextGIS, <info@nextgis.com>
      12             :  *
      13             :   * SPDX-License-Identifier: MIT
      14             :  *******************************************************************************/
      15             : #ifndef DWG_IO_H
      16             : #define DWG_IO_H
      17             : 
      18             : #include "cadheader.h"
      19             : #include "cadobjects.h"
      20             : 
      21             : #include <string>
      22             : #include <algorithm>
      23             : 
      24             : /* DATA TYPES CONSTANTS */
      25             : 
      26             : #define BITSHORT_NORMAL         0x0
      27             : #define BITSHORT_UNSIGNED_CHAR  0x1
      28             : #define BITSHORT_ZERO_VALUE     0x2
      29             : #define BITSHORT_256            0x3
      30             : 
      31             : #define BITLONG_NORMAL          0x0
      32             : #define BITLONG_UNSIGNED_CHAR   0x1
      33             : #define BITLONG_ZERO_VALUE      0x2
      34             : #define BITLONG_NOT_USED        0x3
      35             : 
      36             : #define BITDOUBLE_NORMAL        0x0
      37             : #define BITDOUBLE_ONE_VALUE     0x1
      38             : #define BITDOUBLE_ZERO_VALUE    0x2
      39             : #define BITDOUBLE_NOT_USED      0x3
      40             : 
      41             : #define BITDOUBLEWD_DEFAULT_VALUE  0x0
      42             : #define BITDOUBLEWD_4BYTES_PATCHED 0x1
      43             : #define BITDOUBLEWD_6BYTES_PATCHED 0x2
      44             : #define BITDOUBLEWD_FULL_RD        0x3
      45             : 
      46             : #if defined(__BYTE_ORDER__) && __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
      47             : #define CAD_MSB
      48             : #endif
      49             : 
      50             : namespace DWGConstants {
      51             : extern const size_t SentinelLength;
      52             : extern const char * HeaderVariablesStart;
      53             : extern const char * HeaderVariablesEnd;
      54             : extern const char * DSClassesStart;
      55             : extern const char * DSClassesEnd;
      56             : 
      57             : /* UNUSED
      58             : static const char * DWGDSPreviewStart
      59             :             = "\x1F\x25\x6D\x07\xD4\x36\x28\x28\x9D\x57\xCA\x3F\x9D\x44\x10\x2B";
      60             : static const char * DWGDSPreviewEnd
      61             :             = "\xE0\xDA\x92\xF8\x2B\xc9\xD7\xD7\x62\xA8\x35\xC0\x62\xBB\xEF\xD4";
      62             : 
      63             : static const char * DWGSecondFileHeaderStart
      64             :             = "\xD4\x7B\x21\xCE\x28\x93\x9F\xBF\x53\x24\x40\x09\x12\x3C\xAA\x01";
      65             : static const char * DWGSecondFileHeaderEnd
      66             :             = "\x2B\x84\xDE\x31\xD7\x6C\x60\x40\xAC\xDB\xBF\xF6\xED\xC3\x55\xFE";
      67             : */
      68             : }
      69             : 
      70             : // TODO: probably it would be better to have no dependencies on <algorithm>.
      71             : template<typename T, typename S>
      72         450 : inline void SwapEndianness( T&& object, S size )
      73             : {
      74         450 :     std::reverse( reinterpret_cast<char*>(&object),
      75             :                   reinterpret_cast<char*>(&object) + size );
      76         450 : }
      77             : 
      78             : #ifdef CAD_MSB
      79             : template<typename T>
      80             : inline void FromLSB( T&& object )
      81             : {
      82             :     SwapEndianness(object, sizeof(T));
      83             : }
      84             : #else
      85             : template<typename T>
      86        1186 : inline void FromLSB( T&& )
      87             : {
      88        1186 : }
      89             : #endif
      90             : 
      91             : /*
      92             :  * Method taken from here: http://stackoverflow.com/a/2611850
      93             :  * Purpose: no C++14 dependencies in library
      94             :  */
      95             : template< unsigned long N >
      96             : struct bin
      97             : {
      98             :     enum
      99             :     {
     100             :         value = ( N % 8 ) + ( bin< N / 8 >::value << 1 )
     101             :     };
     102             : };
     103             : 
     104             : template<>
     105             : struct bin< 0 >
     106             : {
     107             :     enum
     108             :     {
     109             :         value = 0
     110             :     };
     111             : };
     112             : #define binary( n ) bin<0##n>::value
     113             : 
     114             : extern const int DWGCRC8Table[256];
     115             : 
     116             : unsigned short CalculateCRC8(unsigned short initialVal, const char *ptr, int num );
     117             : 
     118             : class CADBuffer
     119             : {
     120             : public:
     121             :     enum SeekPosition {
     122             :         BEG = 1,
     123             :         CURRENT,
     124             :         END
     125             :     };
     126             : 
     127             : public:
     128             :     explicit CADBuffer(size_t size);
     129             :     ~CADBuffer();
     130             : 
     131             :     // Disable copy
     132             :     CADBuffer(const CADBuffer&) = delete;
     133             :     CADBuffer& operator=(const CADBuffer&) = delete;
     134             : 
     135             :     void WriteRAW(const void* data, size_t size);
     136         679 :     void* GetRawBuffer() const { return m_pBuffer + m_nBitOffsetFromStart / 8; }
     137             :     unsigned char Read2B();
     138             :     unsigned char Read3B();
     139             :     unsigned char Read4B();
     140             : 
     141             :     double ReadBITDOUBLE();
     142             :     void SkipBITDOUBLE();
     143             : 
     144             :     int ReadRAWLONG();
     145             :     short ReadRAWSHORT();
     146             :     double ReadRAWDOUBLE();
     147             :     CADHandle ReadHANDLE();
     148             :     CADHandle ReadHANDLE8BLENGTH();
     149             :     void SkipHANDLE();
     150             :     bool ReadBIT();
     151             :     void SkipBIT();
     152             :     unsigned char ReadCHAR();
     153             :     short ReadBITSHORT();
     154             :     int ReadBITLONG();
     155             :     double ReadBITDOUBLEWD(double defaultvalue);
     156             :     long ReadMCHAR();
     157             :     long ReadUMCHAR();
     158             :     unsigned int ReadMSHORT();
     159             :     std::string ReadTV();
     160             :     void SkipTV();
     161             :     void SkipBITLONG();
     162             :     void SkipBITSHORT();
     163             :     CADVector ReadVector();
     164             :     CADVector ReadRAWVector();
     165             : 
     166             :     void Seek(size_t offset, enum SeekPosition position = SeekPosition::CURRENT);
     167        2167 :     size_t PositionBit() const { return m_nBitOffsetFromStart; }
     168        3427 :     bool IsEOB() const { return m_bEOB; }
     169             : 
     170             : private:
     171             :     char* m_pBuffer;
     172             :     size_t m_nBitOffsetFromStart;
     173             :     size_t m_nSize;
     174             :     bool m_bEOB = false;
     175             : };
     176             : 
     177             : // long ReadRAWLONGLONG( const char * pabyInput, size_t& nBitOffsetFromStart);
     178             : 
     179             : 
     180             : #endif // DWG_IO_H