graycode, morse, pwm, usb_request, wiegand: cope with absent sample rate

Improve robustness of some more protocol decoders. Few of them never
checked for the availability of a sample rate in the first place, others
checked for the presence of a spec but would not cope with a value of 0.
Some checked the value only after processing it, which could result in
runtime errors.

This change is motivated by bug #1118.

spi: cope when a sample rate of 0 was configured

The explicit test for None was not good enough. Change test conditions
such that sample rates only get processed when they got specified _and_
were not zero.

This fixes bug #1118.

ac97: introduce first AC'97 decoder implementation (bits, slots, binary)

Introduce an "audio and modem control for PC systems" protocol decoder
(referred to as AC'97).

This implementation extracts bits and identifies frames, and annotates
the slots of a frame with mere integer values. Bit fields get decoded
depending on the slot numbers. Bit patterns in audio/modem data slots
can get exported as binary streams.

Some TODO items remain. Register access (read/write) gets annotated, but
neither gets interpreted nor affects the decoding of subsequent frames.
The RESET# line status does not get evaluated.

i2c: Drop obsolete 10bit slave address TODO.

Nobody has seen any such slave in the wild, yet. In the very unlikely
case that someone actually sees or needs this, patches are welcome
though (together with sample .sr files).

counter: make 'reset' signal polarity an option

Allow configuration of the 'reset' signal polarity. Reset counters on
either falling (default) or rising edges.

counter: Make "word reset" an explicit annotation class+row.

Also, add long and short annotation string versions.

Add a trivial "counter" decoder

This decoder just counts the number of falling and/or rising edges. This
is especially useful for diagnosing protocols with a clock signal or a
fixed number of transitions per bit, e.g. pulse length coded.

It also provides a divider, which can be used to e.g. count the number
of words in I²C or SPI transfers.

parallel: implement consistent number formatting

Print all annotations for individual data bit items and for the
de-multiplexed words in a consistent style with leading zeros and
constant width. This shall lend itself better to quick navigation
during visual inspection, as well as automatic processing.

parallel: unbreak and improve "word" de-multiplexing

The previous implementation prepared but never fully enabled the
accumulation of several multi-bit items into words that span multiple
bus cycles (think: address or data de-multiplexing on memory busses).

Complete the accumulation, and fixup the end samplenumber for word
annotations. Fixup the endianess logic (the condition was inverted).
Rephrase calculation to be more Python idiomatic.

Default to word size zero, and only emit word annotations for non-zero
word size specs. This keeps the implementation backwards compatible and
still passes the test suite. Default behaviour is most appropriate for
interactive use in GUI environments, while automated processing will
find consistent behaviour across all setups (non-multiplexed busses, and
multiplexed busses with "words" that span one or multiple cycles).

parallel: cope with sparse input mappings, assume zero for not-connected pins

Cope when users only provide e.g. input lines D0 and D2 to the parallel
decoder. Assume that not-connected pins are "always zero".

Rephrase the .decode() logic which determines .wait() conditions while
we are here, to slightly unobfuscate the implementation.

This fixes bug #1088.

parallel: address minor style nits, no change in behaviour

Remove the redundant .itemcount variable, which exactly corresponds to
the length of the .items array.

Arrange retrieval of options and their evaluation closer to each other
for improved readability.

Use common logic to construct "words" from several multi-bit "items".
Arrange for endianess support by optionally reversing the array before
traversal.

parallel: unify decode() code paths with and without clock signal

Instead of implementing two main loops for operation in the presence and
in the absence of a clock line, use a common main loop which operates on
pre-determined wait conditions.

usb_power_delivery: enforce check order for start-of-packet sequences

The list of a dictionary's keys need not reproduce in identical order
everywhere. Make sure to run all start-of-packet sequence checks in the
decoder implementation in a specific order on each machine, such that
annotations get emitted with identical content and in the same order for
each execution of the decoder.

This fixes the remaining part of bug #1090.

usb_power_delivery: fixup a Python style nit (dict lookup fallback)

Use the dictionary's .get() method in combination with a default result
parameter, instead of an explicit "k in dictvar" test and a conditional
assignment.

usb_power_delivery: enforce numerical order of RDO/PDO flag annotations

Annotations of the USB power delivery decoder contain multiple text
fragments that correspond to several flags in bit fields. The Python
runtime did not guarantee an order of emission and made the test suite
fail.

Sort the order in which RDO and PDO flags related text fragments get
constructed and concatenated. Print text for higher bit positions first
as this might feel more intuitive to users.

This fixes part of bug #1090.

all decoders: introduce a reset() method

Move initialization code of protocol decoders from the constructor to a
new reset() helper method. The libsigrokdecode backend could run this
method several times to clear the decoder's internal state, before new
data from another acquisition gets fed to decode() calls.

ssi32: rename reset() helper method

The ssi32 decoder implements a reset() method which clears internally
accumulated data during decoding. Rename the method before all decoders
will grow a new reset() method that will be used for a different purpose.

mrf24j40: rename reset() helper method

The mrf24j40 decoder implements a reset() method which clears internally
accumulated data during decoding. Rename the method before all decoders
will grow a new reset() method that will be used for a different purpose.

ade77xx: rename reset() helper method

The ade77xx decoder implements a reset() method which clears internally
accumulated data during decoding. Rename the method before all decoders
will grow a new reset() method that will be used for a different purpose.

sdcard_sd: remove unused .reset() method

The decoder's .reset() method seems to partially implement constructor's
assignments, but is not referenced anywhere. There is neither a direct
call site in the remainder of pd.py which uses the "reset" name, and
runtime computation only references "handle_*()" methods for commands
and responses.

Drop the unused .reset() method in the individual decoder before the
introduction of a common .reset() method approach for all decoders.

am230x: rename reset() helper method

The am230x decoder implements a reset() method which clears internal
decoder state. Rename the method before all decoders will grow a new
reset() method that will be used for a different purpose.

eeprom 24xx: rename reset() helper method

ir_nec: Make timing margin relative

This replaces the fixed timing margin with a percentage based tolerance
to better allow for timing inaccuracies, especially for longer timings
like the Leader and Repeat codes.

graycode: Move bitpack/bitunpack to common/.

Add a gray code and rotary encoder protocol decoder.

Add a morse code protocol decoder.

i2s: Fix unportable use of struct.pack

Using the format string 'I' with the default (implied) prefix '@'
results in both word size and endianness being platform dependent.
In this case standard size (32 bits) and little endianness is
required, so the prefix '<' needs to be used.

maple_bus: Add helpers to make the call sites a bit shorter.

Add an initial Maple bus decoder.

instance.c: Removed redundant variable

configure.ac: Added AC_C_BIGENDIAN to autoconf

This is needed so that WORDS_BIGENDIAN is defined on big-endian
systems, which is needed by version.c .

i2s: Set file size to 4Gb

i2s: Make 32-bit wav files

ds243x: Add binary output for data read from EEPROM

Rename ds2432 to ds243x

ds2432: Adapt to allow for DS2433 as well

ds2432: Simplify MAC printing.

ds2432: Add a Maxim DS2432 protocol decoder.

This fixes (parts of) bug #1019.

srd_init(): Print list of decoder search paths in debug output.

Clarify and improve channel map debug output.

usb_request: Remove code duplication, save end sample in central location

usb_request: Handle CONTROL transfer protocol stalls

According to the USB 2.0 spec, 8.5.3.4, a protocol stall condition lasts
until the next SETUP transfer. On reception of the SETUP, adjust the end
sample accordingly, and flush the previous CONTROL transfer.

Fix a unit test.

Only try to acquire the GIL if the Python interpreter is actually
initialized, otherwise there'll be a segfault.

can: introduce clock synchronization (simple implementation)

Check for falling edges (i.e. changes to dominant state) between bits of
a CAN frame, and adjust subsequent bit slots' sample points accordingly.
This is a simple implementation which could get improved later. But it
improves the decoder's reliability when the input signal's rate differs
from the nominal rate.

This fixes bug #990.

Reported-By: PeterMortensen via IRC

can: rename 'bitpos' variable

Consistently use .sample_point for the member variable that corresponds
to the 'sample_point' property. Use 'samplenum' in .get_sample_point()
to reflect that the routine returns a sample number. This eliminates the
'bitpos' identifier which was used for two different things.

self.put(): Eliminate an unneeded malloc/free pair.

Acquire/release the Python GIL where needed to avoid threading issues.

With these additions, frontends can now call libsigrokdecode API
functions from different threads without running into threading issues.

The backend releases the GIL when it is performing tasks that might take
a while and it doesn't need to run Python/C API calls during that time.

This allows frontends to run multiple PD stacks (in multiple frontend
threads) "at the same time" in a time-sharing, "interlocked" manner.
Whenever one of the decoders is inside e.g. self.wait() it releases the
GIL and thus allows other decoders to do some work in the mean time.

The user-visible effect is that for use-cases such as running 3 different
decoder stacks at the same time for an acquisition, the user will not
have to wait for PD 1 to finish decoding, then wait for PD 2 to finish
decoding, and only *then* being able to see annotations from PD 3.

Instead, all three PDs will decode some chunks of data from time to
time, thus the user is able to inspect annotations from all 3 PDs while
the acquisition and decoding is still going on.

HACKING: Prefer git pull requests over mailing list patches.

Also, drop the reference to gitorious.org (no longer available).

pwm: Drop unused 'pins' variable.

ir_rc5: Rephrase open coded value for start bit 1

Make obvious that the start bit's value is 1 in the IDLE stage.

lpc: Improve robustness when decoding unexpected input data

The 'fields' table of state and descriptions is not fully populated,
some slots are missing. Cope with lookup misses when unexpected input
data is not found in the table. Use different error text in annotations
for described but invalid states (the previous implementation used
"reserved / invalid"), and for states that are not described in the
table (introduce the "reserved / unknown" text for conditions that are
not covered by the decoder implementation).

The previous implementation missed the emission of some warnings. When a
"reserved / invalid" description was found, the subsequent exact match
for "reserved" failed and the warning was not emitted. Weaken the test
to emit warnings for either description that has "reserved" in it,
regardless of whether the text was found in the table or is not part of
the table at all.

lpc: Nit, remove an unused variable

onewire_network: Fixup start samplenumber for annotations

Annotations generated by the onewire_network decoder started where bit 1
began, while it should align with the start of bit 0.

guess_bitrate: Eliminate internal state of the decoder

Getting the first edge outside of the loop in .decode() greatly
simplifies the logic, any other edge then is just an update of the
previously collected data, determined by always equal code.

i2c: Don't drop the first sample of input data

The previous implementation of the I2C decoder used to retrieve and not
process the first sample of the input stream. Remove this instruction.

decoders: Rephrase condition-less .wait() calls (self documentation)

Telling .wait() to "skip one sample" slightly obfuscates the intent of
getting the next samples while no condition applies. Explicitly pass no
condition arguments instead, to better reflect the purpose. Coincidently
these .wait() calls will execute in slightly less expensive code paths
in the common code.

decoder: Accept more forms of "unconditional wait()" (None, no args)

The Decoder.wait() method expects a list of dicts, or as a special form
a single dict, to specify the conditions to wait for. An empty dict or
an empty list mean "unconditional wait", requesting the very next sample.

Accept None as well as no arguments at all in Decoder.wait() calls. This
shall better reflect the intent and slightly unobfuscate PD code, as well
as avoid creation of potentially expensive Python objects at the call site.

decoder: Unbreak execution of Decoder.wait() with empty condition

The Decoder.wait() method works as expected when non-empty conditions
are specified by the caller. For empty conditions the implementation was
incomplete, and ended up in an infinite loop because the sample number
got stuck in the current location. Code review revealed more issues like
not getting more input data chunks when needed.

Detect when empty wait() conditions were specified, and re-use existing
code paths for match handling as much as possible. This is achieved by
the manual creation of a SKIP term with the appropriate count value.
It's assumed that naive decoder implementations will run this kind of
condition-less query for every individual sample, which means that
efficiency is important.

Make sample number 0 available to condition-less calls, too. Don't skip
the first sample in the input stream.

usb_signalling: Move another edge detection to common backend code

Rephrase how the 'WAIT IDLE' stage skips over all-low input signals.
Have the next high level on either line detected in common code.

pwm: Fixup sample numbers for binary output

Do reference the period's start and end sample numbers when the
duty cycle is written to the binary output stream. The previous
implementation inappropriately used the period counter instead.

pwm: Eliminate more decoder "state"

Move more items from the Python object's members to local variables of the
decode() method, as they are used there exclusively.

Mark a spot where the binary output references suspicious "sample numbers".

pwm: Rephrase edge and period detection, eliminate internal state

With the simplicity of PWM waveforms and the convenience of the v3 API,
there is no need to maintain internal state. After the start of the
first period was determined based on the input signal's polarity, any
period is defined by just the next two edges, and the next period is
immediately to follow.

Drop support for PD API version 2.

All decoders must be of PD API version 3 now.

Mark all stacked decoders as being PD API version 3.

This is not really relevant for stacked PDs currently (they can be used
unmodified with either PDv2 or PDv3 low-level decoders), but it'll allow
us to drop PDv2 support completely.

ir_rc5: Convert to PD API version 3.

dsi: Convert to PD API version 3.

dsi: Cosmetics, drop obsolete comments.

rgb_led_ws281x: Convert to PD API version 3.

lpc: Convert to PD API version 3.

wiegand: Convert to PD API version 3.

usb_signalling: Convert to PD API version 3.

dali: Change 'self.dali' to 'dali'.

dali: Convert to PD API version 3.

dali: Random cleanups, remove obsolete comments.

instance.c: Drop a few unneeded checks.

spi: Simplify some code chunks.

dmx512: Use a nicer 'dmx' pin name variable.

dmx512: Convert to PD API version 3.

pwm: Reduce indentation level.

pwm: Simplify waiting for initial edge.

session.c: Fix a compiler warning on Mac OS X.

  session.c:203:22: warning: format specifies type 'unsigned long long'
  but the argument has type 'guint64' (aka 'unsigned long') [-Wformat]
                          sess->session_id, g_variant_get_uint64(data));
  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~
  libsigrokdecode-internal.h:103:44: note: expanded from macro 'srd_dbg'
  #define srd_dbg(...)    srd_log(SRD_LOG_DBG,  __VA_ARGS__)
                                                ^~~~~~~~~~~

configure.ac: Bump package version to 0.6.0.

0.6.0 will be the next major release. Bump now, so that
there is no confusion of tarball 0.5.0 and 0.6.0-git snapshots.

Bump libtool version (not package version) to 4:0:0.

The last release (0.4.0) had the libtool version (current:revision:age)
set to 3:0:0. Since this release removes and changes interfaces, the
new version is 4:0:0.

http://www.gnu.org/software/libtool/manual/libtool.html#Updating-version-info

This changes the library filename (e.g. on Linux) from
libsigrokdecode.so.3.0.0 to libsigrokdecode.so.4.0.0, the SONAME
(+symlink) becomes libsigrokdecode.so.4.

NEWS: Add list of user-visible changes so far.

Various Doxygen fixes.

spi: Missing samplerate spec is not fatal

Check for the availability of a samplerate specification, but don't
abort in its absence. Lack of the samplerate only prevents the emission
of throughput annotations, but still allows decoding the clocked signal.

spi: Improve use of PD API version 3

Eliminate more instances where Python code tracked signal changes instead
of having common library code do the work. Reduce the number of boundary
crossings between library and decoder code (Python vs C), by inspecting
fewer input edges. Yet cope with the CS signal's being optional. Emit
identical annotations to the previous implementation for CS changes,
including the initial change "from None to 0/1". Sort the checks for
optional input signals at the top of decode() into a more natural order.
Improve and update comments.

This commit results in a more appropriate use of the PD v3 API in the
SPI protocol decoder.

gpib: Convert to PD API version 3

Have edges detected in common library code. Cope with optional initial
low level (without an edge) at the start of sample data. Handle the
optionally enforced processing at a specified sample number.

pwm: Convert to PD API version 3

Have edges detected in common library code.

spi: Convert to PD API version 3

Have edges detected in common library code. Move the test for presence
of optional channels out of the decode loop. Do inspect the very first
sample for pixel compatibility with the previous implementation.

HACKING: Update URL to Linux kernel coding style.

Rename eeprom93cxx decoder to eeprom93xx.

Not all EEPROMs of this series have (just) a 'c' in the name.

eeprom24xx: Don't make lists.py executable.

Drop trailing whitespace in various PDs.

Add srd_inst_initial_pins_set_all() and support code.

This allows frontends to set the assumed initial pins (i.e., the assumed
state of the pins before the first sample of a capture) to user-specified
values.

The assumed initial pins can be either low, or high, or "use same value
as the first sample of the capture".

The special self.initial_pins decoder attribute is now removed.

Rename maxim_ds28ea00 to ds28ea00.

None of the other PDs have a vendorname in the PD name.

struct srd_decoder: Add list of input/output decoder IDs.

Show lib versions in the debug output.

can: Skip stuff bit inspection where not applicable

Bit stuffing does not apply to the last fields of a frame, specifically
the CRC delimiter, the ACK, and the end-of-frame fields. Adjust the
respective bit handling logic.

This fixes bug #656.

can: Convert to PD API version 3

Don't inspect each individual sample in the Python based PD. Instead use
the backend's query API to detect the start of a frame and to advance to
the sample point position.