pupyC3D.decoder

  1# pupyC3D (c) by Antoine MARIN antoine.marin@univ-rennes2.fr
  2#
  3# pupyC3D is licensed under a
  4# Creative Commons Attribution-NonCommercial 4.0 International License.
  5#
  6# You should have received a copy of the license along with this
  7# work. If not, see <https://creativecommons.org/licenses/by-nc/4.0/>.
  8
  9import struct as _struct
 10
 11# Processor type constants for C3D file format
 12PROCESSOR_INTEL = 84
 13PROCESSOR_DEC = 85
 14PROCESSOR_MIPS = 86
 15
 16
 17class ProcStream(object):
 18    """Binary stream processor for reading and writing C3D data.
 19    
 20    Provides methods for reading/writing various data types from/to
 21    binary streams with proper byte ordering and encoding.
 22    
 23    Attributes:
 24        handle: File handle for binary I/O operations
 25    """
 26
 27    def __init__(self, handle):
 28        """Initialize stream processor.
 29        
 30        Args:
 31            handle: Binary file handle (opened in 'rb' or 'wb' mode)
 32        """
 33        self.handle = handle
 34
 35    def close_handle(self):
 36        """Close the file handle."""
 37        self.handle.close()
 38
 39    def get_int8(self):
 40        """Read signed 8-bit integer.
 41        
 42        Returns:
 43            int: Signed 8-bit integer value
 44        """
 45        return _struct.unpack('b', self.handle.read(1))[0]
 46
 47    def get_uint8(self):
 48        """Read unsigned 8-bit integer.
 49        
 50        Returns:
 51            int: Unsigned 8-bit integer value
 52        """
 53        return _struct.unpack('B', self.handle.read(1))[0]
 54
 55    def get_int16(self):
 56        return _struct.unpack('h', self.handle.read(2))[0]
 57
 58    def get_uint16(self):
 59        return _struct.unpack('H', self.handle.read(2))[0]
 60
 61    def get_int32(self):
 62        return _struct.unpack('i', self.handle.read(4))[0]
 63
 64    def get_uint32(self):
 65        return _struct.unpack('I', self.handle.read(4))[0]
 66
 67    def get_float(self):
 68        """Read 32-bit floating point value.
 69        
 70        Returns:
 71            float: 32-bit float value
 72        """
 73        return _struct.unpack('f', self.handle.read(4))[0]
 74
 75    def get_string(self, numChar):
 76        """Read string of specified length.
 77        
 78        Args:
 79            numChar (int): Number of characters to read
 80            
 81        Returns:
 82            str: Decoded string using latin1 encoding
 83        """
 84        return self.handle.read(numChar).decode('latin1')
 85
 86    def write_int8(self, data):
 87        val = _struct.pack('b', data)
 88        self.handle.write(val)
 89
 90    def write_uint8(self, data):
 91        val = _struct.pack('B', data)
 92        self.handle.write(val)
 93
 94    def write_uint16(self, data):
 95        val = _struct.pack('H', data)
 96        self.handle.write(val)
 97
 98    def write_float(self, data):
 99        val = _struct.pack('f', data)
100        self.handle.write(val)
101
102    def write_string(self, data):
103        """Write string to binary stream.
104        
105        Args:
106            data (str): String to write, encoded as ASCII
107        """
108        self.handle.write(data.encode('ascii'))
109
110
111class DecoderIntel(ProcStream):
112    """Intel processor-specific decoder for C3D files.
113    
114    Uses little-endian byte ordering (Intel/x86 format).
115    """
116
117    def __init__(self, handle):
118        """Initialize Intel decoder.
119        
120        Args:
121            handle: Binary file handle
122        """
123        super(DecoderIntel, self).__init__(handle)
124
125
126class DecoderDec(ProcStream):
127    """DEC processor-specific decoder for C3D files.
128    
129    Uses DEC-specific floating point format with special handling.
130    """
131
132    def __init__(self, handle):
133        """Initialize DEC decoder.
134        
135        Args:
136            handle: Binary file handle
137        """
138        super(DecoderDec, self).__init__(handle)
139
140    def get_float(self):
141        """Read DEC-format floating point value.
142        
143        DEC format requires byte swapping and scaling by 1/4.
144        
145        Returns:
146            float: Converted DEC float value
147        """
148        tmp = self.handle.read(4)
149        tmp = tmp[2:] + tmp[:2]
150        val = _struct.unpack('f', tmp)[0]
151        return val/4.
152
153
154class DecoderMips(ProcStream):
155    """MIPS processor-specific decoder for C3D files.
156    
157    Uses big-endian byte ordering (MIPS format).
158    """
159
160    def __init__(self, handle):
161        """Initialize MIPS decoder.
162        
163        Args:
164            handle: Binary file handle
165        """
166        super(DecoderMips, self).__init__(handle)
167
168    def get_int8(self):
169        """Read signed 8-bit integer with big-endian byte order.
170        
171        Returns:
172            int: Signed 8-bit integer value
173        """
174        return _struct.unpack('>b', self.handle.read(1))[0]
175
176    def get_uint8(self):
177        return _struct.unpack('>B', self.handle.read(1))[0]
178
179    def get_uint16(self):
180        return _struct.unpack('>H', self.handle.read(2))[0]
181
182    def get_float(self):
183        """Read 32-bit float with big-endian byte order.
184        
185        Returns:
186            float: 32-bit float value
187        """
188        return _struct.unpack('>f', self.handle.read(4))[0]