ProtocolDecoderStatic/ProtocolUSB/usb_decoder.cc

// // ******************************************************************
// //       /\ /|       @File         UsbDecoder.cc
// //       \ V/        @Brief
// //       | "")       @Author        lijinwen, ghz005@uni-trend.com.cn
// //       /  |        @Creation      2024-05-17
// //      /  \\        @Modified      2024-06-24
// //    *(__\_\
// // ******************************************************************

#include "Usb_decoder.h"

#include <utility>

#include "constants.h"
#include "../export_method.h"
#include "../BaseHelper/data_check_helper.h"

// #include <cstddef>

namespace Protocol
{
    std::vector<std::string> UsbDecoder::EventInfoTitles()
    {
        return { "Index", "Start Time", "Sync", "PID", "Data", "Addr", "FNUM", "CRC5", "CRC16", "EOP", "Error" };
    }

    //主解码函数入口
    bool UsbDecoder::DecodeUsb(const UsbDecodeOptions& option, const EdgePulseDataTwoLevels& edge_pulses_dp,
        const EdgePulseDataTwoLevels& edge_pulses_dm, UsbDecodeResult& result)
    {
        result.usb_decoder_ptr = reinterpret_cast<intptr_t>(this);
        is_cancel_ptr_ = option.is_cancel;
        std::vector<TwoLevelEdgePulse> edge_pulses1 = {};

        if (&edge_pulses_dp != nullptr && edge_pulses_dp.waveform_data_count > 0)
        {
            edge_pulses1 =
                CommonHelper::ConvertPointerArrayToVector<TwoLevelEdgePulse>(
                    edge_pulses_dp.GetDataAddrPtr(), edge_pulses_dp.edge_pulses_count);
        }
        std::vector<TwoLevelEdgePulse> edge_pulses2 = {};
        if (&edge_pulses_dm != nullptr && edge_pulses_dm.waveform_data_count > 0)
        {
            edge_pulses2 = CommonHelper::ConvertPointerArrayToVector<TwoLevelEdgePulse>(
                edge_pulses_dm.GetDataAddrPtr(), edge_pulses_dm.edge_pulses_count);
        }


        difference_eop_index_ = {};
        double set_bit_time_span = 0;
        //////参数判断
        if (!CheckOptions(option, edge_pulses1, edge_pulses2, set_bit_time_span))
        {
            return false;
        }
        result_cells_ = {};
        result_events_ = {};
        usb_diff_unaligned_frames_index_ = {};

        //////处理差分逻辑
        if (option.sign_type == SignType::Diff)
        {
            if (!ParseDiffSignalData(edge_pulses1, edge_pulses2))
            {
                return false;
            }
        }
        else
        {
            if (edge_pulses1.size() < edge_pulses2.size())
            {
                sign_edge_pulse_ = std::move(edge_pulses2);
            }
            else
            {
                sign_edge_pulse_ = std::move(edge_pulses1);
            }
        }
        wave_max_time_index_len_ = sign_edge_pulse_[sign_edge_pulse_.size() - 1].end_index;
        //////处理单端逻辑
        if (option.auto_clock) set_bit_time_span = -1;
        if (ParseSingleData(set_bit_time_span, option.auto_clock))
        {
            result = {};
            result.decode_events_ptr = result_events_.data();
            result.decode_result_cells_ptr = result_cells_.data();
            result.decode_event_count = result_events_.size();
            result.decode_result_count = result_cells_.size();
            result.decode_result_need_update = !result_cells_.empty();
            result.decode_event_need_update = !result_events_.empty();
            result.usb_speed = usb_speed_;
            // WriteLog(LogLevel::LevelDebug, "Offset 1: %d" , offsetof(UsbDecodeEvent, PacketTitle));
            // WriteLog(LogLevel::LevelDebug, "Offset 2: %d" , offsetof(UsbDecodeEvent, FrameId));
            // WriteLog(LogLevel::LevelDebug, "Offset 2.5: %d" , offsetof(UsbDecodeEvent, EndPoint));
            // WriteLog(LogLevel::LevelDebug, "Offset 3: %d" , offsetof(UsbDecodeEvent, CrcSignNum));
            // WriteLog(LogLevel::LevelDebug, "Offset 3.5: %d" , offsetof(UsbDecodeEvent, CrcData));
            // WriteLog(LogLevel::LevelDebug, "Offset 4: %d" , offsetof(UsbDecodeEvent, DataCount));
            // WriteLog(LogLevel::LevelDebug, "Offset 5: %d" , offsetof(UsbDecodeEvent, DecodeDatasPtr));
            return true;
        }
        return false;
    }

    bool UsbDecoder::ParseSingleData(double set_bit_time_span, const bool auto_clock)
    {
        if (sign_edge_pulse_.empty()) return false;
        WriteLog(LogLevel::Level2, "ParseSingleData start");

        // 检查是否取消
        if (is_cancel_ptr_ != nullptr && *is_cancel_ptr_)
        {
            WriteLog(LogLevel::Level2, "AsyncFunction canceled");
            return false;
        }
        int32_t left_data_size = static_cast<int32_t>(sign_edge_pulse_.size());
        //找数据包
        if (FindPackets(left_data_size, usb_packets_, set_bit_time_span) && !usb_packets_.empty())
        {
            for (auto&& element : usb_packets_)
            {
                //resultData.Add(new UsbDecoderesultCell(element));
                result_events_.emplace_back(element);
                result_events_[result_events_.size() - 1].event_index = static_cast<int64_t>(result_events_.size());
            }
            WriteLog(LogLevel::Level2, "ParseSingleData done");
            return true;
        }
        if (usb_packets_.empty())
        {
            if (auto_clock)
            {
                sync_bit_len_ = USB_USB_SYNC_BIT_NORMAL_SPEED_LEN;
                usb_speed_ = UsbEnums::UsbSpeed::FULL_SPEED;
                left_data_size = static_cast<int32_t>(sign_edge_pulse_.size());
                set_bit_time_span = -1;
                FindPackets(left_data_size, usb_packets_, set_bit_time_span);
            }
            if (usb_packets_.empty())
            {
                WriteLog(LogLevel::Level2, "ParseSingleData false - Usb_packets is empty");
                return false;
            }
            else
            {
                for (auto&& element : usb_packets_)
                {
                    //resultData.Add(new UsbDecoderesultCell(element));
                    result_events_.emplace_back(element);
                    result_events_[result_events_.size() - 1].event_index = static_cast<int64_t>(result_events_.size());
                }
                WriteLog(LogLevel::Level2, "ParseSingleData done");
                return true;
            }
        }
        return false;
    }
    bool UsbDecoder::CheckTimeDifferenceWithinThreshold(const double* array, const int32_t size, double threshold)
    {
        for (int i = 2; i < size; i++)
        {
            const double difference = std::abs(array[i] - array[i - 1]);
            const double percentage_difference = difference / array[i - 1];
            if (difference < 50)
            {
                if (is_auto_clk_ || usb_speed_ == UsbEnums::UsbSpeed::HIGH_SPEED)
                {
                    threshold = USB_TIME_DIFFERENCE_THRESHOLD_HIGH_SPEED;
                }
                else
                {
                    threshold = USB_TIME_DIFFERENCE_THRESHOLD;
                }
            }

            if (percentage_difference > threshold)
            {
                return false; // 如果差异大于阈值，则返回 false
            }
        }

        return true; // 所有元素之间的差异都小于阈值
    }
    bool UsbDecoder::CheckTimeDifferenceWithinThreshold(const double* array, const int32_t size, const int32_t avg_span,
        double threshold)

    {
        for (int i = 2; i < size; i++)
        {
            //double absolute_difference = array[i] / avg_span;

            const double difference1 = std::abs(array[i] - avg_span);
            const double percentage_difference1 = difference1 / avg_span;

            const double difference2 = std::abs(array[i] - array[i - 1]);
            const double percentage_difference2 = difference2 / array[i - 1];
            if (difference2 < 50)
            {
                if (is_auto_clk_ || usb_speed_ == UsbEnums::UsbSpeed::HIGH_SPEED)
                {
                    threshold = USB_TIME_DIFFERENCE_THRESHOLD_HIGH_SPEED;
                }
                else
                {
                    threshold = USB_TIME_DIFFERENCE_THRESHOLD;
                }
            }

            if (percentage_difference1 > threshold && percentage_difference2 > threshold)
            {
                return false; // 如果差异大于阈值，则返回 false
            }
        }

        return true; // 所有元素之间的差异都小于阈值
    }

    void UsbDecoder::ClearEdgeArray(Edge* edges, const int32_t size)
    {
        for (int i = 0; i < size; ++i)
        {
            edges[i] = Edge::NONE;
        }
    }

    //检查同步域边沿
    bool UsbDecoder::CheckSyncEdges(const Edge start_edge, const Edge* edges)
    {
        return edges[0] != edges[1] && edges[0] == start_edge && edges[0] == edges[6];
    }

    //检查同步域在时域间隔
    bool UsbDecoder::CheckSyncSpans(const TwoLevelEdgePulse* node, const int32_t count, int32_t& avg_spans)
    {
        if (count < 1)
        {
            return false;
        }
        const auto start_indexs = new int32_t[count + 1];
        avg_spans = 0;
        if ((node - 1) != nullptr)
        {
            node--;
        }

        for (int i = count - 1; i >= 0; i--)
        {
            node--;
            if (node == nullptr)
            {
                return false;
            }
            start_indexs[i] = node->start_index;
        }
        return CheckSyncSpansByArray(start_indexs, count, avg_spans);
    }


    bool UsbDecoder::CheckSyncSpansByArray(const int32_t* start_indexs, const int32_t count,
        int32_t& avg_span)
    {
        if (count < 1)
        {
            return false;
        }

        const auto tmp_spans = new double[count - 1];
        for (int i = 1; i < count; i++)
        {
            tmp_spans[i - 1] = static_cast<double>(start_indexs[i] - start_indexs[i - 1]);
        }

        double total_spans = 0;
        for (int i = 0; i < count - 1; i++)
        {
            total_spans += std::abs(tmp_spans[2 + (i / 2)]);
        }
        avg_span = static_cast<int>(total_spans / (count - 1));
        //return CheckTimeDifferenceWithinThreshold(tmp_spans, count - 1, avg_span);
        return CheckTimeDifferenceWithinThreshold(tmp_spans, count - 1);
    }

    //bool UsbDecoder::GetPolarty(TwoLevelEdgePulse* node, double set_bit_time_span, int& last_valid_data_index)
    bool UsbDecoder::GetPolarty(TwoLevelEdgePulse* node, const double set_bit_time_span)
    {
        TwoLevelEdgePulse* max_length_node = new TwoLevelEdgePulse();
        double time_length_threshold = 0;
        //last_valid_data_index = -1;

        if (node->start_index > 0)
        {
            max_length_node->start_index = 0;
            max_length_node->end_index = node->start_index;
            max_length_node->current_level = node->current_level == TwoLevelEdgePulseStatusType::Low
                ? TwoLevelEdgePulseStatusType::High
                : TwoLevelEdgePulseStatusType::Low;
        }
        else
        {
            max_length_node = node;
        }

        if (set_bit_time_span > 0)
        {
            time_length_threshold = USB_USB_SYNC_BIT_MAX_LEN * set_bit_time_span;
        }
        while (node != nullptr)
        {
            if (is_cancel_ptr_ != nullptr && *is_cancel_ptr_)
            {
                WriteLog(LogLevel::Level2, "AsyncFunction canceled");
                return false;
            }
            const int32_t node_len = node->GetLength();
            if ((max_length_node->GetLength() < node_len) || (time_length_threshold > 0 && node_len > time_length_threshold))
            {
                max_length_node = node;
            }
            /*if ((time_length_threshold > 0 && node_len > time_length_threshold) || node_len >= max_length_node->GetLength())
            {
                last_valid_data_index = node->startIndex;
            }
            else
            {
                last_valid_data_index = node->endIndex;
            }*/

            node++;
            if (node->start_index < 0 || node->end_index < 0
                || node->start_index > node->end_index || node->LevelCount() <= 0)
            {
                WriteLog(LogLevel::LevelDebug, "GetPolarty break");
                break;
            }
        }

        return max_length_node->current_level == TwoLevelEdgePulseStatusType::Low;
    }

    // bool UsbDecoder::FindAllSyncs(TwoLevelEdgePulse* node, std::vector<SYNC>& all_sync
    //                               , double set_bit_time_span,bool force_normal_speed, bool polarity)
    bool UsbDecoder::FindAllSyncs(TwoLevelEdgePulse* node, std::vector<Sync>& all_sync
        , const double set_bit_time_span, const bool polarity, int32_t& last_valid_data_index)
    {
        all_sync.clear();
        int first_avg_span = 0;
        last_valid_data_index = -1;
        if (node == nullptr || node - 1 == nullptr)
        {
            return false;
        }
        // if (force_normal_speed)
        // {
        //     syncBitLen_ = Usb_Usb_SYNC_BIT_NORMAL_SPEED_LEN;
        // }
        const Edge next_edge = polarity ? Edge::RISE : Edge::FALL;
        const Edge start_edge = next_edge;

        TwoLevelEdgePulse* start_info_node = nullptr;
        Edge tmp_edges[USB_USB_SYNC_BIT_MAX_LEN];
        TwoLevelEdgePulse* tmp_edges_ptr[USB_USB_SYNC_BIT_MAX_LEN];
        int32_t tmp_edges_len[USB_USB_SYNC_BIT_MAX_LEN];
        ClearEdgeArray(tmp_edges, sync_bit_len_);

        int tmp_edge_count = 0;
        TwoLevelEdgePulse* tmp_node = node;

        while (tmp_node != nullptr)
        {
            if (is_cancel_ptr_ != nullptr && *is_cancel_ptr_)
            {
                WriteLog(LogLevel::Level2, "AsyncFunction canceled");
                return false;
            }
            if (tmp_node->start_index < 0 || tmp_node->end_index < 0
                || tmp_node->start_index > tmp_node->end_index || tmp_node->LevelCount() <= 0)
            {
                WriteLog(LogLevel::Level2, "FindAllSyncs break,SYNC count:%d", all_sync.size());
                break;
            }
            //可能找到目标头
            if (first_avg_span != 0 && tmp_node->GetLength() > first_avg_span * USB_IDLE_MIN_BIT_LEN)
            {
                tmp_edge_count = 0;
                if (tmp_node->start_index > 0)
                {
                    last_valid_data_index = tmp_node->start_index;
                }
            }

            if (tmp_edge_count <= sync_bit_len_ - 1)
            {
                if (tmp_edge_count == 0)
                {
                    start_info_node = tmp_node;
                }

                tmp_edges[tmp_edge_count] = tmp_node->edge;
                tmp_edges_ptr[tmp_edge_count] = tmp_node;
                tmp_edges_len[tmp_edge_count] = tmp_node->GetLength();
                tmp_edge_count++;
            }
            else
            {
                if (CheckSyncEdges(start_edge, tmp_edges))
                {
                    int avg_spans;
                    if (CheckSyncSpans(tmp_node, sync_bit_len_ - 1, avg_spans))
                    {
                        if (all_sync.empty())
                        {
                            int32_t set_bit_span = static_cast<int>(set_bit_time_span);

                            first_avg_span = set_bit_span >= 0 ? set_bit_span : avg_spans;
                            all_sync.emplace_back(start_info_node, (tmp_node - 2)->start_index + first_avg_span,
                                first_avg_span, usb_speed_ == UsbEnums::UsbSpeed::HIGH_SPEED);
                        }
                        else if (start_info_node != nullptr && (start_info_node - 1) != nullptr && (start_info_node - 1)->
                            GetLength() > first_avg_span * sync_bit_len_)
                        {
                            int32_t set_bit_span = static_cast<int>(set_bit_time_span);
                            avg_spans = set_bit_span >= 0 ? set_bit_span : avg_spans;
                            all_sync.emplace_back(start_info_node, (tmp_node - 2)->start_index + avg_spans,
                                avg_spans, usb_speed_ == UsbEnums::UsbSpeed::HIGH_SPEED);
                        }

                        ClearEdgeArray(tmp_edges, sync_bit_len_);
                        tmp_edge_count = 0;
                        tmp_node++;
                        //left_over_size--;
                        continue;
                    }
                }

                for (int i = 0; i < sync_bit_len_ - 1; i++)
                {
                    tmp_edges[i] = tmp_edges[i + 1];
                    tmp_edges_ptr[i] = tmp_edges_ptr[i + 1];
                    tmp_edges_len[i] = tmp_edges_len[i + 1];
                }

                tmp_edges[sync_bit_len_ - 1] = tmp_node->edge;
                tmp_edges_ptr[sync_bit_len_ - 1] = tmp_node;
                tmp_edges_len[sync_bit_len_ - 1] = tmp_node->GetLength();
                start_info_node++;
            }

            tmp_node++;
            //left_over_size--;
        }

        return !all_sync.empty();
    }


    bool UsbDecoder::FindPackets(int32_t& left_over_size,
        std::vector<UsbPacket>& all_packet, const double set_bit_time_span)
    {
        TwoLevelEdgePulse* node = sign_edge_pulse_.data();
        all_packet.clear();
        std::vector<Sync> all_sync;
        //int last_valid_data_index = -1;
        //bool polarity = GetPolarty(node, set_bit_time_span, last_valid_data_index);
        const bool polarity = GetPolarty(node, set_bit_time_span);
        int32_t last_valid_data_index = -1;
        //找的全部同步帧
        if (!FindAllSyncs(node, all_sync, set_bit_time_span, polarity, last_valid_data_index) || all_sync.empty())
        {
            return false;
        }

        for (const auto& sync : all_sync)
        {
            if (sync.node_ptr == nullptr)
            {
                continue;
            }
            if (is_cancel_ptr_ != nullptr && *is_cancel_ptr_)
            {
                WriteLog(LogLevel::Level2, "AsyncFunction canceled");
                return false;
            }
            TwoLevelEdgePulse* tmp_node = sync.node_ptr;

            int32_t eop_index = -1;
            //有差分Eop情况
            if (!difference_eop_index_.empty() && difference_eop_index_.size() > all_packet.size())
            {
                eop_index = difference_eop_index_[all_packet.size()];
            }
            if (eop_index <= 0)
            {
                //如果存在后续同步帧，用下个同步帧头-1的起始做可能结束 
                if (static_cast<int32_t>(all_sync.size()) > static_cast<int32_t>(all_packet.size() + 2))
                {
                    const TwoLevelEdgePulse* tmp_node = (all_sync[all_packet.size() + 1].node_ptr - 1);
                    if (set_bit_time_span > 0 && tmp_node->GetLength() > USB_BYTE_BIT_COUNT * set_bit_time_span)
                    {
                        eop_index = tmp_node->start_index;
                    }
                    else
                    {
                        eop_index = (all_sync[all_packet.size() + 2].node_ptr - 1)->start_index;
                    }
                }
                else
                {
                    if (last_valid_data_index > 0 && last_valid_data_index < wave_max_time_index_len_)
                    {
                        eop_index = last_valid_data_index;
                    }
                    else
                    {
                        eop_index = wave_max_time_index_len_;
                    }
                }
            }
            const int32_t packetMaxTimeLen = eop_index - sync.node_ptr->start_index;
            if (packetMaxTimeLen <= 0)
            {
                WriteLog(LogLevel::Level2, "FindPackets Warning: packetMaxTimeLen <= 0");
            }
            UsbPacket packet(tmp_node, left_over_size, sync, polarity, packetMaxTimeLen);
            if (packet.IsValid())
            {
                all_packet.push_back(packet);
            }
        }

        return true;
    }
    bool UsbDecoder::CheckOptions(UsbDecodeOptions option, const std::vector<TwoLevelEdgePulse>& edge_pulses_dp,
        const std::vector<TwoLevelEdgePulse>& edge_pulses_dm, double& set_bit_time_span)
    {
        double usb_speed;
        usb_speed_ = option.usb_speed;
        switch (option.usb_speed)
        {
        case UsbEnums::UsbSpeed::LOW_SPEED:
            usb_speed = USB_LOW_SPEED_MHZ;
            sync_bit_len_ = USB_USB_SYNC_BIT_NORMAL_SPEED_LEN;
            break;
        case UsbEnums::UsbSpeed::FULL_SPEED:
            usb_speed = USB_FULL_SPEED_MHZ;
            sync_bit_len_ = USB_USB_SYNC_BIT_NORMAL_SPEED_LEN;
            break;
        case UsbEnums::UsbSpeed::HIGH_SPEED:
            usb_speed = USB_HIGH_SPEED_MHZ;
            sync_bit_len_ = USB_USB_SYNC_BIT_HIGH_SPEED_LEN;
            break;
        default:
            WriteLog(LogLevel::Level2, "CheckOptions Failed, UsbSpeed error");
            return false;
        }
        is_auto_clk_ = option.auto_clock;
        if (!is_auto_clk_ && option.sampling_frequency < usb_speed * 2)
        {
            WriteLog(LogLevel::Level2, "CheckOptions Failed, samplingFrequency error");
            return false;
        }

        if (!is_auto_clk_)
        {
            sync_bit_len_ = USB_USB_SYNC_BIT_MAX_LEN;
        }
        if (option.sign_type == SignType::SingleEnded)
        {
            WriteLog(LogLevel::Level2, "CheckOptions SignType:%d", static_cast<int>(option.sign_type));
            if (edge_pulses_dp.size() < USB_MINIMUM_SEQUENCE_LENGTH && edge_pulses_dm.size() < USB_MINIMUM_SEQUENCE_LENGTH)
            {
                WriteLog(LogLevel::Level2, "CheckOptions Failed, edgePulses.size too short");
                return false;
            }
        }
        else
        {
            const auto edge_pulses_size1 = static_cast<double>(edge_pulses_dp.size());
            const auto edge_pulses_size2 = static_cast<double>(edge_pulses_dm.size());
            //// 差分长度判断
            if (!DataCheckHelper::CheckDoubleIsEqual(edge_pulses_size1, edge_pulses_size2)
                && ((USB_DIFF_LEN_DIFFERENCE_THRESHOLD * edge_pulses_size1) > edge_pulses_size2
                    || (USB_DIFF_LEN_DIFFERENCE_THRESHOLD * edge_pulses_size2) > edge_pulses_size1))
            {
                WriteLog(LogLevel::Level2, "CheckOptions Failed,diff edgePulses size is not equal");
                return false;
            }

            if (edge_pulses_dp.size() < USB_MINIMUM_SEQUENCE_LENGTH)
            {
                WriteLog(LogLevel::Level2, "CheckOptions Failed, edgePulses size too short");
                return false;
            }

            usb_diff_signal_real_edges_count_ = static_cast<int32_t>(edge_pulses_dp.size() > edge_pulses_dm.size()
                ? edge_pulses_dm.size()
                : edge_pulses_dp.size());
        }
        set_bit_time_span = option.sampling_frequency / (usb_speed * 1000000);
        return true;
    }
}