[FL-1800] IRDA: enc/decoder refactoring, Add NEC42 (#705)

* WIP: IRDA: multilen protocol refactoring, NEC42
* IRDA: Refactoring encoder/decoder

Co-authored-by: あく <alleteam@gmail.com>

lib/irda/encoder_decoder/common/irda_common_encoder.c

@@ -4,6 +4,19 @@
 #include <stdbool.h>
 #include <furi.h>
 #include "irda_i.h"
+#include <stdint.h>
+
+static IrdaStatus irda_common_encode_bits(IrdaCommonEncoder* encoder, uint32_t* duration, bool* level) {
+    IrdaStatus status = encoder->protocol->encode(encoder, duration, level);
+    furi_assert(status == IrdaStatusOk);
+    ++encoder->timings_encoded;
+    encoder->timings_sum += *duration;
+    if ((encoder->bits_encoded == encoder->bits_to_encode) && *level) {
+        status = IrdaStatusDone;
+    }
+
+    return status;
+}
 
 /*
  *
@@ -32,14 +45,12 @@ IrdaStatus irda_common_encode_manchester(IrdaCommonEncoder* encoder, uint32_t* d
 
     *level = even_timing ^ logic_value;
     *duration = timings->bit1_mark;
-    if (even_timing)        /* start encoding from space */
+    if (even_timing)
         ++encoder->bits_encoded;
-    ++encoder->timings_encoded;
-    encoder->timings_sum += *duration;
+    else if (*level && (encoder->bits_encoded + 1 == encoder->bits_to_encode))
+        ++encoder->bits_encoded;        /* don't encode last space */
 
-    bool finish = (encoder->bits_encoded == encoder->protocol->databit_len);
-    finish |= (encoder->bits_encoded == (encoder->protocol->databit_len-1)) && *level && !even_timing;
-    return finish ? IrdaStatusDone : IrdaStatusOk;
+    return IrdaStatusOk;
 }
 
 IrdaStatus irda_common_encode_pdwm(IrdaCommonEncoder* encoder, uint32_t* duration, bool* level) {
@@ -47,39 +58,25 @@ IrdaStatus irda_common_encode_pdwm(IrdaCommonEncoder* encoder, uint32_t* duratio
     furi_assert(duration);
     furi_assert(level);
 
-    bool done = false;
     const IrdaTimings* timings = &encoder->protocol->timings;
     uint8_t index = encoder->bits_encoded / 8;
     uint8_t shift = encoder->bits_encoded % 8;   // LSB first
     bool logic_value = !!(encoder->data[index] & (0x01 << shift));
-
-    // stop bit
-    if (encoder->bits_encoded == encoder->protocol->databit_len) {
-        furi_assert(!encoder->protocol->no_stop_bit);
-        *duration = timings->bit1_mark;
-        *level = true;
-        ++encoder->timings_encoded;
-        encoder->timings_sum += *duration;
-        return IrdaStatusDone;
-    }
+    bool pwm = timings->bit1_space == timings->bit0_space;
 
     if (encoder->timings_encoded % 2) {         /* start encoding from space */
         *duration = logic_value ? timings->bit1_mark : timings->bit0_mark;
         *level = true;
+        if (pwm)
+            ++encoder->bits_encoded;
     } else {
         *duration = logic_value ? timings->bit1_space : timings->bit0_space;
         *level = false;
-        ++encoder->bits_encoded;
+        if (!pwm)
+            ++encoder->bits_encoded;
     }
 
-    if ((encoder->bits_encoded == encoder->protocol->databit_len)
-        && encoder->protocol->no_stop_bit) {
-        done = true;
-    }
-
-    ++encoder->timings_encoded;
-    encoder->timings_sum += *duration;
-    return done ? IrdaStatusDone : IrdaStatusOk;
+    return IrdaStatusOk;
 }
 
 IrdaStatus irda_common_encode(IrdaCommonEncoder* encoder, uint32_t* duration, bool* level) {
@@ -116,7 +113,7 @@ IrdaStatus irda_common_encode(IrdaCommonEncoder* encoder, uint32_t* duration, bo
         }
         /* FALLTHROUGH */
     case IrdaCommonEncoderStateEncode:
-        status = encoder->protocol->encode(encoder, duration, level);
+        status = irda_common_encode_bits(encoder, duration, level);
         if (status == IrdaStatusDone) {
             if (encoder->protocol->encode_repeat) {
                 encoder->state = IrdaCommonEncoderStateEncodeRepeat;
@@ -138,10 +135,18 @@ IrdaStatus irda_common_encode(IrdaCommonEncoder* encoder, uint32_t* duration, bo
 
 void* irda_common_encoder_alloc(const IrdaCommonProtocolSpec* protocol) {
     furi_assert(protocol);
+    if (protocol->decode == irda_common_decode_pdwm) {
+        furi_assert((protocol->timings.bit1_mark == protocol->timings.bit0_mark) ^ (protocol->timings.bit1_space == protocol->timings.bit0_space));
+    }
 
-    uint32_t alloc_size = sizeof(IrdaCommonEncoder)
-                          + protocol->databit_len / 8
-                          + !!(protocol->databit_len % 8);
+    /* protocol->databit_len[0] has to contain biggest value of bits that can be decoded */
+    for (int i = 1; i < COUNT_OF(protocol->databit_len); ++i) {
+        furi_assert(protocol->databit_len[i] <= protocol->databit_len[0]);
+    }
+
+    uint32_t alloc_size = sizeof(IrdaCommonDecoder)
+                          + protocol->databit_len[0] / 8
+                          + !!(protocol->databit_len[0] % 8);
     IrdaCommonEncoder* encoder = furi_alloc(alloc_size);
     memset(encoder, 0, alloc_size);
     encoder->protocol = protocol;
@@ -162,8 +167,14 @@ void irda_common_encoder_reset(IrdaCommonEncoder* encoder) {
     encoder->state = IrdaCommonEncoderStateSilence;
     encoder->switch_detect = 0;
 
-    uint8_t bytes_to_clear = encoder->protocol->databit_len / 8
-        + !!(encoder->protocol->databit_len % 8);
+    uint8_t max_databit_len = 0;
+
+    for (int i = 0; i < COUNT_OF(encoder->protocol->databit_len); ++i) {
+        max_databit_len = MAX(max_databit_len, encoder->protocol->databit_len[i]);
+    }
+
+    uint8_t bytes_to_clear = max_databit_len / 8
+        + !!(max_databit_len % 8);
     memset(encoder->data, 0, bytes_to_clear);
 }