pkt_buffer.h

// Copyright 2021-2025 The Aerospace Corporation.
// This file is a part of SatCat5, licensed under CERN-OHL-W v2 or later.
// Multipurpose circular buffer
//
 
#pragma once
 
#include <satcat5/io_core.h>
#include <satcat5/io_counter.h>
#include <satcat5/types.h>
 
// Default size is large enough for one full-size Ethernet frame + metadata.
#ifndef SATCAT5_DEFAULT_PKTBUFF
#define SATCAT5_DEFAULT_PKTBUFF     1600    // Buffer size in bytes
#endif
 
namespace satcat5 {
    namespace io {
        class PacketBuffer
            : public satcat5::io::Writeable
            , public satcat5::io::Readable
            , public satcat5::io::Counter
        {
        public:
            constexpr PacketBuffer(void* buff, unsigned nbytes, unsigned max_pkt=0)
                : m_buff(static_cast<u8*>(buff) + 2*max_pkt)
                , m_buff_size((buff && nbytes >= 2*max_pkt) ? (nbytes - 2*max_pkt) : 0)
                , m_buff_rdidx(0)
                , m_buff_rdcount(0)
                , m_pkt_lbuff(static_cast<u16*>(buff))
                , m_pkt_maxct(max_pkt)
                , m_pkt_rdidx(0)
                , m_total_bytes(0)
                , m_total_frames(0)
                , m_next_wrpos(0)
                , m_next_wrlen(0)
                , m_shared_rdavail(0)
                , m_shared_pktcount(0)
                {} // No further initialization required
 
            void clear();
 
            // Implement the io::Countable API.
            unsigned byte_count(bool reset = true) override;
            unsigned frame_count(bool reset = true) override;
 
            u8 get_percent_full() const;
 
            unsigned get_write_partial() const;
 
            // io::Writeable function implementations.
            unsigned get_write_space() const override;
            void write_bytes(unsigned nbytes, const void* src) override;
            void write_abort() override;
            bool write_finalize() override;
 
            void zcw_write(unsigned nbytes);
            unsigned zcw_maxlen() const; 
            u8* zcw_start(); 
 
            // io::Readable function implementations.
            unsigned get_read_ready() const override;
            bool read_bytes(unsigned nbytes, void* dst) override;
            bool read_consume(unsigned nbytes) override;
            void read_finalize() override;
 
            const u8* peek(unsigned nbytes) const;
 
            unsigned get_peek_ready() const;
 
            inline u8* get_buff_dtor() const {return (u8*)m_pkt_lbuff;}
            inline unsigned get_buff_size() const {return m_buff_size;}
 
        protected:
            // Internal functions required for Writeable and Readable APIs.
            void write_next(u8 data) override;
            void write_overflow() override;
            u8 read_next() override;
            bool can_read_internal(unsigned nbytes) const;
            void consume_internal(unsigned nbytes);
 
        private:
            u8* const m_buff;               // Pointer to backing array
            const unsigned m_buff_size;     // Size of backing array
            unsigned m_buff_rdidx;          // Current read position
            unsigned m_buff_rdcount;        // Count consumed bytes
 
            u16* const m_pkt_lbuff;         // Pointer to backing array
            const unsigned m_pkt_maxct;     // Size of backing array
            unsigned m_pkt_rdidx;           // Current read position
 
            unsigned m_total_bytes;
            unsigned m_total_frames;
 
            unsigned m_next_wrpos;          // Base position for writes
            unsigned m_next_wrlen;          // Working packet length
 
            volatile unsigned m_shared_rdavail;
            volatile unsigned m_shared_pktcount;
        };
 
        template<unsigned SIZE = SATCAT5_DEFAULT_PKTBUFF>
        class PacketBufferStatic final : public satcat5::io::PacketBuffer {
        public:
            explicit PacketBufferStatic(unsigned max_pkt = 32)
                : PacketBuffer(m_raw, SIZE, max_pkt), m_raw{} {}
        private:
            u8 m_raw[SIZE];
        };
 
        template<unsigned SIZE = SATCAT5_DEFAULT_PKTBUFF>
        class StreamBufferStatic final : public satcat5::io::PacketBuffer {
        public:
            StreamBufferStatic()
                : PacketBuffer(m_raw, SIZE, 0), m_raw{} {}
        private:
            u8 m_raw[SIZE];
        };
    }
}