// Copyright 2009 Ken Shirriff

// Copyright 2015 Mark Szabo

// Copyright 2015 Sebastien Warin

// Copyright 2017, 2019 David Conran

#include "IRrecv.h"

#include <stddef.h>

#ifndef UNIT_TEST

#if defined(ESP8266)

extern "C" {

#include <gpio.h>

#include <user_interface.h>

}

#endif // ESP8266

#include <Arduino.h>

#endif // UNIT_TEST

#include <algorithm>

#ifdef UNIT_TEST

#include <cassert>

#endif // UNIT_TEST

#include "IRremoteESP8266.h"

#include "IRutils.h"

#if defined(ESP32)

#if ( defined(ESP_ARDUINO_VERSION_MAJOR) && (ESP_ARDUINO_VERSION_MAJOR >= 3) )

#include <driver/gpio.h>

#endif // ESP_ARDUINO_VERSION_MAJOR >= 3

#endif

#ifdef UNIT_TEST

#undef ICACHE_RAM_ATTR

#define ICACHE_RAM_ATTR

#endif

#ifndef USE_IRAM_ATTR

#if defined(ESP8266)

#if defined(IRAM_ATTR)

#define USE_IRAM_ATTR IRAM_ATTR

#else // IRAM_ATTR

#define USE_IRAM_ATTR ICACHE_RAM_ATTR

#endif // IRAM_ATTR

#endif // ESP8266

#if defined(ESP32)

#define USE_IRAM_ATTR IRAM_ATTR

#endif // ESP32

#endif // USE_IRAM_ATTR

#define ONCE 0

// Updated by David Conran (https://github.com/crankyoldgit) for receiving IR

// code on ESP32

// Updated by Sebastien Warin (http://sebastien.warin.fr) for receiving IR code

// on ESP8266

// Updated by markszabo (https://github.com/crankyoldgit/IRremoteESP8266) for

// sending IR code on ESP8266

// Globals

#ifndef UNIT_TEST

#if defined(ESP8266)

namespace _IRrecv {

static ETSTimer timer;

} // namespace _IRrecv

#endif // ESP8266

#if defined(ESP32)

#if ( defined(ESP_ARDUINO_VERSION) && \

(ESP_ARDUINO_VERSION >= ESP_ARDUINO_VERSION_VAL(3, 0, 0)) )

#define _ESP32_ARDUINO_CORE_V3PLUS

#endif // ESP_ARDUINO_VERSION >= 3

// We need a horrible timer hack for ESP32 Arduino framework < v2.0.0

#if !defined(_ESP32_ARDUINO_CORE_V2PLUS)

// Version check

#if ( defined(ESP_ARDUINO_VERSION_MAJOR) && (ESP_ARDUINO_VERSION_MAJOR >= 2) )

// No need for the hack if we are running version >= 2.0.0

#define _ESP32_ARDUINO_CORE_V2PLUS false

#else // Version check

// If no ESP_ARDUINO_VERSION_MAJOR is defined, or less than 2, then we are

// using an old ESP32 core, so we need the hack.

#define _ESP32_ARDUINO_CORE_V2PLUS true

#endif // Version check

#endif // !defined(_ESP32_ARDUINO_CORE_V2PLUS)

#if _ESP32_ARDUINO_CORE_V2PLUS

// Required structs/types from:

// https://github.com/espressif/arduino-esp32/blob/6b0114366baf986c155e8173ab7c22bc0c5fcedc/cores/esp32/esp32-hal-timer.c#L28-L58

// These are needed to be able to directly manipulate the timer registers from

// inside an ISR. This is very very ugly.

// Ref: https://github.com/crankyoldgit/IRremoteESP8266/issues/1350

// Note: This will need to be updated if it ever changes.

//

// Start of Horrible Hack!

typedef struct {

union {

struct {

uint32_t reserved0: 10;

uint32_t alarm_en: 1;

/*When set alarm is enabled*/

uint32_t level_int_en: 1;

/*When set level type interrupt will be generated during alarm*/

uint32_t edge_int_en: 1;

/*When set edge type interrupt will be generated during alarm*/

uint32_t divider: 16;

/*Timer clock (T0/1_clk) pre-scale value.*/

uint32_t autoreload: 1;

/*When set timer 0/1 auto-reload at alarming is enabled*/

uint32_t increase: 1;

/*When set timer 0/1 time-base counter increment.

When cleared timer 0 time-base counter decrement.*/

uint32_t enable: 1;

/*When set timer 0/1 time-base counter is enabled*/

};

uint32_t val;

} config;

uint32_t cnt_low;

/*Register to store timer 0/1 time-base counter current value lower 32

bits.*/

uint32_t cnt_high;

/*Register to store timer 0 time-base counter current value higher 32

bits.*/

uint32_t update;

/*Write any value will trigger a timer 0 time-base counter value update

(timer 0 current value will be stored in registers above)*/

uint32_t alarm_low;

/*Timer 0 time-base counter value lower 32 bits that will trigger the

alarm*/

uint32_t alarm_high;

/*Timer 0 time-base counter value higher 32 bits that will trigger the

alarm*/

uint32_t load_low;

/*Lower 32 bits of the value that will load into timer 0 time-base counter*/

uint32_t load_high;

/*higher 32 bits of the value that will load into timer 0 time-base

counter*/

uint32_t reload;

/*Write any value will trigger timer 0 time-base counter reload*/

} hw_timer_reg_t;

typedef struct hw_timer_s {

hw_timer_reg_t * dev;

uint8_t num;

uint8_t group;

uint8_t timer;

portMUX_TYPE lock;

} hw_timer_t;

#endif // _ESP32_ARDUINO_CORE_V2PLUS / End of Horrible Hack.

namespace _IRrecv {

static hw_timer_t *timer = NULL;

} // namespace _IRrecv

#endif // ESP32

using _IRrecv::timer;

#endif // UNIT_TEST

namespace _IRrecv { // Namespace extension

#if defined(ESP32)

portMUX_TYPE mux = portMUX_INITIALIZER_UNLOCKED;

#endif // ESP32

atomic_irparams_t params;

irparams_t *params_save; // A copy of the interrupt state while decoding.

} // namespace _IRrecv

#if defined(ESP32)

using _IRrecv::mux;

#endif // ESP32

using _IRrecv::params;

using _IRrecv::params_save;

#ifndef UNIT_TEST

#if defined(ESP8266)

/// Interrupt handler for when the timer runs out.

/// It signals to the library that capturing of IR data has stopped.

/// @param[in] arg Unused. (ESP8266 Only)

static void USE_IRAM_ATTR read_timeout(void *arg __attribute__((unused))) {

os_intr_lock();

#endif // ESP8266

/// @cond IGNORE

#if defined(ESP32)

/// Interrupt handler for when the timer runs out.

/// It signals to the library that capturing of IR data has stopped.

/// @note ESP32 version

static void USE_IRAM_ATTR read_timeout(void) {

/// @endcond

portENTER_CRITICAL(&mux);

#endif // ESP32

if (params.rawlen) params.rcvstate = kStopState;

#if defined(ESP8266)

os_intr_unlock();

#endif // ESP8266

#if defined(ESP32)

portEXIT_CRITICAL(&mux);

#endif // ESP32

}

/// Interrupt handler for changes on the GPIO pin handling incoming IR messages.

static void USE_IRAM_ATTR gpio_intr() {

uint32_t now = micros();

static uint32_t start = 0;

#if defined(ESP8266)

uint32_t gpio_status = GPIO_REG_READ(GPIO_STATUS_ADDRESS);

os_timer_disarm(&timer);

GPIO_REG_WRITE(GPIO_STATUS_W1TC_ADDRESS, gpio_status);

#endif // ESP8266

// Grab a local copy of rawlen to reduce instructions used in IRAM.

// This is an ugly premature optimisation code-wise, but we do everything we

// can to save IRAM.

// It seems referencing the value via the structure uses more instructions.

// Less instructions means faster and less IRAM used.

// N.B. It saves about 13 bytes of IRAM.

uint16_t rawlen = params.rawlen;

if (rawlen >= params.bufsize) {

params.overflow = true;

params.rcvstate = kStopState;

}

if (params.rcvstate == kStopState) return;

if (params.rcvstate == kIdleState) {

params.rcvstate = kMarkState;

params.rawbuf[rawlen] = 1;

} else {

if (now < start)

params.rawbuf[rawlen] = (UINT32_MAX - start + now) / kRawTick;

else

params.rawbuf[rawlen] = (now - start) / kRawTick;

}

params.rawlen = params.rawlen + 1; // C++20 fix

start = now;

#if defined(ESP8266)

os_timer_arm(&timer, params.timeout, ONCE);

#endif // ESP8266

#if defined(ESP32)

// Reset the timeout.

//

#if _ESP32_ARDUINO_CORE_V2PLUS

// The following three lines of code are the equivalent of:

// `timerWrite(timer, 0);`

// We can't call that routine safely from inside an ISR as that procedure

// is not stored in IRAM. Hence, we do it manually so that it's covered by

// USE_IRAM_ATTR in this ISR.

// @see https://github.com/crankyoldgit/IRremoteESP8266/issues/1350

// @see https://github.com/espressif/arduino-esp32/blob/6b0114366baf986c155e8173ab7c22bc0c5fcedc/cores/esp32/esp32-hal-timer.c#L106-L110

timer->dev->load_high = static_cast<uint32_t>(0);

timer->dev->load_low = static_cast<uint32_t>(0);

timer->dev->reload = 1;

// The next line is the same, but instead replaces:

// `timerAlarmEnable(timer);`

// @see https://github.com/crankyoldgit/IRremoteESP8266/issues/1350

// @see https://github.com/espressif/arduino-esp32/blob/6b0114366baf986c155e8173ab7c22bc0c5fcedc/cores/esp32/esp32-hal-timer.c#L176-L178

timer->dev->config.alarm_en = 1;

#elif defined(_ESP32_ARDUINO_CORE_V3PLUS)

// For ESP32 core version 3.x, replace `timerAlarmEnable`

timerWrite(timer, 0);

uint64_t alarm_value = 50000; // Example value (50ms)

timerAlarm(timer, alarm_value, false, 0);

#else // !_ESP32_ARDUINO_CORE_V3PLUS

timerWrite(timer, 0);

timerAlarmEnable(timer);

#endif // _ESP32_ARDUINO_CORE_V2PLUS

#endif // ESP32

}

#endif // UNIT_TEST

// Start of IRrecv class -------------------

/// Class constructor

/// Args:

/// @param[in] recvpin The GPIO pin the IR receiver module's data pin is

/// connected to.

/// @param[in] bufsize Nr. of entries to have in the capture buffer.

/// (Default: kRawBuf)

/// @param[in] timeout Nr. of milli-Seconds of no signal before we stop

/// capturing data. (Default: kTimeoutMs)

/// @param[in] save_buffer Use a second (save) buffer to decode from.

/// (Default: false)

/// @param[in] timer_num Nr. of the ESP32 timer to use. (0 to 3) (ESP32 Only)

/// or (0 to 1) (ESP32-C3)

#if defined(ESP32)

IRrecv::IRrecv(const uint16_t recvpin, const uint16_t bufsize,

const uint8_t timeout, const bool save_buffer,

const uint8_t timer_num) {

// Ensure we use a valid timer number.

_timer_num = std::min(timer_num,

(uint8_t)(

#ifdef SOC_TIMER_GROUP_TOTAL_TIMERS

SOC_TIMER_GROUP_TOTAL_TIMERS - 1));

#else // SOC_TIMER_GROUP_TOTAL_TIMERS

3));

#endif // SOC_TIMER_GROUP_TOTAL_TIMERS

#else // ESP32

/// @cond IGNORE

/// Class constructor

/// Args:

/// @param[in] recvpin The GPIO pin the IR receiver module's data pin is

/// connected to.

/// @param[in] bufsize Nr. of entries to have in the capture buffer.

/// (Default: kRawBuf)

/// @param[in] timeout Nr. of milli-Seconds of no signal before we stop

/// capturing data. (Default: kTimeoutMs)

/// @param[in] save_buffer Use a second (save) buffer to decode from.

/// (Default: false)

IRrecv::IRrecv(const uint16_t recvpin, const uint16_t bufsize,

const uint8_t timeout, const bool save_buffer) {

/// @endcond

#endif // ESP32

params.recvpin = recvpin;

params.bufsize = bufsize;

// Ensure we are going to be able to store all possible values in the

// capture buffer.

params.timeout = std::min(timeout, (uint8_t)kMaxTimeoutMs);

params.rawbuf = new uint16_t[bufsize];

if (params.rawbuf == NULL) {

DPRINTLN(

"Could not allocate memory for the primary IR buffer.\n"

"Try a smaller size for CAPTURE_BUFFER_SIZE.\nRebooting!");

#ifndef UNIT_TEST

ESP.restart(); // Mem alloc failure. Reboot.

#endif

}

// If we have been asked to use a save buffer (for decoding), then create one.

if (save_buffer) {

params_save = new irparams_t;

params_save->rawbuf = new uint16_t[bufsize];

// Check we allocated the memory successfully.

if (params_save->rawbuf == NULL) {

DPRINTLN(

"Could not allocate memory for the second IR buffer.\n"

"Try a smaller size for CAPTURE_BUFFER_SIZE.\nRebooting!");

#ifndef UNIT_TEST

ESP.restart(); // Mem alloc failure. Reboot.

#endif

}

} else {

params_save = NULL;

}

#if DECODE_HASH

_unknown_threshold = kUnknownThreshold;

#endif // DECODE_HASH

_tolerance = kTolerance;

}

/// Class destructor

/// Cleans up after the object is no longer needed.

/// e.g. Frees up all memory used by the various buffers, and disables any

/// timers or interrupts used.

IRrecv::~IRrecv(void) {

disableIRIn();

delete[] params.rawbuf;

if (params_save != NULL) {

delete[] params_save->rawbuf;

delete params_save;

}

}

/// Set up and (re)start the IR capture mechanism.

/// @param[in] pullup A flag indicating should the GPIO use the internal pullup

/// resistor. (Default: `false`. i.e. No.)

void IRrecv::enableIRIn(const bool pullup) {

// ESP32's seem to require explicitly setting the GPIO to INPUT etc.

// This wasn't required on the ESP8266s, but it shouldn't hurt to make sure.

if (pullup) {

#ifndef UNIT_TEST

pinMode(params.recvpin, INPUT_PULLUP);

} else {

pinMode(params.recvpin, INPUT);

#endif // UNIT_TEST

}

#if defined(ESP32)

// Initialise the ESP32 timer.

#if defined(_ESP32_ARDUINO_CORE_V3PLUS)

// Use newer timerBegin signature for ESP32 core version 3.x

timer = timerBegin(1000000); // Initialize with 1MHz (1us per tick)

#else // _ESP32_ARDUINO_CORE_V3PLUS

// 80MHz / 80 = 1 uSec granularity.

timer = timerBegin(_timer_num, 80, true);

#endif // _ESP32_ARDUINO_CORE_V3PLUS

// Ensure the timer is successfully initialized

#ifdef DEBUG

if (timer == NULL) {

DPRINT("FATAL: Unable enable system timer: ");

DPRINTLN((uint16_t)_timer_num);

}

#endif // DEBUG

assert(timer != NULL); // Check we actually got the timer.

// Set the timer so it only fires once, and set its trigger in microseconds.

#if defined(_ESP32_ARDUINO_CORE_V3PLUS)

timerWrite(timer, 0); // Reset the timer for ESP32 core version 3.x

timerAttachInterrupt(timer, &read_timeout);

#else // _ESP32_ARDUINO_CORE_V3PLUS

timerAlarmWrite(timer, MS_TO_USEC(params.timeout), ONCE);

// Note: Interrupt needs to be attached before it can be enabled or disabled.

// Note: EDGE (true) is not supported, use LEVEL (false). Ref: #1713

// See: https://github.com/espressif/arduino-esp32/blob/caef4006af491130136b219c1205bdcf8f08bf2b/cores/esp32/esp32-hal-timer.c#L224-L227

timerAttachInterrupt(timer, &read_timeout, false);

#endif // _ESP32_ARDUINO_CORE_V3PLUS

#endif // ESP32

// Initialise state machine variables

resume();

#ifndef UNIT_TEST

#if defined(ESP8266)

// Initialise ESP8266 timer.

os_timer_disarm(&timer);

os_timer_setfn(&timer, reinterpret_cast<os_timer_func_t *>(read_timeout),

NULL);

#endif // ESP8266

// Attach Interrupt

attachInterrupt(params.recvpin, gpio_intr, CHANGE);

#endif // UNIT_TEST

}

/// Stop collection of any received IR data.

/// Disable any timers and interrupts.

void IRrecv::disableIRIn(void) {

#ifndef UNIT_TEST

#if defined(ESP8266)

os_timer_disarm(&timer);

#elif defined(_ESP32_ARDUINO_CORE_V3PLUS)

timerWrite(timer, 0); // Reset the timer

timerDetachInterrupt(timer);

timerEnd(timer);

#elif defined(ESP32)

timerAlarmDisable(timer);

timerDetachInterrupt(timer);

timerEnd(timer);

timer = NULL; // Cleanup the ESP32 timeout timer.

#endif // ESP32

detachInterrupt(params.recvpin);

#endif // UNIT_TEST

}

/// Pause collection of received IR data.

/// @see IRrecv class constructor

void IRrecv::pause(void) {

params.rcvstate = kStopState;

params.rawlen = 0;

params.overflow = false;

#if defined(ESP32)

gpio_intr_disable((gpio_num_t)params.recvpin);

#endif // ESP32

}

/// Resume collection of received IR data.

/// @note This is required if `decode()` is successful and `save_buffer` was

/// not set when the class was instanciated.

/// @see IRrecv class constructor

void IRrecv::resume(void) {

params.rcvstate = kIdleState;

params.rawlen = 0;

params.overflow = false;

#if defined(ESP32)

// Check for ESP32 core version and handle timer functions differently

#if defined(_ESP32_ARDUINO_CORE_V3PLUS)

timerWrite(timer, 0); // Reset the timer (no need for timerAlarmDisable)

#else // _ESP32_ARDUINO_CORE_V3PLUS

timerAlarmDisable(timer);

#endif // _ESP32_ARDUINO_CORE_V3PLUS

// Re-enable GPIO interrupt in both versions

gpio_intr_enable((gpio_num_t)params.recvpin);

#endif // ESP32

}

/// Make a copy of the interrupt state & buffer data.

/// Needed because irparams is marked as volatile, thus memcpy() isn't allowed.

/// Only call this when you know the interrupt handlers won't modify anything.

/// i.e. In kStopState.

/// @param[in] src Pointer to an irparams_t structure to copy from.

/// @param[out] dst Pointer to an irparams_t structure to copy to.

void IRrecv::copyIrParams(atomic_irparams_t *src, irparams_t *dst) {

// Typecast src and dst addresses to (char *)

char *csrc = (char *)src; // NOLINT(readability/casting)

char *cdst = (char *)dst; // NOLINT(readability/casting)

// Save the pointer to the destination's rawbuf so we don't lose it as

// the for-loop/copy after this will overwrite it with src's rawbuf pointer.

// This isn't immediately obvious due to typecasting/different variable names.

uint16_t *dst_rawbuf_ptr;

dst_rawbuf_ptr = dst->rawbuf;

// Copy contents of src[] to dst[]

for (uint16_t i = 0; i < sizeof(irparams_t); i++) cdst[i] = csrc[i];

// Restore the buffer pointer

dst->rawbuf = dst_rawbuf_ptr;

// Copy the rawbuf

for (uint16_t i = 0; i < dst->bufsize; i++) dst->rawbuf[i] = src->rawbuf[i];

}

/// Obtain the maximum number of entries possible in the capture buffer.

/// i.e. It's size.

/// @return The size of the buffer that is in use by the object.

uint16_t IRrecv::getBufSize(void) { return params.bufsize; }

#if DECODE_HASH

/// Set the minimum length we will consider for reporting UNKNOWN message types.

/// @param[in] length Min nr. of mark/space pulses required to be considered.

void IRrecv::setUnknownThreshold(const uint16_t length) {

_unknown_threshold = length;

}

#endif // DECODE_HASH

/// Set the base tolerance percentage for matching incoming IR messages.

/// @param[in] percent An integer percentage. (0-100)

void IRrecv::setTolerance(const uint8_t percent) {

_tolerance = std::min(percent, (uint8_t)100);

}

/// Get the base tolerance percentage for matching incoming IR messages.

/// @return A integer percentage.

uint8_t IRrecv::getTolerance(void) { return _tolerance; }

#if ENABLE_NOISE_FILTER_OPTION

/// Remove or merge pulses in the capture buffer that are too short.

/// @param[in,out] results Ptr to the decode_results we are going to filter.

/// @param[in] floor Only allow values in the buffer large than this.

/// (in microSeconds)

void IRrecv::crudeNoiseFilter(decode_results *results, const uint16_t floor) {

if (floor == 0) return; // Nothing to do.

const uint16_t kTickFloor = floor / kRawTick;

const uint16_t kBufSize = getBufSize();

uint16_t offset = kStartOffset;

while (offset < results->rawlen && offset + 2 < kBufSize) {

uint16_t curr = results->rawbuf[offset];

uint16_t next = results->rawbuf[offset + 1];

uint16_t addition = curr + next;

if (curr < kTickFloor) { // Is it too short?

// Shuffle the buffer down. i.e. Remove the mark & space pair.

// Note: `memcpy()` can't be used as rawbuf is `volatile`.

for (uint16_t i = offset + 2; i <= results->rawlen && i < kBufSize; i++)

results->rawbuf[i - 2] = results->rawbuf[i];

if (offset > 1) { // There is a previous pair we can add to.

// Merge this pair into into the previous space. // C++20 fix applied

results->rawbuf[offset - 1] = results->rawbuf[offset - 1] + addition;

}

results->rawlen -= 2; // Adjust the length.

} else {

offset++; // Move along.

}

}

}

#endif // ENABLE_NOISE_FILTER_OPTION

/// Decodes the received IR message.

/// If the interrupt state is saved, we will immediately resume waiting

/// for the next IR message to avoid missing messages.

/// @note There is a trade-off here. Saving the state means less time lost until

/// we can receiving the next message vs. using more RAM. Choose appropriately.

/// @param[out] results A PTR to where the decoded IR message will be stored.

/// @param[out] save A PTR to an irparams_t instance in which to save

/// the interrupt's memory/state. NULL means don't save it.

/// @param[in] max_skip Maximum Nr. of pulses at the begining of a capture we

/// can skip when attempting to find a protocol we can successfully decode.

/// This parameter can dramatically improve detection of protocols

/// when there is light IR interference just before an incoming IR

/// message, however, it comes at a steep performace price.

/// (Default is 0. No skipping.)

/// @warning Increasing the `max_skip` value will dramatically (linearly)

/// increase the cpu time & usage to decode protocols.

/// e.g. 0 -> 1 will be a 2x increase in cpu usage/time.

/// 0 -> 2 will be a 3x increase etc.

/// If you are going to do this, consider disabling protocol decoding for

/// protocols you are not expecting.

/// @param[in] noise_floor Pulses below this size (in usecs) will be removed or

/// merged prior to any decoding. This is to try to remove noise/poor

/// readings & slightly increase the chances of a successful decode but at the

/// cost of data fidelity & integrity.

/// (Defaults to 0 usecs. i.e. Don't filter; which is safe!)

/// @warning DANGER: **Here Be Dragons!**

/// If you set the `noise_floor` value too high, it **WILL** break decoding

/// of some protocols. You have been warned!

/// **Any** non-zero value has the potential to **cook** the captured raw data

/// i.e. The raw data is going to lie to you.

/// It may obscure hardware, circuit, & environment issues thus making it

/// impossible to support you accurately or confidently.

/// Values of <= 50 usecs will probably be safe.

/// 51 - 100 usecs **might** be okay.

/// 100 - 150 usecs is "Danger, Will Robinson!".

/// 150 - 200 usecs expect broken protocols.

/// At 200+ usecs, you **have** protocols you can't decode!!

/// @return A boolean indicating if an IR message is ready or not.

bool IRrecv::decode(decode_results *results, irparams_t *save,

uint8_t max_skip, uint16_t noise_floor) {

// Proceed only if an IR message been received.

#ifndef UNIT_TEST

if (params.rcvstate != kStopState) return false;

#endif

// Clear the entry we are currently pointing to when we got the timeout.

// i.e. Stopped collecting IR data.

// It's junk as we never wrote an entry to it and can only confuse decoding.

// This is done here rather than logically the best place in read_timeout()

// as it saves a few bytes of ICACHE_RAM as that routine is bound to an

// interrupt. decode() is not stored in ICACHE_RAM.

// Another better option would be to zero the entire irparams.rawbuf[] on

// resume() but that is a much more expensive operation compare to this.

// However, don't do this if rawbuf is already full as we stomp over the heap.

// See: https://github.com/crankyoldgit/IRremoteESP8266/issues/1516

if (!params.overflow) params.rawbuf[params.rawlen] = 0;

bool resumed = false; // Flag indicating if we have resumed.

// If we were requested to use a save buffer previously, do so.

if (save == NULL) save = params_save;

if (save == NULL) {

// We haven't been asked to copy it so use the existing memory.

#ifndef UNIT_TEST

results->rawbuf = params.rawbuf;

results->rawlen = params.rawlen;

results->overflow = params.overflow;

#endif

} else {

copyIrParams(&params, save); // Duplicate the interrupt's memory.

resume(); // It's now safe to rearm. The IR message won't be overridden.

resumed = true;

// Point the results at the saved copy.

results->rawbuf = save->rawbuf;

results->rawlen = save->rawlen;

results->overflow = save->overflow;

}

// Reset any previously partially processed results.

results->decode_type = UNKNOWN;

results->bits = 0;

results->value = 0;

results->address = 0;

results->command = 0;

results->repeat = false;

#if ENABLE_NOISE_FILTER_OPTION

crudeNoiseFilter(results, noise_floor);

#endif // ENABLE_NOISE_FILTER_OPTION

// Keep looking for protocols until we've run out of entries to skip or we

// find a valid protocol message.

for (uint16_t offset = kStartOffset;

offset <= (max_skip * 2) + kStartOffset;

offset += 2) {

#if DECODE_AIWA_RC_T501

DPRINTLN("Attempting Aiwa RC T501 decode");

// Try decodeAiwaRCT501() before decodeSanyoLC7461() & decodeNEC()

// because the protocols are similar. This protocol is more specific than

// those ones, so should go before them.

if (decodeAiwaRCT501(results, offset)) return true;

#endif

#if DECODE_SANYO

DPRINTLN("Attempting Sanyo LC7461 decode");

// Try decodeSanyoLC7461() before decodeNEC() because the protocols are

// similar in timings & structure, but the Sanyo one is much longer than the

// NEC protocol (42 vs 32 bits) so this one should be tried first to try to

// reduce false detection as a NEC packet.

if (decodeSanyoLC7461(results, offset)) return true;

#endif

#if DECODE_CARRIER_AC

DPRINTLN("Attempting Carrier AC decode");

// Try decodeCarrierAC() before decodeNEC() because the protocols are

// similar in timings & structure, but the Carrier one is much longer than

// the NEC protocol (3x32 bits vs 1x32 bits) so this one should be tried

// first to try to reduce false detection as a NEC packet.

if (decodeCarrierAC(results, offset)) return true;

#endif

#if DECODE_PIONEER

DPRINTLN("Attempting Pioneer decode");

// Try decodePioneer() before decodeNEC() because the protocols are

// similar in timings & structure, but the Pioneer one is much longer than

// the NEC protocol (2x32 bits vs 1x32 bits) so this one should be tried

// first to try to reduce false detection as a NEC packet.

if (decodePioneer(results, offset)) return true;

#endif

#if DECODE_EPSON

DPRINTLN("Attempting Epson decode");

// Try decodeEpson() before decodeNEC() because the protocols are

// similar in timings & structure, but the Epson one is much longer than the

// NEC protocol (3x32 identical bits vs 1x32 bits) so this one should be tried

// first to try to reduce false detection as a NEC packet.

if (decodeEpson(results, offset)) return true;

#endif

#if DECODE_NEC

DPRINTLN("Attempting NEC decode");

if (decodeNEC(results, offset)) return true;

#endif

#if DECODE_MILESTAG2

DPRINTLN("Attempting MilesTag2 decode");

// Try decodeMilestag2() before decodeSony() because the protocols are

// similar in timings & structure, but the Miles one differs in nbits

// so this one should be tried first to try to reduce false detection

if (decodeMilestag2(results, offset, kMilesTag2MsgBits) ||

decodeMilestag2(results, offset, kMilesTag2ShotBits)) return true;

#endif

#if DECODE_SONY

DPRINTLN("Attempting Sony decode");

if (decodeSony(results, offset)) return true;

#endif

#if DECODE_MITSUBISHI

DPRINTLN("Attempting Mitsubishi decode");

if (decodeMitsubishi(results, offset)) return true;

#endif

#if DECODE_MITSUBISHI_AC

DPRINTLN("Attempting Mitsubishi AC decode");

if (decodeMitsubishiAC(results, offset)) return true;

#endif

#if DECODE_MITSUBISHI2

DPRINTLN("Attempting Mitsubishi2 decode");

if (decodeMitsubishi2(results, offset)) return true;

#endif

#if DECODE_RC5

DPRINTLN("Attempting RC5 decode");

if (decodeRC5(results, offset)) return true;

#endif

#if DECODE_RC6

DPRINTLN("Attempting RC6 decode");

if (decodeRC6(results, offset)) return true;

#endif

#if DECODE_RCMM

DPRINTLN("Attempting RC-MM decode");

if (decodeRCMM(results, offset)) return true;

#endif

#if DECODE_FUJITSU_AC

// Fujitsu A/C needs to precede Panasonic and Denon as it has a short

// message which looks exactly the same as a Panasonic/Denon message.

DPRINTLN("Attempting Fujitsu A/C decode");

if (decodeFujitsuAC(results, offset)) return true;

#endif

#if DECODE_DENON

// Denon needs to precede Panasonic as it is a special case of Panasonic.

DPRINTLN("Attempting Denon decode");

if (decodeDenon(results, offset, kDenon48Bits) ||

decodeDenon(results, offset, kDenonBits) ||

decodeDenon(results, offset, kDenonLegacyBits))

return true;

#endif

#if DECODE_PANASONIC

DPRINTLN("Attempting Panasonic (48-bit) decode");

if (decodePanasonic(results, offset)) return true;

DPRINTLN("Attempting Panasonic (40-bit) decode");

if (decodePanasonic(results, offset, kPanasonic40Bits, true,

kPanasonic40Manufacturer)) return true;

#endif // DECODE_PANASONIC

#if DECODE_LG

DPRINTLN("Attempting LG (28-bit) decode");

if (decodeLG(results, offset, kLgBits, true)) return true;

DPRINTLN("Attempting LG (32-bit) decode");

// LG32 should be tried before Samsung

if (decodeLG(results, offset, kLg32Bits, true)) return true;

#endif

#if DECODE_GICABLE

// Note: Needs to happen before JVC decode, because it looks similar except

// with a required NEC-like repeat code.

DPRINTLN("Attempting GICable decode");

if (decodeGICable(results, offset)) return true;

#endif

#if DECODE_JVC

DPRINTLN("Attempting JVC decode");

if (decodeJVC(results, offset)) return true;

#endif

#if DECODE_SAMSUNG

DPRINTLN("Attempting SAMSUNG decode");

if (decodeSAMSUNG(results, offset)) return true;

#endif

#if DECODE_SAMSUNG36

DPRINTLN("Attempting Samsung36 decode");

if (decodeSamsung36(results, offset)) return true;

#endif

#if DECODE_WHYNTER

DPRINTLN("Attempting Whynter decode");

if (decodeWhynter(results, offset)) return true;

#endif

#if DECODE_DISH

DPRINTLN("Attempting DISH decode");

if (decodeDISH(results, offset)) return true;

#endif

#if DECODE_SHARP

DPRINTLN("Attempting Sharp decode");

if (decodeSharp(results, offset)) return true;

#endif

#if DECODE_BOSCH144

DPRINTLN("Attempting Bosch 144-bit decode");

// Bosch is similar to Coolix, so it must be attempted before decodeCOOLIX.

if (decodeBosch144(results, offset)) return true;

#endif // DECODE_BOSCH144

#if DECODE_COOLIX

DPRINTLN("Attempting Coolix 24-bit decode");

if (decodeCOOLIX(results, offset)) return true;

#endif // DECODE_COOLIX

#if DECODE_NIKAI

DPRINTLN("Attempting Nikai decode");

if (decodeNikai(results, offset)) return true;

#endif

#if DECODE_KELVINATOR

// Kelvinator based-devices use a similar code to Gree ones, to avoid false

// matches this needs to happen before decodeGree().

DPRINTLN("Attempting Kelvinator decode");

if (decodeKelvinator(results, offset)) return true;

#endif

#if DECODE_DAIKIN

DPRINTLN("Attempting Daikin decode");

if (decodeDaikin(results, offset)) return true;

#endif

#if DECODE_DAIKIN2

DPRINTLN("Attempting Daikin2 decode");

if (decodeDaikin2(results, offset)) return true;

#endif

#if DECODE_DAIKIN216

DPRINTLN("Attempting Daikin216 decode");

if (decodeDaikin216(results, offset)) return true;

#endif

#if DECODE_TOSHIBA_AC

DPRINTLN("Attempting Toshiba AC 72bit decode");

if (decodeToshibaAC(results, offset)) return true;

DPRINTLN("Attempting Toshiba AC 80bit decode");

if (decodeToshibaAC(results, offset, kToshibaACBitsLong)) return true;

DPRINTLN("Attempting Toshiba AC 56bit decode");

if (decodeToshibaAC(results, offset, kToshibaACBitsShort)) return true;

#endif

#if DECODE_MIDEA

DPRINTLN("Attempting Midea decode");

if (decodeMidea(results, offset)) return true;

#endif

#if DECODE_MAGIQUEST

DPRINTLN("Attempting Magiquest decode");

if (decodeMagiQuest(results, offset)) return true;

#endif

/* NOTE: Disabled due to poor quality.

#if DECODE_SANYO

// The Sanyo S866500B decoder is very poor quality & depricated.

// *IF* you are going to enable it, do it near last to avoid false positive

// matches.

DPRINTLN("Attempting Sanyo SA8650B decode");

if (decodeSanyo(results, offset))

return true;

#endif

*/

#if DECODE_NEC

// Some devices send NEC-like codes that don't follow the true NEC spec.

// This should detect those. e.g. Apple TV remote etc.

// This needs to be done after all other codes that use strict and some

// other protocols that are NEC-like as well, as turning off strict may

// cause this to match other valid protocols.

DPRINTLN("Attempting NEC (non-strict) decode");

if (decodeNEC(results, offset, kNECBits, false)) {

results->decode_type = NEC_LIKE;

return true;

}

#endif

#if DECODE_LASERTAG

DPRINTLN("Attempting Lasertag decode");

if (decodeLasertag(results, offset)) return true;

#endif

#if DECODE_GREE

// Gree based-devices use a similar code to Kelvinator ones, to avoid false

// matches this needs to happen after decodeKelvinator().

DPRINTLN("Attempting Gree decode");

if (decodeGree(results, offset)) return true;

#endif

#if DECODE_HAIER_AC

DPRINTLN("Attempting Haier AC decode");

if (decodeHaierAC(results, offset)) return true;

#endif

#if DECODE_HAIER_AC_YRW02

DPRINTLN("Attempting Haier AC YR-W02 decode");

if (decodeHaierACYRW02(results, offset)) return true;

#endif

#if DECODE_HAIER_AC176

DPRINTLN("Attempting Haier AC 176 bit decode");

if (decodeHaierAC176(results, offset)) return true;

#endif // DECODE_HAIER_AC176

#if DECODE_HITACHI_AC424

// HitachiAc424 should be checked before HitachiAC, HitachiAC2,

// & HitachiAC184

DPRINTLN("Attempting Hitachi AC 424 decode");

if (decodeHitachiAc424(results, offset, kHitachiAc424Bits)) return true;

#endif // DECODE_HITACHI_AC424

#if DECODE_MITSUBISHI136

// Needs to happen before HitachiAc3 decode.

DPRINTLN("Attempting Mitsubishi136 decode");

if (decodeMitsubishi136(results, offset)) return true;

#endif // DECODE_MITSUBISHI136

#if DECODE_HITACHI_AC3

// HitachiAc3 should be checked before HitachiAC & HitachiAC2

// Attempt normal before the short version.

DPRINTLN("Attempting Hitachi AC3 decode");

// Order these in decreasing bit size, as it is more optimal.

if (decodeHitachiAc3(results, offset, kHitachiAc3Bits) ||

decodeHitachiAc3(results, offset, kHitachiAc3Bits - 4 * 8) ||

decodeHitachiAc3(results, offset, kHitachiAc3Bits - 6 * 8) ||

decodeHitachiAc3(results, offset, kHitachiAc3MinBits + 2 * 8) ||

decodeHitachiAc3(results, offset, kHitachiAc3MinBits))

return true;

#endif // DECODE_HITACHI_AC3

#if DECODE_HITACHI_AC344

// HitachiAC344 should be checked before HitachiAC

DPRINTLN("Attempting Hitachi AC344 decode");

if (decodeHitachiAC(results, offset, kHitachiAc344Bits, true, false))

return true;

#endif // DECODE_HITACHI_AC344

#if DECODE_HITACHI_AC264

// HitachiAC264 should be checked before HitachiAC

DPRINTLN("Attempting Hitachi AC264 decode");

if (decodeHitachiAC(results, offset, kHitachiAc264Bits, true, false))

return true;

#endif // DECODE_HITACHI_AC264

#if DECODE_HITACHI_AC296

// HitachiAC296 should be checked before HitachiAC

DPRINTLN("Attempting Hitachi AC296 decode");

if (decodeHitachiAc296(results, offset, kHitachiAc296Bits, true))

return true;

#endif // DECODE_HITACHI_AC296

#if DECODE_HITACHI_AC2

// HitachiAC2 should be checked before HitachiAC

DPRINTLN("Attempting Hitachi AC2 decode");

if (decodeHitachiAC(results, offset, kHitachiAc2Bits)) return true;

#endif // DECODE_HITACHI_AC2

#if DECODE_HITACHI_AC

DPRINTLN("Attempting Hitachi AC decode");

if (decodeHitachiAC(results, offset, kHitachiAcBits)) return true;

#endif

#if DECODE_HITACHI_AC1

DPRINTLN("Attempting Hitachi AC1 decode");

if (decodeHitachiAC(results, offset, kHitachiAc1Bits)) return true;

#endif

#if DECODE_WHIRLPOOL_AC

DPRINTLN("Attempting Whirlpool AC decode");

if (decodeWhirlpoolAC(results, offset)) return true;

#endif

#if DECODE_SAMSUNG_AC

DPRINTLN("Attempting Samsung AC (extended) decode");

// Check the extended size first, as it should fail fast due to longer

// length.

if (decodeSamsungAC(results, offset, kSamsungAcExtendedBits)) return true;

// Now check for the more common length.

DPRINTLN("Attempting Samsung AC decode");

if (decodeSamsungAC(results, offset, kSamsungAcBits)) return true;

#endif

#if DECODE_ELECTRA_AC

DPRINTLN("Attempting Electra AC decode");

if (decodeElectraAC(results, offset)) return true;

#endif

#if DECODE_PANASONIC_AC

DPRINTLN("Attempting Panasonic AC decode");

if (decodePanasonicAC(results, offset)) return true;

DPRINTLN("Attempting Panasonic AC short decode");

if (decodePanasonicAC(results, offset, kPanasonicAcShortBits)) return true;

#endif

#if DECODE_LUTRON

DPRINTLN("Attempting Lutron decode");

if (decodeLutron(results, offset)) return true;

#endif

#if DECODE_MWM

DPRINTLN("Attempting MWM decode");

if (decodeMWM(results, offset)) return true;

#endif

#if DECODE_VESTEL_AC

DPRINTLN("Attempting Vestel AC decode");

if (decodeVestelAc(results, offset)) return true;

#endif

#if DECODE_MITSUBISHI112 || DECODE_TCL112AC

// Mitsubish112 and Tcl112 share the same decoder.

DPRINTLN("Attempting Mitsubishi112/TCL112AC decode");

if (decodeMitsubishi112(results, offset)) return true;

#endif // DECODE_MITSUBISHI112 || DECODE_TCL112AC

#if DECODE_TECO

DPRINTLN("Attempting Teco decode");

if (decodeTeco(results, offset)) return true;

#endif

#if DECODE_LEGOPF

DPRINTLN("Attempting LEGOPF decode");

if (decodeLegoPf(results, offset)) return true;

#endif

#if DECODE_MITSUBISHIHEAVY

DPRINTLN("Attempting MITSUBISHIHEAVY (152 bit) decode");

if (decodeMitsubishiHeavy(results, offset, kMitsubishiHeavy152Bits))

return true;

DPRINTLN("Attempting MITSUBISHIHEAVY (88 bit) decode");

if (decodeMitsubishiHeavy(results, offset, kMitsubishiHeavy88Bits))

return true;

#endif

#if DECODE_ARGO

DPRINTLN("Attempting Argo WREM3 decode (AC Control)");

if (decodeArgoWREM3(results, offset, kArgo3AcControlStateLength * 8, true))

return true;

DPRINTLN("Attempting Argo WREM3 decode (iFeel report)");

if (decodeArgoWREM3(results, offset, kArgo3iFeelReportStateLength * 8, true))

return true;

DPRINTLN("Attempting Argo WREM3 decode (Config)");

if (decodeArgoWREM3(results, offset, kArgo3ConfigStateLength * 8, true))

return true;

DPRINTLN("Attempting Argo WREM3 decode (Timer)");

if (decodeArgoWREM3(results, offset, kArgo3TimerStateLength * 8, true))

return true;

DPRINTLN("Attempting Argo WREM2 decode");

if (decodeArgo(results, offset, kArgoBits) ||

decodeArgo(results, offset, kArgoShortBits, false)) return true;

#endif // DECODE_ARGO

#if DECODE_SHARP_AC