QRTP — QR Transport Protocol

export function parseQrtpFrameHeader(data) {
    const pkt = new Uint8Array(data);
    if (pkt.length < 4 || pkt[0] !== 0x71 || pkt[1] !== 0) return null;

    const tw = pkt[2] | (pkt[3] << 8);
    const transferId = tw & 0x7fff;
    const isSqueezed = (tw & 0x8000) !== 0;

    if (isSqueezed) {
        if (pkt.length < 8) return null;
        const src = (pkt[4] | (pkt[5] << 8) | (pkt[6] << 16) | (pkt[7] << 24)) >>> 0;
        const payloadLen = pkt.length - 8;
        const pktSz = payloadLen >= 368 ? 368 : 40;
        const count = Math.floor(payloadLen / pktSz);
        
        return {
            transferId,
            squeezed: true,
            payloadOffset: 8,
            streams: [{
                streamType: 0,
                streamId: 0,
                packetCount: count,
                packetSizeBytes: pktSz,
                sourceTotalBytes: src
            }]
        };
    }

    let offset = 4;
    const streams = [];
    while (offset + 8 <= pkt.length) {
        const stRaw = pkt[offset];
        const streamId = pkt[offset + 1];
        const packetCount = pkt[offset + 2];
        const pw = pkt[offset + 3];
        const src = (pkt[offset+4] | (pkt[offset+5] << 8) | (pkt[offset+6] << 16) | (pkt[offset+7] << 24)) >>> 0;
        
        streams.push({
            streamType: stRaw & 0x7f,
            streamId,
            packetCount,
            packetSizeBytes: pw * 8,
            sourceTotalBytes: src
        });
        offset += 8;
        if ((stRaw & 0x80) !== 0) break;
    }
    return { transferId, squeezed: false, streams, payloadOffset: offset };
}

import struct

def parse_qrtp_frame_header(data: bytes):
    if len(data) < 4 or data[0:2] != b'q\x00':
        return None

    tw = struct.unpack_from('<H', data, 2)[0]
    transfer_id = tw & 0x7fff
    is_squeezed = bool(tw & 0x8000)

    if is_squeezed:
        if len(data) < 8:
            return None
        src = struct.unpack_from('<I', data, 4)[0]
        payload_len = len(data) - 8
        pkt_size = 368 if payload_len >= 368 else 40
        count = payload_len // pkt_size
        return {
            'transfer_id': transfer_id,
            'squeezed': True,
            'payload_offset': 8,
            'streams': [{
                'stream_type': 0, 'stream_id': 0, 'packet_count': count,
                'packet_size': pkt_size, 'source_total_bytes': src
            }]
        }

    offset = 4
    streams = []
    while offset + 8 <= len(data):
        st_raw, stream_id, packet_count, pw = struct.unpack_from('<BBBB', data, offset)
        src = struct.unpack_from('<I', data, offset + 4)[0]
        
        streams.append({
            'stream_type': st_raw & 0x7f,
            'stream_id': stream_id,
            'packet_count': packet_count,
            'packet_size': pw * 8,
            'source_total_bytes': src
        })
        offset += 8
        if st_raw & 0x80:
            break
            
    return {'transfer_id': transfer_id, 'squeezed': False, 'streams': streams, 'payload_offset': offset}

package qrtp

import (
	"encoding/binary"
	"errors"
)

type StreamInfo struct {
	StreamType       uint8
	StreamID         uint8
	PacketCount      uint8
	PacketSize       int
	SourceTotalBytes uint32
}

func ParseQrtpFrameHeader(data []byte) ([]StreamInfo, uint16, int, error) {
	if len(data) < 4 || data[0] != 'q' || data[1] != 0 {
		return nil, 0, 0, errors.New("invalid protocol header marker")
	}

	tw := binary.LittleEndian.Uint16(data[2:4])
	transferID := tw & 0x7fff
	isSqueezed := (tw & 0x8000) != 0

	if isSqueezed {
		if len(data) < 8 {
			return nil, 0, 0, errors.New("truncated squeezed metadata")
		}
		src := binary.LittleEndian.Uint32(data[4:8])
		payloadLen := len(data) - 8
		pktSize := 40
		if payloadLen >= 368 {
			pktSize = 368
		}
		count := payloadLen / pktSize
		return []StreamInfo{{
			StreamType:       0,
			StreamID:         0,
			PacketCount:      uint8(count),
			PacketSize:       pktSize,
			SourceTotalBytes: src,
		}}, transferID, 8, nil
	}

	offset := 4
	var streams []StreamInfo
	for offset+8 <= len(data) {
		stRaw := data[offset]
		src := binary.LittleEndian.Uint32(data[offset+4 : offset+8])
		
		streams = append(streams, StreamInfo{
			StreamType:       stRaw & 0x7f,
			StreamID:         data[offset+1],
			PacketCount:      data[offset+2],
			PacketSize:       int(data[offset+3]) * 8,
			SourceTotalBytes: src,
		})
		offset += 8
		if stRaw&0x80 != 0 {
			break
		}
	}
	return streams, transferID, offset, nil
}

export function processPayloadPackets(pkt, streams, startOffset) {
    let offset = startOffset;
    for (const stream of streams) {
        const pktSize = stream.packetSizeBytes;
        const srcTotal = stream.sourceTotalBytes;
        
        for (let i = 0; i < stream.packetCount; i++) {
            if (offset + pktSize > pkt.length) break;
            const packetBuffer = pkt.slice(offset, offset + pktSize);
            
            const useWirehair = pktSize <= srcTotal;
            if (useWirehair && pktSize >= 12) {
                const blockId = new DataView(packetBuffer.buffer, packetBuffer.byteOffset, packetBuffer.byteLength).getUint32(0, true);
                const payload = packetBuffer.slice(4);
                // processWirehairBlock(blockId, payload);
            } else {
                const validLen = Math.min(pktSize, srcTotal);
                const directData = packetBuffer.slice(0, validLen);
                // processDirectBlock(directData);
            }
            offset += pktSize;
        }
    }
}

def process_payload_packets(data: bytes, streams: list, start_offset: int):
    offset = start_offset
    for stream in streams:
        pkt_sz = stream['packet_size']
        src_total = stream['source_total_bytes']
        
        for _ in range(stream['packet_count']):
            if offset + pkt_sz > len(data):
                break
            pkt = data[offset : offset + pkt_sz]
            
            use_wirehair = pkt_sz <= src_total
            if use_wirehair and pkt_sz >= 12:
                block_id = struct.unpack_from('<I', pkt, 0)[0]
                payload = pkt[4:]
                # feed_wirehair_decoder(block_id, payload)
            else:
                valid_len = min(pkt_sz, src_total)
                direct_data = pkt[:valid_len]
                # process_direct_data(direct_data)
            offset += pkt_sz

func ProcessPayloadPackets(data []byte, streams []StreamInfo, startOffset int) {
	offset := startOffset
	for _, stream := range streams {
		pktSz := stream.PacketSize
		srcTotal := int(stream.SourceTotalBytes)
		
		for i := 0; i < int(stream.PacketCount); i++ {
			if offset+pktSz > len(data) {
				break
			}
			pkt := data[offset : offset+pktSz]
			
			useWirehair := pktSz <= srcTotal
			if useWirehair && pktSz >= 12 {
				blockID := binary.LittleEndian.Uint32(pkt[:4])
				payload := pkt[4:]
				// ingestWirehair(blockID, payload)
				_, _ = blockID, payload
			} else {
				validLen := pktSz
				if srcTotal < validLen {
					validLen = srcTotal
				}
				directData := pkt[:validLen]
				_ = directData
			}
			offset += pktSz
		}
	}
}

export function createQrtpFrame(transferId, streams, packetsPayloads) {
    const buffers = [];
    
    // Check squeezed criteria optimization
    if (streams.len === 1 && streams[0].streamId === 0 && (streams[0].packetSizeBytes === 368 || streams[0].packetSizeBytes === 40)) {
        const markerAndId = new Uint8Array(4);
        markerAndId[0] = 0x71; markerAndId[1] = 0x00;
        const tw = (transferId & 0x7fff) | 0x8000;
        markerAndId[2] = tw & 0xff; markerAndId[3] = (tw >> 8) & 0xff;
        buffers.push(markerAndId);

        const srcBuf = new Uint8Array(4);
        const src = streams[0].sourceTotalBytes;
        srcBuf[0] = src & 0xff; srcBuf[1] = (src >> 8) & 0xff;
        srcBuf[2] = (src >> 16) & 0xff; srcBuf[3] = (src >> 24) & 0xff;
        buffers.push(srcBuf);
        
        for (const pkt of packetsPayloads) buffers.push(pkt);
        return mergeBuffers(buffers);
    }

    const header = new bytearray([0x71, 0x00, transferId & 0xff, (transferId >> 8) & 0x7f]);
    buffers.push(header);

    for (let i = 0; i < streams.length; i++) {
        const s = streams[i];
        const isLast = i === streams.length - 1;
        const stByte = isLast ? (s.streamType | 0x80) : s.streamType;
        const sHeader = new Uint8Array(8);
        sHeader[0] = stByte; sHeader[1] = s.streamId; sHeader[2] = s.packetCount; sHeader[3] = Math.floor(s.packetSizeBytes / 8);
        sHeader[4] = s.sourceTotalBytes & 0xff; sHeader[5] = (s.sourceTotalBytes >> 8) & 0xff;
        sHeader[6] = (s.sourceTotalBytes >> 16) & 0xff; sHeader[7] = (s.sourceTotalBytes >> 24) & 0xff;
        buffers.push(sHeader);
    }

    for (const pkt of packetsPayloads) buffers.push(pkt);
    return mergeBuffers(buffers);
}

 Gentile function helper to simplify buffer array composition
function mergeBuffers(arr) {
    let total = arr.reduce((acc, b) => acc + b.length, 0);
    let out = new Uint8Array(total), offset = 0;
    for (const b of arr) { out.set(b, offset); offset += b.length; }
    return out;
}

def create_qrtp_frame(transfer_id, streams, packets_payloads):
    buf = bytearray(b'q\x00')

    # Optimization path validation for squeezed targets
    if len(streams) == 1 and streams[0]['stream_id'] == 0 and streams[0]['packet_size'] in (368, 40):
        buf += struct.pack('<HI', (transfer_id & 0x7fff) | 0x8000, streams[0]['source_total_bytes'])
        for pkt in packets_payloads:
            buf += pkt
        return bytes(buf)

    # Standard full layout execution flow
    buf += struct.pack('<H', transfer_id & 0x7fff)
    for i, stream in enumerate(streams):
        is_last = (i == len(streams) - 1)
        st_byte = (stream['stream_type'] | 0x80) if is_last else stream['stream_type']
        
        buf += struct.pack('<BBBB', st_byte, stream['stream_id'], stream['packet_count'], stream['packet_size'] // 8)
        buf += struct.pack('<I', stream['source_total_bytes'])
        
    for pkt in packets_payloads:
        buf += pkt
    return bytes(buf)

func CreateQrtpFrame(transferID uint16, streams []StreamInfo, packetsPayloads [][]byte) []byte {
	var buf []byte
	buf = append(buf, 'q', 0)

	if len(streams) == 1 && streams[0].StreamID == 0 && (streams[0].PacketSize == 368 || streams[0].PacketSize == 40) {
		tw := (transferID & 0x7fff) | 0x8000
		tBytes := make([]byte, 2)
		binary.LittleEndian.PutUint16(tBytes, tw)
		buf = append(buf, tBytes...)

		sBytes := make([]byte, 4)
		binary.LittleEndian.PutUint32(sBytes, streams[0].SourceTotalBytes)
		buf = append(buf, sBytes...)

		for _, pkt := range packetsPayloads {
			buf = append(buf, pkt...)
		}
		return buf
	}

	tBytes := make([]byte, 2)
	binary.LittleEndian.PutUint16(tBytes, transferID&0x7fff)
	buf = append(buf, tBytes...)

	for i, stream := range streams {
		isLast := i == len(streams)-1
		stByte := stream.StreamType
		if isLast {
			stByte |= 0x80
		}
		buf = append(buf, stByte, stream.StreamID, stream.PacketCount, uint8(stream.PacketSize/8))
		sBytes := make([]byte, 4)
		binary.LittleEndian.PutUint32(sBytes, stream.SourceTotalBytes)
		buf = append(buf, sBytes...)
	}

	for _, pkt := range packetsPayloads {
		buf = append(buf, pkt...)
	}
	return buf
}