cine-handler 0.1.1__py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -0,0 +1,91 @@
1
+ """Frame payload decoding helpers for Phantom CINE data."""
2
+
3
+ from __future__ import annotations
4
+
5
+ import numpy as np
6
+
7
+
8
+ def decode_frame_payload(
9
+ raw: bytes,
10
+ *,
11
+ bit_count: int,
12
+ width: int,
13
+ height_signed: int,
14
+ real_bpp: int,
15
+ unpack_10bit_fn,
16
+ ) -> np.ndarray:
17
+ """Decode one frame payload to a NumPy array.
18
+
19
+ Parameters
20
+ ----------
21
+ raw:
22
+ Raw frame payload bytes (annotation block excluded).
23
+ bit_count:
24
+ Container bit depth from bitmap header (`biBitCount`).
25
+ width:
26
+ Image width.
27
+ height_signed:
28
+ Signed image height from bitmap header. Negative means top-down storage.
29
+ real_bpp:
30
+ Sensor bit depth from setup block (`RealBPP`).
31
+ unpack_10bit_fn:
32
+ Callable that decodes Phantom packed 10-bit blocks to `uint16`.
33
+
34
+ Returns
35
+ -------
36
+ numpy.ndarray
37
+ Decoded frame payload. Raw CFA color frames remain 2D sensor mosaics;
38
+ debayering is handled by `Cine`.
39
+ """
40
+ height = abs(int(height_signed))
41
+ channels = 1 if bit_count in (8, 16) else 3
42
+
43
+ if bit_count in (8, 24):
44
+ row_bytes = width * channels
45
+ row_stride = ((row_bytes + 3) // 4) * 4
46
+ buffer_u8 = np.frombuffer(raw, dtype=np.uint8)
47
+ if buffer_u8.size == height * row_stride:
48
+ rows = buffer_u8.reshape(height, row_stride)[:, :row_bytes]
49
+ elif buffer_u8.size == height * row_bytes:
50
+ rows = buffer_u8.reshape(height, row_bytes)
51
+ else:
52
+ raise ValueError(
53
+ f"8/24-bit size mismatch: got {buffer_u8.size}, expected "
54
+ f"{height * row_bytes} or {height * row_stride}"
55
+ )
56
+ if channels == 1:
57
+ return rows.reshape(height, width).copy()
58
+ return rows.reshape(height, width, channels).copy()
59
+
60
+ if bit_count not in (16, 48):
61
+ raise ValueError(f"Unsupported bit depth: {bit_count}")
62
+
63
+ if int(real_bpp) == 10:
64
+ unpacked = unpack_10bit_fn(raw)
65
+ expected = height * width * channels
66
+ if unpacked.size < expected:
67
+ raise ValueError(
68
+ f"Packed 10-bit decode returned {unpacked.size} samples, expected at least {expected}"
69
+ )
70
+ unpacked = unpacked[:expected]
71
+ if channels == 1:
72
+ return unpacked.reshape(height, width)
73
+ return unpacked.reshape(height, width, channels)
74
+
75
+ row_bytes = width * channels * 2
76
+ row_stride = ((row_bytes + 3) // 4) * 4
77
+ buffer_u8 = np.frombuffer(raw, dtype=np.uint8)
78
+ if buffer_u8.size == height * row_stride:
79
+ rows_u8 = buffer_u8.reshape(height, row_stride)[:, :row_bytes]
80
+ elif buffer_u8.size == height * row_bytes:
81
+ rows_u8 = buffer_u8.reshape(height, row_bytes)
82
+ else:
83
+ raise ValueError(
84
+ f"16/48-bit size mismatch: got {buffer_u8.size}, expected "
85
+ f"{height * row_bytes} or {height * row_stride}"
86
+ )
87
+ rows_u8 = np.ascontiguousarray(rows_u8)
88
+ values = rows_u8.view("<u2")
89
+ if channels == 1:
90
+ return values.reshape(height, width)
91
+ return values.reshape(height, width, channels)
cine_reader/headers.py ADDED
@@ -0,0 +1,452 @@
1
+ """Header/setup dataclasses and binary parsing helpers for Phantom CINE files."""
2
+
3
+ from __future__ import annotations
4
+
5
+ import struct
6
+ from dataclasses import dataclass, field
7
+ from typing import Any, BinaryIO
8
+
9
+ import numpy as np
10
+
11
+
12
+ def _decode_text(raw: bytes) -> str:
13
+ """Decode NUL-terminated text from setup/header payload bytes."""
14
+ return raw.split(b"\x00", 1)[0].decode("utf-8", errors="ignore").strip()
15
+
16
+
17
+ def _f32(data: bytes, start: int) -> float:
18
+ return struct.unpack("<f", data[start:start + 4])[0]
19
+
20
+
21
+ def _f64(data: bytes, start: int) -> float:
22
+ return struct.unpack("<d", data[start:start + 8])[0]
23
+
24
+
25
+ @dataclass
26
+ class CineHeader:
27
+ """CINE file header (44 bytes at file start)."""
28
+
29
+ FileHeaderData: bytes # Raw 44-byte header block.
30
+ Type: bytes # File signature (e.g., b"CI").
31
+ Headersize: int # Header size in bytes.
32
+ Compression: int # Compression identifier.
33
+ Version: int # Offset table version (0=32-bit, 1=64-bit).
34
+ FirstMovieImage: int # First movie image index.
35
+ TotalImageCount: int # Total images in movie.
36
+ FirstImageNo: int # Global frame number of first stored image.
37
+ ImageCount: int # Number of stored images in this cine.
38
+ OffImageHeader: int # Byte offset to BITMAPINFOHEADER.
39
+ OffSetup: int # Byte offset to setup block.
40
+ OffImageOffsets: int # Byte offset to image-offset table.
41
+ TriggerTime: int # 64-bit trigger timestamp token from header.
42
+
43
+ @property
44
+ def first_frame_number(self) -> int:
45
+ """Alias for `FirstImageNo`."""
46
+ return int(self.FirstImageNo)
47
+
48
+ @property
49
+ def total_frames(self) -> int:
50
+ """Alias for `ImageCount`."""
51
+ return int(self.ImageCount)
52
+
53
+ @property
54
+ def last_frame_number(self) -> int:
55
+ """Derived last frame number (`FirstImageNo + ImageCount - 1`)."""
56
+ return int(self.FirstImageNo) + int(self.ImageCount) - 1
57
+
58
+
59
+ @dataclass
60
+ class BitmapHeader:
61
+ """Bitmap (DIB) image header block."""
62
+
63
+ ImageHeaderData: bytes # Raw 40-byte bitmap header payload.
64
+ biSize: int # DIB header size.
65
+ biWidth: int # Image width in pixels.
66
+ biHeight: int # Signed image height (negative means top-down).
67
+ biPlanes: int # Number of color planes.
68
+ biBitCount: int # Container bit depth (8/16/24/48 expected).
69
+ biCompression: int # Compression mode code.
70
+ biSizeImage: int # Declared image byte count.
71
+ biXPelsPerMeter: int # Horizontal pixels-per-meter.
72
+ biYPelsPerMeter: int # Vertical pixels-per-meter.
73
+ biClrUsed: int # Color table entries in use.
74
+ biClrImportant: int # Number of important colors.
75
+
76
+ @property
77
+ def width(self) -> int:
78
+ """Alias for `biWidth`."""
79
+ return int(self.biWidth)
80
+
81
+ @property
82
+ def height(self) -> int:
83
+ """Absolute image height in pixels."""
84
+ return abs(int(self.biHeight))
85
+
86
+ @property
87
+ def bit_count(self) -> int:
88
+ """Alias for `biBitCount`."""
89
+ return int(self.biBitCount)
90
+
91
+
92
+ @dataclass
93
+ class ImageOffsets:
94
+ """Frame offset table (plus file-size sentinel)."""
95
+
96
+ pImageData: bytes # Raw bytes of offsets table.
97
+ pImage: np.ndarray # `uint64` offsets array with N+1 entries.
98
+
99
+ @property
100
+ def image_offsets(self) -> np.ndarray:
101
+ """Alias for `pImage`."""
102
+ return self.pImage
103
+
104
+
105
+ @dataclass
106
+ class Setup:
107
+ """Camera setup block.
108
+
109
+ This dataclass keeps frequently used setup values as explicit fields and
110
+ also exposes parsed setup keys as dynamic attributes for compatibility.
111
+ """
112
+
113
+ SetupData: bytes # Raw setup block bytes (`OffSetup .. OffImageOffsets`).
114
+ Length: int = 0 # Setup block length field.
115
+ FrameRate: int = 0 # Integer frame rate from setup block.
116
+ dFrameRate: float = 0.0 # Floating-point frame rate when available.
117
+ Shutter: int = 0 # Legacy shutter/exposure token.
118
+ ShutterNs: int = 0 # Exposure time in nanoseconds.
119
+ RecordingTimeZone: int = 0 # Time-zone offset token from setup block.
120
+ RealBPP: int = 0 # Sensor bit depth (e.g., 10/12/14).
121
+ bEnableColor: bool = False # Color enable flag.
122
+ Description: str = "" # User description text.
123
+ LensDescription: str = "" # Lens description text.
124
+ CineName: str = "" # Cine clip name.
125
+ CreatedBy: str = "" # Creator/user text.
126
+ _extra: dict[str, Any] = field(default_factory=dict, repr=False)
127
+
128
+ def __post_init__(self) -> None:
129
+ for key, value in self._extra.items():
130
+ setattr(self, key, value)
131
+
132
+ @property
133
+ def frame_rate_hz(self) -> float:
134
+ """Best available frame rate in Hz (`dFrameRate` preferred)."""
135
+ if float(self.dFrameRate) > 0.0:
136
+ return float(self.dFrameRate)
137
+ return float(self.FrameRate)
138
+
139
+ @property
140
+ def exposure_time_ns(self) -> int:
141
+ """Best available exposure time in nanoseconds."""
142
+ if int(self.ShutterNs) > 0:
143
+ return int(self.ShutterNs)
144
+ return int(self.Shutter)
145
+
146
+ @property
147
+ def exposure_time_seconds(self) -> float:
148
+ """Best available exposure time in seconds."""
149
+ ns = self.exposure_time_ns
150
+ return float(ns) * 1e-9 if ns > 0 else 0.0
151
+
152
+
153
+ def read_cine_header(file_obj: BinaryIO) -> CineHeader:
154
+ """Read and parse the fixed-size CINE file header."""
155
+ file_obj.seek(0, 0)
156
+ raw = file_obj.read(44)
157
+ return CineHeader(
158
+ FileHeaderData=raw,
159
+ Type=raw[0:2],
160
+ Headersize=int.from_bytes(raw[2:4], "little", signed=False),
161
+ Compression=int.from_bytes(raw[4:6], "little", signed=False),
162
+ Version=int.from_bytes(raw[6:8], "little", signed=False),
163
+ FirstMovieImage=int.from_bytes(raw[8:12], "little", signed=True),
164
+ TotalImageCount=int.from_bytes(raw[12:16], "little", signed=False),
165
+ FirstImageNo=int.from_bytes(raw[16:20], "little", signed=True),
166
+ ImageCount=int.from_bytes(raw[20:24], "little", signed=False),
167
+ OffImageHeader=int.from_bytes(raw[24:28], "little", signed=False),
168
+ OffSetup=int.from_bytes(raw[28:32], "little", signed=False),
169
+ OffImageOffsets=int.from_bytes(raw[32:36], "little", signed=False),
170
+ TriggerTime=int.from_bytes(raw[36:44], "little", signed=False),
171
+ )
172
+
173
+
174
+ def read_bitmap_header(file_obj: BinaryIO, *, off_image_header: int) -> BitmapHeader:
175
+ """Read and parse the 40-byte BITMAPINFOHEADER block."""
176
+ file_obj.seek(off_image_header, 0)
177
+ raw = file_obj.read(40)
178
+ return BitmapHeader(
179
+ ImageHeaderData=raw,
180
+ biSize=int.from_bytes(raw[0:4], "little", signed=False),
181
+ biWidth=int.from_bytes(raw[4:8], "little", signed=True),
182
+ biHeight=int.from_bytes(raw[8:12], "little", signed=True),
183
+ biPlanes=int.from_bytes(raw[12:14], "little", signed=False),
184
+ biBitCount=int.from_bytes(raw[14:16], "little", signed=False),
185
+ biCompression=int.from_bytes(raw[16:20], "little", signed=False),
186
+ biSizeImage=int.from_bytes(raw[20:24], "little", signed=False),
187
+ biXPelsPerMeter=int.from_bytes(raw[24:28], "little", signed=True),
188
+ biYPelsPerMeter=int.from_bytes(raw[28:32], "little", signed=True),
189
+ biClrUsed=int.from_bytes(raw[32:36], "little", signed=False),
190
+ biClrImportant=int.from_bytes(raw[36:40], "little", signed=False),
191
+ )
192
+
193
+
194
+ def read_image_offsets(
195
+ file_obj: BinaryIO,
196
+ *,
197
+ off_image_offsets: int,
198
+ image_count: int,
199
+ version: int,
200
+ ) -> ImageOffsets:
201
+ """Read the frame offset table and append file-size sentinel."""
202
+ file_obj.seek(off_image_offsets, 0)
203
+ if version == 0:
204
+ raw = file_obj.read(image_count * 4)
205
+ offsets = np.frombuffer(raw, dtype="<u4").astype(np.uint64, copy=False)
206
+ elif version == 1:
207
+ raw = file_obj.read(image_count * 8)
208
+ offsets = np.frombuffer(raw, dtype="<u8").astype(np.uint64, copy=False)
209
+ else:
210
+ raise ValueError(f"Invalid file version: {version}")
211
+
212
+ file_obj.seek(0, 2)
213
+ file_size = np.uint64(file_obj.tell())
214
+ offsets = np.concatenate((offsets, np.array([file_size], dtype=np.uint64)))
215
+ return ImageOffsets(pImageData=raw, pImage=offsets)
216
+
217
+
218
+ def read_setup(
219
+ file_obj: BinaryIO,
220
+ *,
221
+ off_setup: int,
222
+ off_image_offsets: int,
223
+ ) -> Setup:
224
+ """Read and parse the setup block fields used by the reader."""
225
+ file_obj.seek(off_setup, 0)
226
+ setup_data = file_obj.read(off_image_offsets - off_setup)
227
+ values: dict[str, Any] = {}
228
+
229
+ values["FrameRate16"] = int.from_bytes(setup_data[0:2], "little", signed=False)
230
+ values["Shutter16"] = int.from_bytes(setup_data[2:4], "little", signed=False)
231
+ values["PostTrigger16"] = int.from_bytes(setup_data[4:6], "little", signed=False)
232
+ values["FrameDelay16"] = int.from_bytes(setup_data[6:8], "little", signed=False)
233
+ values["AspectRatio"] = int.from_bytes(setup_data[8:10], "little", signed=False)
234
+ values["Res7"] = int.from_bytes(setup_data[10:12], "little", signed=False)
235
+ values["Res8"] = int.from_bytes(setup_data[12:14], "little", signed=False)
236
+ values["Res9"] = int.from_bytes(setup_data[14:15], "little", signed=False)
237
+ values["Res10"] = int.from_bytes(setup_data[15:16], "little", signed=False)
238
+ values["Res11"] = int.from_bytes(setup_data[16:17], "little", signed=False)
239
+ values["TrigFrame"] = int.from_bytes(setup_data[17:18], "little", signed=False)
240
+ values["Res12"] = int.from_bytes(setup_data[18:19], "little", signed=False)
241
+ values["DescriptionOld"] = setup_data[19:140]
242
+ values["Mark"] = setup_data[140:142]
243
+ values["Length"] = int.from_bytes(setup_data[142:144], "little", signed=False)
244
+ values["Res13"] = int.from_bytes(setup_data[144:146], "little", signed=False)
245
+ values["SigOption"] = int.from_bytes(setup_data[146:148], "little", signed=False)
246
+ values["BinChannels"] = int.from_bytes(setup_data[148:150], "little", signed=True)
247
+ values["SamplesPerImage"] = int.from_bytes(setup_data[150:151], "little", signed=False)
248
+ values["BinName"] = [setup_data[151 + 11 * i:162 + 11 * i] for i in range(8)]
249
+ values["AnaOption"] = int.from_bytes(setup_data[239:241], "little", signed=False)
250
+ values["AnaChannels"] = int.from_bytes(setup_data[241:243], "little", signed=True)
251
+ values["Res6"] = int.from_bytes(setup_data[243:244], "little", signed=False)
252
+ values["AnaBoard"] = int.from_bytes(setup_data[244:245], "little", signed=False)
253
+ values["ChOption"] = [
254
+ int.from_bytes(setup_data[245 + 2 * i:247 + 2 * i], "little", signed=False)
255
+ for i in range(8)
256
+ ]
257
+ values["AnaGain"] = [_f32(setup_data, 261 + 4 * i) for i in range(8)]
258
+ values["AnaUnit"] = [setup_data[293 + 6 * i:299 + 6 * i] for i in range(8)]
259
+ values["AnaName"] = [setup_data[341 + 11 * i:352 + 11 * i] for i in range(8)]
260
+ values["lFirstImage"] = int.from_bytes(setup_data[429:433], "little", signed=True)
261
+ values["dwImageCount"] = int.from_bytes(setup_data[433:437], "little", signed=False)
262
+ values["nQFactor"] = int.from_bytes(setup_data[437:439], "little", signed=True)
263
+ values["wCineFileType"] = int.from_bytes(setup_data[439:441], "little", signed=False)
264
+ values["szCinePath"] = [setup_data[441 + 65 * i:506 + 65 * i] for i in range(4)]
265
+ values["Res14"] = int.from_bytes(setup_data[701:703], "little", signed=False)
266
+ values["Res15"] = int.from_bytes(setup_data[703:704], "little", signed=False)
267
+ values["Res16"] = int.from_bytes(setup_data[704:705], "little", signed=False)
268
+ values["Res17"] = int.from_bytes(setup_data[705:707], "little", signed=False)
269
+ values["Res18"] = int.from_bytes(setup_data[707:715], "little", signed=False)
270
+ values["Res19"] = int.from_bytes(setup_data[715:723], "little", signed=False)
271
+ values["Res20"] = int.from_bytes(setup_data[723:725], "little", signed=False)
272
+ values["Res1"] = int.from_bytes(setup_data[725:729], "little", signed=False)
273
+ values["Res2"] = int.from_bytes(setup_data[729:733], "little", signed=False)
274
+ values["Res3"] = int.from_bytes(setup_data[733:737], "little", signed=False)
275
+ values["ImWidth"] = int.from_bytes(setup_data[737:739], "little", signed=False)
276
+ values["ImHeight"] = int.from_bytes(setup_data[739:741], "little", signed=False)
277
+ values["EDRShutter16"] = int.from_bytes(setup_data[741:743], "little", signed=False)
278
+ values["Serial"] = int.from_bytes(setup_data[743:747], "little", signed=False)
279
+ values["Saturation"] = int.from_bytes(setup_data[747:751], "little", signed=True)
280
+ values["Res5"] = int.from_bytes(setup_data[751:752], "little", signed=False)
281
+ values["AutoExposure"] = int.from_bytes(setup_data[752:756], "little", signed=False)
282
+ values["bFlipH"] = bool(int.from_bytes(setup_data[756:760], "little", signed=False))
283
+ values["bFlipV"] = bool(int.from_bytes(setup_data[760:764], "little", signed=False))
284
+ values["Grid"] = int.from_bytes(setup_data[764:768], "little", signed=False)
285
+ values["FrameRate"] = int.from_bytes(setup_data[768:772], "little", signed=False)
286
+ values["Shutter"] = int.from_bytes(setup_data[772:776], "little", signed=False)
287
+ values["EDRSshutter"] = int.from_bytes(setup_data[776:780], "little", signed=False)
288
+ values["PostTrigger"] = int.from_bytes(setup_data[780:784], "little", signed=False)
289
+ values["FrameDelay"] = int.from_bytes(setup_data[784:788], "little", signed=False)
290
+ values["bEnableColor"] = bool(int.from_bytes(setup_data[788:792], "little", signed=False))
291
+ values["CameraVersion"] = int.from_bytes(setup_data[792:796], "little", signed=False)
292
+ values["FirmwareVersion"] = int.from_bytes(setup_data[796:800], "little", signed=False)
293
+ values["SoftwareVersion"] = int.from_bytes(setup_data[800:804], "little", signed=False)
294
+ values["RecordingTimeZone"] = int.from_bytes(setup_data[804:808], "little", signed=True)
295
+ values["CFA"] = int.from_bytes(setup_data[808:812], "little", signed=False)
296
+ values["Bright"] = int.from_bytes(setup_data[812:816], "little", signed=True)
297
+ values["Contrast"] = int.from_bytes(setup_data[816:820], "little", signed=True)
298
+ values["Gamma"] = int.from_bytes(setup_data[820:824], "little", signed=True)
299
+ values["Res21"] = int.from_bytes(setup_data[824:828], "little", signed=False)
300
+ values["AutoExpLevel"] = int.from_bytes(setup_data[828:832], "little", signed=False)
301
+ values["AutoExpSpeed"] = int.from_bytes(setup_data[832:836], "little", signed=False)
302
+ values["AutoExpRect"] = [
303
+ [
304
+ int.from_bytes(setup_data[836 + 4 * a + 8 * b:840 + 4 * a + 8 * b], "little", signed=False)
305
+ for a in range(2)
306
+ ]
307
+ for b in range(2)
308
+ ]
309
+ values["WBGain"] = [[_f32(setup_data, 852 + 4 * b + 8 * a) for b in range(2)] for a in range(4)]
310
+ values["Rotate"] = int.from_bytes(setup_data[884:888], "little", signed=True)
311
+ values["WBView"] = [_f32(setup_data, 888 + 4 * b) for b in range(2)]
312
+ values["RealBPP"] = int.from_bytes(setup_data[896:900], "little", signed=False)
313
+ values["Conv8Min"] = int.from_bytes(setup_data[900:904], "little", signed=False)
314
+ values["Conv8Max"] = int.from_bytes(setup_data[904:908], "little", signed=False)
315
+ values["FilterCode"] = int.from_bytes(setup_data[908:912], "little", signed=True)
316
+ values["FilterParam"] = int.from_bytes(setup_data[912:916], "little", signed=True)
317
+ values["UF"] = [
318
+ int.from_bytes(setup_data[916:920], "little", signed=True),
319
+ int.from_bytes(setup_data[920:924], "little", signed=True),
320
+ int.from_bytes(setup_data[924:928], "little", signed=True),
321
+ [int.from_bytes(setup_data[928 + 4 * a:932 + 4 * a], "little", signed=True) for a in range(25)],
322
+ ]
323
+ values["BlackCalSVer"] = int.from_bytes(setup_data[1028:1032], "little", signed=False)
324
+ values["WhiteCalSVer"] = int.from_bytes(setup_data[1032:1036], "little", signed=False)
325
+ values["GrayCalSVer"] = int.from_bytes(setup_data[1036:1040], "little", signed=False)
326
+ values["bStampTime"] = bool(int.from_bytes(setup_data[1040:1044], "little", signed=False))
327
+ values["SoundDest"] = int.from_bytes(setup_data[1044:1048], "little", signed=False)
328
+ values["FRPSteps"] = int.from_bytes(setup_data[1048:1052], "little", signed=False)
329
+ values["FRPImgNr"] = [int.from_bytes(setup_data[1052 + 4 * a:1056 + 4 * a], "little", signed=True) for a in range(16)]
330
+ values["FRPRate"] = [int.from_bytes(setup_data[1116 + 4 * a:1120 + 4 * a], "little", signed=False) for a in range(16)]
331
+ values["FRPExp"] = [int.from_bytes(setup_data[1180 + 4 * a:1184 + 4 * a], "little", signed=False) for a in range(16)]
332
+ values["MCCnt"] = int.from_bytes(setup_data[1244:1248], "little", signed=True)
333
+ values["MCPercent"] = [_f32(setup_data, 1248 + 4 * a) for a in range(64)]
334
+ values["CICalib"] = int.from_bytes(setup_data[1504:1508], "little", signed=False)
335
+ values["CalibWidth"] = int.from_bytes(setup_data[1508:1512], "little", signed=False)
336
+ values["CalibHeight"] = int.from_bytes(setup_data[1512:1516], "little", signed=False)
337
+ values["CalibRate"] = int.from_bytes(setup_data[1516:1520], "little", signed=False)
338
+ values["CalibExp"] = int.from_bytes(setup_data[1520:1524], "little", signed=False)
339
+ values["CalibEDR"] = int.from_bytes(setup_data[1524:1528], "little", signed=False)
340
+ values["CalibTemp"] = int.from_bytes(setup_data[1528:1532], "little", signed=False)
341
+ values["HeadSerial"] = [int.from_bytes(setup_data[1532 + 4 * a:1536 + 4 * a], "little", signed=False) for a in range(4)]
342
+ values["RangeCode"] = int.from_bytes(setup_data[1548:1552], "little", signed=False)
343
+ values["RangeSize"] = int.from_bytes(setup_data[1552:1556], "little", signed=False)
344
+ values["Decimation"] = int.from_bytes(setup_data[1556:1560], "little", signed=False)
345
+ values["MasterSerial"] = int.from_bytes(setup_data[1560:1564], "little", signed=False)
346
+ values["Sensor"] = int.from_bytes(setup_data[1564:1568], "little", signed=False)
347
+ values["ShutterNs"] = int.from_bytes(setup_data[1568:1572], "little", signed=False)
348
+ values["EDRShutterNs"] = int.from_bytes(setup_data[1572:1576], "little", signed=False)
349
+ values["FrameDelayNs"] = int.from_bytes(setup_data[1576:1580], "little", signed=False)
350
+ values["ImPosXAcq"] = int.from_bytes(setup_data[1580:1584], "little", signed=False)
351
+ values["ImPosYAcq"] = int.from_bytes(setup_data[1584:1588], "little", signed=False)
352
+ values["ImWidthAcq"] = int.from_bytes(setup_data[1588:1592], "little", signed=False)
353
+ values["ImHeightAcq"] = int.from_bytes(setup_data[1592:1596], "little", signed=False)
354
+ values["Description"] = _decode_text(setup_data[1596:5692])
355
+ values["RisingEdge"] = bool(int.from_bytes(setup_data[5692:5696], "little", signed=False))
356
+ values["FilterTime"] = int.from_bytes(setup_data[5696:5700], "little", signed=False)
357
+ values["LongReady"] = bool(int.from_bytes(setup_data[5700:5704], "little", signed=False))
358
+ values["ShutterOff"] = bool(int.from_bytes(setup_data[5704:5708], "little", signed=False))
359
+ values["Res4"] = [int.from_bytes(setup_data[5708 + a:5709 + a], "little", signed=False) for a in range(16)]
360
+ values["bMetaWB"] = bool(int.from_bytes(setup_data[5724:5728], "little", signed=False))
361
+ values["Hue"] = int.from_bytes(setup_data[5728:5732], "little", signed=True)
362
+ values["BlackLevel"] = int.from_bytes(setup_data[5732:5736], "little", signed=True)
363
+ values["WhiteLevel"] = int.from_bytes(setup_data[5736:5740], "little", signed=True)
364
+ values["LensDescription"] = _decode_text(setup_data[5740:5996])
365
+ values["LensAperture"] = _f32(setup_data, 5996)
366
+ values["LensFocusDistance"] = _f32(setup_data, 6000)
367
+ values["LensFocalLength"] = _f32(setup_data, 6004)
368
+ values["fOffset"] = _f32(setup_data, 6008)
369
+ values["fGain"] = _f32(setup_data, 6012)
370
+ values["fSaturation"] = _f32(setup_data, 6016)
371
+ values["fHue"] = _f32(setup_data, 6020)
372
+ values["fGamma"] = _f32(setup_data, 6024)
373
+ values["fGammaR"] = _f32(setup_data, 6028)
374
+ values["fGammaB"] = _f32(setup_data, 6032)
375
+ values["fFlare"] = _f32(setup_data, 6036)
376
+ values["fPedestalR"] = _f32(setup_data, 6040)
377
+ values["fPedestalG"] = _f32(setup_data, 6044)
378
+ values["fPedestalB"] = _f32(setup_data, 6048)
379
+ values["fChroma"] = _f32(setup_data, 6052)
380
+ values["ToneLabel"] = _decode_text(setup_data[6056:6312])
381
+ values["TonePoints"] = int.from_bytes(setup_data[6312:6316], "little", signed=True)
382
+ values["fTone"] = [[_f32(setup_data, 6316 + 4 * b + 8 * a) for b in range(2)] for a in range(32)]
383
+ values["UserMatrixLabel"] = _decode_text(setup_data[6572:6828])
384
+ values["EnableMatrices"] = bool(int.from_bytes(setup_data[6828:6832], "little", signed=False))
385
+ values["cmUser"] = [_f32(setup_data, 6832 + 4 * b) for b in range(9)]
386
+ values["EnableCrop"] = bool(int.from_bytes(setup_data[6868:6872], "little", signed=False))
387
+ values["CropRect"] = [
388
+ [
389
+ int.from_bytes(setup_data[6872 + 4 * a + 8 * b:6876 + 4 * a + 8 * b], "little", signed=False)
390
+ for a in range(2)
391
+ ]
392
+ for b in range(2)
393
+ ]
394
+ values["EnableResample"] = bool(int.from_bytes(setup_data[6888:6892], "little", signed=False))
395
+ values["ResampleWidth"] = int.from_bytes(setup_data[6892:6896], "little", signed=False)
396
+ values["ResampleHeight"] = int.from_bytes(setup_data[6896:6900], "little", signed=False)
397
+ values["fGain16"] = _f32(setup_data, 6900)
398
+ values["FRPShape"] = [int.from_bytes(setup_data[6904 + 4 * a:6908 + 4 * a], "little", signed=False) for a in range(16)]
399
+ values["TrigTC"] = int.from_bytes(setup_data[6968:6976], "little", signed=False)
400
+ values["fPbRate"] = _f32(setup_data, 6976)
401
+ values["fTcRate"] = _f32(setup_data, 6980)
402
+ values["CineName"] = _decode_text(setup_data[6984:7240])
403
+ values["fGainR"] = _f32(setup_data, 7240)
404
+ values["fGainG"] = _f32(setup_data, 7244)
405
+ values["fGainB"] = _f32(setup_data, 7248)
406
+ values["cmCalib"] = [_f32(setup_data, 7252 + 4 * a) for a in range(9)]
407
+ values["fWBTemp"] = _f32(setup_data, 7288)
408
+ values["fWBCc"] = _f32(setup_data, 7292)
409
+ values["CalibrationInfo"] = _decode_text(setup_data[7296:8320])
410
+ values["OpticalFilter"] = _decode_text(setup_data[8320:9344])
411
+ values["GpsInfo"] = _decode_text(setup_data[9344:9600])
412
+ values["Uuid"] = _decode_text(setup_data[9600:9856])
413
+ values["CreatedBy"] = _decode_text(setup_data[9856:10112])
414
+ values["RecBPP"] = int.from_bytes(setup_data[10112:10116], "little", signed=False)
415
+ values["LowestFormatBPP"] = int.from_bytes(setup_data[10116:10118], "little", signed=False)
416
+ values["LowestFormatQ"] = int.from_bytes(setup_data[10118:10120], "little", signed=False)
417
+ values["fToe"] = _f32(setup_data, 10120)
418
+ values["LogMode"] = int.from_bytes(setup_data[10124:10128], "little", signed=False)
419
+ values["CameraModel"] = setup_data[10128:10384]
420
+ values["WBType"] = int.from_bytes(setup_data[10384:10388], "little", signed=False)
421
+ values["fDecimation"] = _f32(setup_data, 10388)
422
+ values["MagSerial"] = int.from_bytes(setup_data[10392:10396], "little", signed=False)
423
+ values["CSSerial"] = int.from_bytes(setup_data[10396:10400], "little", signed=False)
424
+ values["dFrameRate"] = _f64(setup_data, 10400)
425
+ values["SensorMode"] = int.from_bytes(setup_data[10408:10412], "little", signed=False)
426
+ values["UndecFirst"] = int.from_bytes(setup_data[10412:10416], "little", signed=False)
427
+ values["SupportsBinning"] = bool(int.from_bytes(setup_data[10416:10420], "little", signed=False))
428
+ values["UvSensor"] = bool(int.from_bytes(setup_data[10420:10424], "little", signed=False))
429
+ values["AnaDaqDescription"] = setup_data[10424:10552]
430
+ values["BinDaqDescription"] = setup_data[10552:10680]
431
+ values["DaqOptions"] = bool(int.from_bytes(setup_data[10680:10684], "little", signed=False))
432
+
433
+ # Legacy typo aliases kept only as secondary names.
434
+ values["LensAperature"] = values["LensAperture"]
435
+ values["EnableMatricies"] = values["EnableMatrices"]
436
+
437
+ return Setup(
438
+ SetupData=setup_data,
439
+ Length=int(values.get("Length", 0)),
440
+ FrameRate=int(values.get("FrameRate", 0)),
441
+ dFrameRate=float(values.get("dFrameRate", 0.0)),
442
+ Shutter=int(values.get("Shutter", 0)),
443
+ ShutterNs=int(values.get("ShutterNs", 0)),
444
+ RecordingTimeZone=int(values.get("RecordingTimeZone", 0)),
445
+ RealBPP=int(values.get("RealBPP", 0)),
446
+ bEnableColor=bool(values.get("bEnableColor", False)),
447
+ Description=str(values.get("Description", "")),
448
+ LensDescription=str(values.get("LensDescription", "")),
449
+ CineName=str(values.get("CineName", "")),
450
+ CreatedBy=str(values.get("CreatedBy", "")),
451
+ _extra=values,
452
+ )