usb_power_delivery: Whitespace/consistency cosmetics.
[libsigrokdecode.git] / decoders / usb_power_delivery / pd.py
1 ##
2 ## This file is part of the libsigrokdecode project.
3 ##
4 ## Copyright (C) 2015 Google, Inc
5 ## Copyright (C) 2018 davidanger <davidanger@163.com>
6 ## Copyright (C) 2018 Peter Hazenberg <sigrok@haas-en-berg.nl>
7 ##
8 ## This program is free software; you can redistribute it and/or modify
9 ## it under the terms of the GNU General Public License as published by
10 ## the Free Software Foundation; either version 2 of the License, or
11 ## (at your option) any later version.
12 ##
13 ## This program is distributed in the hope that it will be useful,
14 ## but WITHOUT ANY WARRANTY; without even the implied warranty of
15 ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16 ## GNU General Public License for more details.
17 ##
18 ## You should have received a copy of the GNU General Public License
19 ## along with this program; if not, see <http://www.gnu.org/licenses/>.
20 ##
21
22 import sigrokdecode as srd
23 import struct
24 import zlib   # for crc32
25
26 # BMC encoding with a 600kHz datarate
27 UI_US = 1000000/600000.0
28
29 # Threshold to discriminate half-1 from 0 in Binary Mark Conding
30 THRESHOLD_US = (UI_US + 2 * UI_US) / 2
31
32 # Control Message type
33 CTRL_TYPES = {
34     0: 'reserved',
35     1: 'GOOD CRC',
36     2: 'GOTO MIN',
37     3: 'ACCEPT',
38     4: 'REJECT',
39     5: 'PING',
40     6: 'PS RDY',
41     7: 'GET SOURCE CAP',
42     8: 'GET SINK CAP',
43     9: 'DR SWAP',
44     10: 'PR SWAP',
45     11: 'VCONN SWAP',
46     12: 'WAIT',
47     13: 'SOFT RESET',
48     14: 'reserved',
49     15: 'reserved',
50     16: 'Not Supported',
51     17: 'Get_Source_Cap_Extended',
52     18: 'Get_Status',
53     19: 'FR_Swap',
54     20: 'Get_PPS_Status',
55     21: 'Get_Country_Codes',
56 }
57
58 # Data message type
59 DATA_TYPES = {
60     1: 'SOURCE CAP',
61     2: 'REQUEST',
62     3: 'BIST',
63     4: 'SINK CAP',
64     5: 'Battery_Status',
65     6: 'Alert',
66     7: 'Get_Country_Info',
67     15: 'VDM'
68 }
69
70 # 4b5b encoding of the symbols
71 DEC4B5B = [
72     0x10,   # Error      00000
73     0x10,   # Error      00001
74     0x10,   # Error      00010
75     0x10,   # Error      00011
76     0x10,   # Error      00100
77     0x10,   # Error      00101
78     0x13,   # Sync-3     00110
79     0x14,   # RST-1      00111
80     0x10,   # Error      01000
81     0x01,   # 1 = 0001   01001
82     0x04,   # 4 = 0100   01010
83     0x05,   # 5 = 0101   01011
84     0x10,   # Error      01100
85     0x16,   # EOP        01101
86     0x06,   # 6 = 0110   01110
87     0x07,   # 7 = 0111   01111
88     0x10,   # Error      10000
89     0x12,   # Sync-2     10001
90     0x08,   # 8 = 1000   10010
91     0x09,   # 9 = 1001   10011
92     0x02,   # 2 = 0010   10100
93     0x03,   # 3 = 0011   10101
94     0x0A,   # A = 1010   10110
95     0x0B,   # B = 1011   10111
96     0x11,   # Sync-1     11000
97     0x15,   # RST-2      11001
98     0x0C,   # C = 1100   11010
99     0x0D,   # D = 1101   11011
100     0x0E,   # E = 1110   11100
101     0x0F,   # F = 1111   11101
102     0x00,   # 0 = 0000   11110
103     0x10,   # Error      11111
104 ]
105 SYM_ERR = 0x10
106 SYNC1 = 0x11
107 SYNC2 = 0x12
108 SYNC3 = 0x13
109 RST1 = 0x14
110 RST2 = 0x15
111 EOP = 0x16
112 SYNC_CODES = [SYNC1, SYNC2, SYNC3]
113 HRST_CODES = [RST1, RST1, RST1, RST2]
114
115 SOP_SEQUENCES = [
116     (SYNC1, SYNC1, SYNC1, SYNC2),
117     (SYNC1, SYNC1, SYNC3, SYNC3),
118     (SYNC1, SYNC3, SYNC1, SYNC3),
119     (SYNC1, RST2,  RST2,  SYNC3),
120     (SYNC1, RST2,  SYNC3, SYNC2),
121     (RST1,  SYNC1, RST1,  SYNC3),
122     (RST1,  RST1,  RST1,   RST2),
123 ]
124 START_OF_PACKETS = {
125     SOP_SEQUENCES[0]: 'SOP',
126     SOP_SEQUENCES[1]: "SOP'",
127     SOP_SEQUENCES[2]: 'SOP"',
128     SOP_SEQUENCES[3]: "SOP' Debug",
129     SOP_SEQUENCES[4]: 'SOP" Debug',
130     SOP_SEQUENCES[5]: 'Cable Reset',
131     SOP_SEQUENCES[6]: 'Hard Reset',
132 }
133
134 SYM_NAME = [
135     ['0x0', '0'],
136     ['0x1', '1'],
137     ['0x2', '2'],
138     ['0x3', '3'],
139     ['0x4', '4'],
140     ['0x5', '5'],
141     ['0x6', '6'],
142     ['0x7', '7'],
143     ['0x8', '8'],
144     ['0x9', '9'],
145     ['0xA', 'A'],
146     ['0xB', 'B'],
147     ['0xC', 'C'],
148     ['0xD', 'D'],
149     ['0xE', 'E'],
150     ['0xF', 'F'],
151     ['ERROR', 'X'],
152     ['SYNC-1', 'S1'],
153     ['SYNC-2', 'S2'],
154     ['SYNC-3', 'S3'],
155     ['RST-1', 'R1'],
156     ['RST-2', 'R2'],
157     ['EOP', '#'],
158 ]
159
160 RDO_FLAGS = {
161     (1 << 23): 'unchunked',
162     (1 << 24): 'no_suspend',
163     (1 << 25): 'comm_cap',
164     (1 << 26): 'cap_mismatch',
165     (1 << 27): 'give_back'
166 }
167
168 BIST_MODES = {
169         0: 'Receiver',
170         1: 'Transmit',
171         2: 'Counters',
172         3: 'Carrier 0',
173         4: 'Carrier 1',
174         5: 'Carrier 2',
175         6: 'Carrier 3',
176         7: 'Eye',
177 }
178
179 VDM_CMDS = {
180         1: 'Disc Ident',
181         2: 'Disc SVID',
182         3: 'Disc Mode',
183         4: 'Enter Mode',
184         5: 'Exit Mode',
185         6: 'Attention',
186         # 16..31: SVID Specific Commands
187         # DisplayPort Commands
188         16: 'DP Status',
189         17: 'DP Configure',
190 }
191 VDM_ACK = ['REQ', 'ACK', 'NAK', 'BSY']
192
193
194 class SamplerateError(Exception):
195     pass
196
197 class Decoder(srd.Decoder):
198     api_version = 3
199     id = 'usb_power_delivery'
200     name = 'USB PD'
201     longname = 'USB Power Delivery'
202     desc = 'USB Power Delivery protocol.'
203     license = 'gplv2+'
204     inputs = ['logic']
205     outputs = ['usb_pd']
206     channels = (
207         {'id': 'cc1', 'name': 'CC1', 'desc': 'Configuration Channel 1'},
208     )
209     optional_channels = (
210         {'id': 'cc2', 'name': 'CC2', 'desc': 'Configuration Channel 2'},
211     )
212     options = (
213         {'id': 'fulltext', 'desc': 'Full text decoding of packets',
214          'default': 'no', 'values': ('yes', 'no')},
215     )
216     annotations = (
217         ('type', 'Packet Type'),
218         ('preamble', 'Preamble'),
219         ('sop', 'Start of Packet'),
220         ('header', 'Header'),
221         ('data', 'Data'),
222         ('crc', 'Checksum'),
223         ('eop', 'End Of Packet'),
224         ('sym', '4b5b symbols'),
225         ('warnings', 'Warnings'),
226         ('src', 'Source Message'),
227         ('snk', 'Sink Message'),
228         ('payload', 'Payload'),
229         ('text', 'Plain text'),
230     )
231     annotation_rows = (
232        ('4b5b', 'Symbols', (7,)),
233        ('phase', 'Parts', (1, 2, 3, 4, 5, 6)),
234        ('payload', 'Payload', (11,)),
235        ('type', 'Type', (0, 9, 10)),
236        ('warnings', 'Warnings', (8,)),
237        ('text', 'Full text', (12,)),
238     )
239     binary = (
240         ('raw-data', 'RAW binary data'),
241     )
242
243     stored_pdos = {}
244
245     def get_request(self, rdo):
246         pos = (rdo >> 28) & 7
247
248         op_ma = ((rdo >> 10) & 0x3ff) * 0.01
249         max_ma = (rdo & 0x3ff) * 0.01
250
251         mark = self.cap_mark[pos]
252         if mark == 3:
253             op_v = ((rdo >> 9) & 0x7ff) * 0.02
254             op_a = (rdo & 0x3f) * 0.05
255             t_settings = '%gV %gA' % (op_v, op_a)
256         elif mark == 2:
257             op_w = ((rdo >> 10) & 0x3ff) * 0.25
258             mp_w = (rdo & 0x3ff) * 0.25
259             t_settings = '%gW (operating)' % op_w
260         else:
261             op_a = ((rdo >> 10) & 0x3ff) * 0.01
262             max_a = (rdo & 0x3ff) * 0.01
263             t_settings = '%gA (operating) / %gA (max)' % (op_a, max_a)
264
265         t_flags = ''
266         for f in sorted(RDO_FLAGS.keys(), reverse = True):
267             if rdo & f:
268                 t_flags += ' [' + RDO_FLAGS[f] + ']'
269
270         if pos in self.stored_pdos.keys():
271             t_pdo = '#%d: %s' % (pos, self.stored_pdos[pos])
272         else:
273             t_pdo = '#d' % (pos)
274
275         return '(PDO %s) %s%s' % (t_pdo, t_settings, t_flags)
276
277     def get_source_sink_cap(self, pdo, idx, source):
278         t1 = (pdo >> 30) & 3
279         self.cap_mark[idx] = t1
280
281         flags = {}
282         if t1 == 0:
283             t_name = 'Fixed'
284             if source:
285                 flags = {
286                     (1 << 29): 'dual_role_power',
287                     (1 << 28): 'suspend',
288                     (1 << 27): 'unconstrained',
289                     (1 << 26): 'comm_cap',
290                     (1 << 25): 'dual_role_data',
291                     (1 << 24): 'unchunked',
292                 }
293             else: # Sink
294                 flags = {
295                     (1 << 29): 'dual_role_power',
296                     (1 << 28): 'high_capability',
297                     (1 << 27): 'unconstrained',
298                     (1 << 26): 'comm_cap',
299                     (1 << 25): 'dual_role_data',
300                     (0b01 << 23): 'fr_swap default power',
301                     (0b10 << 23): 'fr_swap 1.5 A',
302                     (0b11 << 23): 'fr_swap 3.0 A',
303                 }
304             mv = ((pdo >> 10) & 0x3ff) * 0.05
305             ma = ((pdo >>  0) & 0x3ff) * 0.01
306             p = '%gV %gA (%gW)' % (mv, ma, mv*ma)
307             self.stored_pdos[idx] = '%s %gV' % (t_name, mv)
308         elif t1 == 1:
309             t_name = 'Battery'
310             flags = {} # No flags defined for Battery PDO in PD 3.0 spec
311             minv = ((pdo >> 10) & 0x3ff) * 0.05
312             maxv = ((pdo >> 20) & 0x3ff) * 0.05
313             mw   = ((pdo >>  0) & 0x3ff) * 0.25
314             p = '%g/%gV %gW' % (minv, maxv, mw)
315             self.stored_pdos[idx] = '%s %g/%gV' % (t_name, minv, maxv)
316         elif t1 == 2:
317             t_name = 'Variable'
318             flags = {} # No flags defined for Variable PDO in PD 3.0 spec
319             minv = ((pdo >> 10) & 0x3ff) * 0.05
320             maxv = ((pdo >> 20) & 0x3ff) * 0.05
321             ma   = ((pdo >>  0) & 0x3ff) * 0.01
322             p = '%g/%gV %gA' % (minv, maxv, ma)
323             self.stored_pdos[idx] = '%s %g/%gV' % (t_name, minv, maxv)
324         elif t1 == 3:
325             t2 = (pdo >> 28) & 3
326             if t2 == 0:
327                 t_name = 'Programmable|PPS'
328                 flags = {
329                     (1 << 29): 'power_limited',
330                 }
331                 minv = ((pdo >> 8) & 0xff) * 0.1
332                 maxv = ((pdo >> 17) & 0xff) * 0.1
333                 ma = ((pdo >> 0) & 0xff) * 0.05
334                 p = '%g/%gV %gA' % (minv, maxv, ma)
335                 if (pdo >> 27) & 0x1:
336                     p += ' [limited]'
337                 self.stored_pdos[idx] = '%s %g/%gV' % (t_name, minv, maxv)
338             else:
339                 t_name = 'Reserved APDO: '+bin(t2)
340                 p = '[raw: %s]' % (bin(pdo))
341                 self.stored_pdos[idx] = '%s %s' % (t_name, p)
342         t_flags = ''
343         for f in sorted(flags.keys(), reverse = True):
344             if pdo & f:
345                 t_flags += ' [' + flags[f] + ']'
346         return '[%s] %s%s' % (t_name, p, t_flags)
347
348     def get_vdm(self, idx, data):
349         if idx == 0: # VDM header
350             vid = data >> 16
351             struct = data & (1 << 15)
352             txt = 'VDM'
353             if struct: # Structured VDM
354                 cmd = data & 0x1f
355                 src = data & (1 << 5)
356                 ack = (data >> 6) & 3
357                 pos = (data >> 8) & 7
358                 ver = (data >> 13) & 3
359                 txt = VDM_ACK[ack] + ' '
360                 txt += VDM_CMDS[cmd] if cmd in VDM_CMDS else 'cmd?'
361                 txt += ' pos %d' % (pos) if pos else ' '
362             else: # Unstructured VDM
363                 txt = 'unstruct [%04x]' % (data & 0x7fff)
364             txt += ' SVID:%04x' % (vid)
365         else: # VDM payload
366             txt = 'VDO:%08x' % (data)
367         return txt
368
369     def get_bist(self, idx, data):
370         mode = data >> 28
371         counter = data & 0xffff
372         mode_name = BIST_MODES[mode] if mode in BIST_MODES else 'INVALID'
373         if mode == 2:
374             mode_name = 'Counter[= %d]' % (counter)
375         # TODO: Check all 0 bits are 0 / emit warnings.
376         return 'mode %s' % (mode_name) if idx == 0 else 'invalid BRO'
377
378     def putpayload(self, s0, s1, idx):
379         t = self.head_type()
380         txt = '['+str(idx+1)+'] '
381         if t == 2:
382             txt += self.get_request(self.data[idx])
383         elif t == 1 or t == 4:
384             txt += self.get_source_sink_cap(self.data[idx], idx+1, t==1)
385         elif t == 15:
386             txt += self.get_vdm(idx, self.data[idx])
387         elif t == 3:
388             txt += self.get_bist(idx, self.data[idx])
389         self.putx(s0, s1, [11, [txt, txt]])
390         self.text += ' - ' + txt
391
392     def puthead(self):
393         ann_type = 9 if self.head_power_role() else 10
394         role = 'SRC' if self.head_power_role() else 'SNK'
395         if self.head_data_role() != self.head_power_role():
396             role += '/DFP' if self.head_data_role() else '/UFP'
397         t = self.head_type()
398         if self.head_count() == 0:
399             shortm = CTRL_TYPES[t]
400         else:
401             shortm = DATA_TYPES[t] if t in DATA_TYPES else 'DAT???'
402
403         longm = '(r{:d}) {:s}[{:d}]: {:s}'.format(self.head_rev(), role, self.head_id(), shortm)
404         self.putx(0, -1, [ann_type, [longm, shortm]])
405         self.text += longm
406
407     def head_id(self):
408         return (self.head >> 9) & 7
409
410     def head_power_role(self):
411         return (self.head >> 8) & 1
412
413     def head_data_role(self):
414         return (self.head >> 5) & 1
415
416     def head_rev(self):
417         return ((self.head >> 6) & 3) + 1
418
419     def head_type(self):
420         return self.head & 0xF
421
422     def head_count(self):
423         return (self.head >> 12) & 7
424
425     def putx(self, s0, s1, data):
426         self.put(self.edges[s0], self.edges[s1], self.out_ann, data)
427
428     def putwarn(self, longm, shortm):
429         self.putx(0, -1, [8, [longm, shortm]])
430
431     def compute_crc32(self):
432         bdata = struct.pack('<H'+'I'*len(self.data), self.head & 0xffff,
433                             *tuple([d & 0xffffffff for d in self.data]))
434         return zlib.crc32(bdata)
435
436     def rec_sym(self, i, sym):
437         self.putx(i, i+5, [7, SYM_NAME[sym]])
438
439     def get_sym(self, i, rec=True):
440         v = (self.bits[i] | (self.bits[i+1] << 1) | (self.bits[i+2] << 2) |
441              (self.bits[i+3] << 3) | (self.bits[i+4] << 4))
442         sym = DEC4B5B[v]
443         if rec:
444             self.rec_sym(i, sym)
445         return sym
446
447     def get_short(self):
448         i = self.idx
449         # Check it's not a truncated packet.
450         if len(self.bits) - i <= 20:
451             self.putwarn('Truncated', '!')
452             return 0x0BAD
453         k = [self.get_sym(i), self.get_sym(i+5),
454              self.get_sym(i+10), self.get_sym(i+15)]
455         # TODO: Check bad symbols.
456         val = k[0] | (k[1] << 4) | (k[2] << 8) | (k[3] << 12)
457         self.idx += 20
458         return val
459
460     def get_word(self):
461         lo = self.get_short()
462         hi = self.get_short()
463         return lo | (hi << 16)
464
465     def find_corrupted_sop(self, k):
466         # Start of packet are valid even if they have only 3 correct symbols
467         # out of 4.
468         for seq in SOP_SEQUENCES:
469             if [k[i] == seq[i] for i in range(len(k))].count(True) >= 3:
470                 return START_OF_PACKETS[seq]
471         return None
472
473     def scan_eop(self):
474         for i in range(len(self.bits) - 19):
475             k = (self.get_sym(i, rec=False), self.get_sym(i+5, rec=False),
476                  self.get_sym(i+10, rec=False), self.get_sym(i+15, rec=False))
477             sym = START_OF_PACKETS.get(k, None)
478             if not sym:
479                 sym = self.find_corrupted_sop(k)
480             # We have an interesting symbol sequence.
481             if sym:
482                 # Annotate the preamble.
483                 self.putx(0, i, [1, ['Preamble', '...']])
484                 # Annotate each symbol.
485                 self.rec_sym(i, k[0])
486                 self.rec_sym(i+5, k[1])
487                 self.rec_sym(i+10, k[2])
488                 self.rec_sym(i+15, k[3])
489                 if sym == 'Hard Reset':
490                     self.text += 'HRST'
491                     return -1 # Hard reset
492                 elif sym == 'Cable Reset':
493                     self.text += 'CRST'
494                     return -1 # Cable reset
495                 else:
496                     self.putx(i, i+20, [2, [sym, 'S']])
497                 return i+20
498         self.putx(0, len(self.bits), [1, ['Junk???', 'XXX']])
499         self.text += 'Junk???'
500         self.putwarn('No start of packet found', 'XXX')
501         return -1 # No Start Of Packet
502
503     def __init__(self):
504         self.reset()
505
506     def reset(self):
507         self.samplerate = None
508         self.idx = 0
509         self.packet_seq = 0
510         self.previous = 0
511         self.startsample = None
512         self.bits = []
513         self.edges = []
514         self.bad = []
515         self.half_one = False
516         self.start_one = 0
517         self.stored_pdos = {}
518         self.cap_mark = [0, 0, 0, 0, 0, 0, 0, 0]
519
520     def metadata(self, key, value):
521         if key == srd.SRD_CONF_SAMPLERATE:
522             self.samplerate = value
523             # 0 is 2 UI, space larger than 1.5x 0 is definitely wrong.
524             self.maxbit = self.us2samples(3 * UI_US)
525             # Duration threshold between half 1 and 0.
526             self.threshold = self.us2samples(THRESHOLD_US)
527
528     def start(self):
529         self.out_ann = self.register(srd.OUTPUT_ANN)
530         self.out_binary = self.register(srd.OUTPUT_BINARY)
531         self.out_bitrate = self.register(
532             srd.OUTPUT_META,
533             meta=(int, 'Bitrate', 'Bitrate during the packet')
534         )
535
536     def us2samples(self, us):
537         return int(us * self.samplerate / 1000000)
538
539     def decode_packet(self):
540         self.data = []
541         self.idx = 0
542         self.text = ''
543
544         if len(self.edges) < 50:
545             return # Not a real PD packet
546
547         self.packet_seq += 1
548         tstamp = float(self.startsample) / self.samplerate
549         self.text += '#%-4d (%8.6fms): ' % (self.packet_seq, tstamp*1000)
550
551         self.idx = self.scan_eop()
552         if self.idx < 0:
553             # Full text trace of the issue.
554             self.putx(0, self.idx, [12, [self.text, '...']])
555             return # No real packet: ABORT.
556
557         # Packet header
558         self.head = self.get_short()
559         self.putx(self.idx-20, self.idx, [3, ['H:%04x' % (self.head), 'HD']])
560         self.puthead()
561
562         # Decode data payload
563         for i in range(self.head_count()):
564             self.data.append(self.get_word())
565             self.putx(self.idx-40, self.idx,
566                       [4, ['[%d]%08x' % (i, self.data[i]), 'D%d' % (i)]])
567             self.putpayload(self.idx-40, self.idx, i)
568
569         # CRC check
570         self.crc = self.get_word()
571         ccrc = self.compute_crc32()
572         if self.crc != ccrc:
573             self.putwarn('Bad CRC %08x != %08x' % (self.crc, ccrc), 'CRC!')
574         self.putx(self.idx-40, self.idx, [5, ['CRC:%08x' % (self.crc), 'CRC']])
575
576         # End of Packet
577         if len(self.bits) >= self.idx + 5 and self.get_sym(self.idx) == EOP:
578             self.putx(self.idx, self.idx + 5, [6, ['EOP', 'E']])
579             self.idx += 5
580         else:
581             self.putwarn('No EOP', 'EOP!')
582         # Full text trace
583         if self.options['fulltext'] == 'yes':
584             self.putx(0, self.idx, [12, [self.text, '...']])
585
586         # Meta data for bitrate
587         ss, es = self.edges[0], self.edges[-1]
588         bitrate = self.samplerate*len(self.bits) / float(es - ss)
589         self.put(es, ss, self.out_bitrate, int(bitrate))
590         # Raw binary data (BMC decoded)
591         self.put(es, ss, self.out_binary, [0, bytes(self.bits)])
592
593     def decode(self):
594         if not self.samplerate:
595             raise SamplerateError('Cannot decode without samplerate.')
596         while True:
597             pins = self.wait([{0: 'e'}, {1: 'e'}, {'skip': int(self.samplerate/1e3)}])
598
599             # First sample of the packet, just record the start date.
600             if not self.startsample:
601                 self.startsample = self.samplenum
602                 self.previous = self.samplenum
603                 continue
604
605             diff = self.samplenum - self.previous
606
607             # Large idle: use it as the end of packet.
608             if diff > self.maxbit:
609                 # The last edge of the packet.
610                 self.edges.append(self.previous)
611                 # Export the packet.
612                 self.decode_packet()
613                 # Reset for next packet.
614                 self.startsample = self.samplenum
615                 self.bits = []
616                 self.edges = []
617                 self.bad = []
618                 self.half_one = False
619                 self.start_one = 0
620             else: # Add the bit to the packet.
621                 is_zero = diff > self.threshold
622                 if is_zero and not self.half_one:
623                     self.bits.append(0)
624                     self.edges.append(self.previous)
625                 elif not is_zero and self.half_one:
626                     self.bits.append(1)
627                     self.edges.append(self.start_one)
628                     self.half_one = False
629                 elif not is_zero and not self.half_one:
630                     self.half_one = True
631                     self.start_one = self.previous
632                 else: # Invalid BMC sequence
633                     self.bad.append((self.start_one, self.previous))
634                     # TODO: Try to recover.
635                     self.bits.append(0)
636                     self.edges.append(self.previous)
637                     self.half_one = False
638             self.previous = self.samplenum