pyxcp 0.21.10__cp39-cp39-win_amd64.whl → 0.22.23__cp39-cp39-win_amd64.whl

pyxcp/recorder/reader.hpp

@@ -0,0 +1,139 @@
+
+#ifndef RECORDER_READER_HPP
+#define RECORDER_READER_HPP
+
+#include <iostream>
+
+class XcpLogFileReader {
+   public:
+
+    explicit XcpLogFileReader(const std::string &file_name) {
+        if (!file_name.ends_with(detail::FILE_EXTENSION)) {
+            m_file_name = file_name + detail::FILE_EXTENSION;
+        } else {
+            m_file_name = file_name;
+        }
+
+        m_mmap = new mio::mmap_source(m_file_name);
+        blob_t magic[detail::MAGIC_SIZE + 1];
+
+        read_bytes(0UL, detail::MAGIC_SIZE, magic);
+        if (memcmp(detail::MAGIC.c_str(), magic, detail::MAGIC_SIZE) != 0) {
+            throw std::runtime_error("Invalid file magic.");
+        }
+        m_offset = detail::MAGIC_SIZE;
+
+        read_bytes(m_offset, detail::FILE_HEADER_SIZE, reinterpret_cast<blob_t *>(&m_header));
+        // printf("Sizes: %u %u %.3f\n", m_header.size_uncompressed,
+        //        m_header.size_compressed,
+        //        float(m_header.size_uncompressed) / float(m_header.size_compressed));
+        if (m_header.hdr_size != detail::FILE_HEADER_SIZE + detail::MAGIC_SIZE) {
+            throw std::runtime_error("File header size does not match.");
+        }
+        if (detail::VERSION != m_header.version) {
+            throw std::runtime_error("File version mismatch.");
+        }
+#if 0
+        if (m_header.num_containers < 1) {
+            throw std::runtime_error("At least one container required.");
+        }
+#endif
+        m_offset += detail::FILE_HEADER_SIZE;
+
+        if ((m_header.options & XMRAW_HAS_METADATA) == XMRAW_HAS_METADATA) {
+            std::size_t metadata_length = 0;
+            std::size_t data_start      = m_offset + sizeof(std::size_t);
+
+            read_bytes(m_offset, sizeof(std::size_t), reinterpret_cast<blob_t *>(&metadata_length));
+
+            std::copy(ptr(data_start), ptr(data_start + metadata_length), std::back_inserter(m_metadata));
+            // std::cout << "Metadata: " << m_metadata << std::endl;
+            m_offset += (metadata_length + sizeof(std::size_t));
+        }
+    }
+
+    [[nodiscard]] FileHeaderType get_header() const noexcept {
+        return m_header;
+    }
+
+    [[nodiscard]] auto get_header_as_tuple() const noexcept -> HeaderTuple {
+        auto hdr = get_header();
+
+        return std::make_tuple(
+            hdr.version, hdr.options, hdr.num_containers, hdr.record_count, hdr.size_uncompressed, hdr.size_compressed,
+            (double)((std::uint64_t)(((double)hdr.size_uncompressed / (double)hdr.size_compressed * 100.0) + 0.5)) / 100.0
+        );
+    }
+
+    [[nodiscard]] auto get_metadata() const noexcept {
+        return m_metadata;
+    }
+
+    void reset() noexcept {
+        m_current_container = 0;
+        m_offset            = file_header_size();
+    }
+
+    std::optional<FrameVector> next_block() {
+        auto          container = ContainerHeaderType{};
+        auto          frame     = frame_header_t{};
+        std::uint64_t boffs     = 0;
+        auto          result    = FrameVector{};
+        payload_t     payload;
+
+        if (m_current_container >= m_header.num_containers) {
+            return std::nullopt;
+        }
+        read_bytes(m_offset, detail::CONTAINER_SIZE, reinterpret_cast<blob_t *>(&container));
+        __ALIGN auto buffer = new blob_t[container.size_uncompressed];
+        m_offset += detail::CONTAINER_SIZE;
+        result.reserve(container.record_count);
+        const int uc_size = ::LZ4_decompress_safe(
+            reinterpret_cast<char const *>(ptr(m_offset)), reinterpret_cast<char *>(buffer), container.size_compressed,
+            container.size_uncompressed
+        );
+        if (uc_size < 0) {
+            throw std::runtime_error("LZ4 decompression failed.");
+        }
+        boffs = 0;
+        for (std::uint64_t idx = 0; idx < container.record_count; ++idx) {
+            _fcopy(reinterpret_cast<char *>(&frame), reinterpret_cast<char const *>(&(buffer[boffs])), sizeof(frame_header_t));
+            boffs += sizeof(frame_header_t);
+            result.emplace_back(
+                frame.category, frame.counter, frame.timestamp, frame.length, create_payload(frame.length, &buffer[boffs])
+            );
+            boffs += frame.length;
+        }
+        m_offset += container.size_compressed;
+        m_current_container += 1;
+        delete[] buffer;
+
+        return std::optional<FrameVector>{ result };
+    }
+
+    ~XcpLogFileReader() noexcept {
+        delete m_mmap;
+    }
+
+   protected:
+
+    [[nodiscard]] blob_t const *ptr(std::uint64_t pos = 0) const {
+        return reinterpret_cast<blob_t const *>(m_mmap->data() + pos);
+    }
+
+    void read_bytes(std::uint64_t pos, std::uint64_t count, blob_t *buf) const {
+        auto addr = reinterpret_cast<char const *>(ptr(pos));
+        _fcopy(reinterpret_cast<char *>(buf), addr, count);
+    }
+
+   private:
+
+    std::string       m_file_name;
+    std::uint64_t     m_offset{ 0 };
+    std::uint64_t     m_current_container{ 0 };
+    mio::mmap_source *m_mmap{ nullptr };
+    FileHeaderType    m_header;
+    std::string       m_metadata;
+};
+
+#endif  // RECORDER_READER_HPP

pyxcp/recorder/reco.py

@@ -1,5 +1,4 @@
 #!/usr/bin/env python
-# -*- coding: utf-8 -*-
 """Raw XCP traffic recorder.
 
 Data is stored in LZ4 compressed containers.
@@ -15,8 +14,6 @@ See
 """
 import enum
 import mmap
-import os
-import pathlib
 import struct
 from collections import namedtuple
 
@@ -27,7 +24,7 @@ FILE_EXTENSION = ".xmraw"  # XCP Measurement / raw data.
 
 MAGIC = b"ASAMINT::XCP_RAW"
 
-FILE_HEADER_STRUCT = struct.Struct("<{:d}sHHHLLLL".format(len(MAGIC)))
+FILE_HEADER_STRUCT = struct.Struct(f"<{len(MAGIC):d}sHHHLLLL")
 FileHeader = namedtuple(
     "FileHeader",
     "magic hdr_size version options num_containers record_count size_compressed size_uncompressed",
@@ -82,7 +79,7 @@ class XcpLogFileWriter:
     ):
         self._is_closed = True
         try:
-            self._of = open("{}{}".format(file_name, FILE_EXTENSION), "w+b")
+            self._of = open(f"{file_name}{FILE_EXTENSION}", "w+b")
         except Exception:
             raise
         else:
@@ -161,7 +158,7 @@ class XcpLogFileWriter:
         try:
             self._mapping[address : address + length] = data
         except IndexError:
-            raise XcpLogFileCapacityExceededError("Maximum file size of {} MBytes exceeded.".format(self.prealloc)) from None
+            raise XcpLogFileCapacityExceededError(f"Maximum file size of {self.prealloc} MBytes exceeded.") from None
 
     def _write_header(
         self,
@@ -201,7 +198,7 @@ class XcpLogFileReader:
     def __init__(self, file_name):
         self._is_closed = True
         try:
-            self._log_file = open("{}{}".format(file_name, FILE_EXTENSION), "r+b")
+            self._log_file = open(f"{file_name}{FILE_EXTENSION}", "r+b")
         except Exception:
             raise
         else:
@@ -218,7 +215,7 @@ class XcpLogFileReader:
             self.total_size_uncompressed,
         ) = FILE_HEADER_STRUCT.unpack(self.get(0, FILE_HEADER_STRUCT.size))
         if magic != MAGIC:
-            raise XcpLogFileParseError("Invalid file magic: '{}'.".format(magic))
+            raise XcpLogFileParseError(f"Invalid file magic: {magic!r}.")
 
     def __del__(self):
         if not self._is_closed:

pyxcp/recorder/rekorder.cpp

@@ -3,28 +3,24 @@
 
 #include "rekorder.hpp"
 
-
-void some_records(XcpLogFileWriter& writer)
-{
-    const auto COUNT = 1024 * 100 * 5;
-    unsigned filler = 0x00;
-    char buffer[1024];
+void some_records(XcpLogFileWriter& writer) {
+    const auto COUNT  = 1024 * 100 * 5;
+    unsigned   filler = 0x00;
+    char       buffer[1024];
 
     for (auto idx = 0; idx < COUNT; ++idx) {
-        auto fr = frame_header_t{};
-        fr.category = 1;
-        fr.counter = idx;
+        auto fr      = frame_header_t{};
+        fr.category  = 1;
+        fr.counter   = idx;
         fr.timestamp = std::clock();
-        fr.length = 10 + (rand() % 240);
-        filler = (filler + 1) % 16;
+        fr.length    = 10 + (rand() % 240);
+        filler       = (filler + 1) % 16;
         memset(buffer, filler, fr.length);
-        writer.add_frame(fr.category, fr.counter, fr.timestamp, fr.length, std::bit_cast<char const*>(&buffer));
+        writer.add_frame(fr.category, fr.counter, fr.timestamp, fr.length, std::bit_cast<char const *>(&buffer));
     }
 }
 
-
-int main()
-{
+int main() {
     srand(42);
 
     printf("\nWRITER\n");
@@ -49,15 +45,15 @@ int main()
     printf("size/uncompressed:  %u\n", header.size_uncompressed);
     printf("compression ratio:  %.2f\n", static_cast<float>(header.size_uncompressed) / static_cast<float>(header.size_compressed));
 
-	while (true) {
-		const auto& frames = reader.next_block();
-	    if (!frames) {
-	        break;
-	    }
-        for (const auto& frame: frames.value()) {
+    while (true) {
+        const auto& frames = reader.next_block();
+        if (!frames) {
+            break;
+        }
+        for (const auto& frame : frames.value()) {
             auto const& [category, counter, timestamp, length, payload] = frame;
         }
-	}
+    }
     printf("---\n");
     printf("Finished.\n");
 }