try (var pcap = NetPcap.openOffline("capture.pcap")) {
    pcap.loop(System.out::println);
}

try (var pcap = NetPcap.openOffline("capture.pcap")) {
    // Initialize protocol headers once for reuse
    final Ethernet ethernet = new Ethernet();
    final Ip4 ip4 = new Ip4();
    final Tcp tcp = new Tcp();
    final Http http = new Http();

    // Configure packet formatting
    pcap.setPacketFormatter(new PacketFormat());
    
    pcap.loop(packet -> {
        // Headers bind to packet's native memory
        if (packet.hasHeader(ethernet))
            System.out.println(ethernet);

        if (packet.hasHeader(ip4))
            System.out.println(ip4);

        if (packet.hasHeader(tcp))
            System.out.println(tcp);

        if (packet.hasHeader(http))
            System.out.println(http);
    });
}

try (PcapFramework framework = new PcapFramework(PcapFramework.VERSION)) {
    
    // Configure multi-port setup with streams and buffers
    try (Config config = framework.createConfig()) {
        // Enable multiple ports
        config.getPortsConfig()
                .enablePorts(PortIds.portSet(0, 1, 2, 3))
                .disablePorts(PortIds.portRange(4, 2));

        // Configure receive streams
        var rxSettings = new StreamSettings()
                .setRxBufferCount(4)    // Multiple receive buffers
                .setRxStreamCount(4);    // Multiple stream processors

        // Setup streams with hash-based distribution
        int[] streamIds = config.getBufferConfig()
                .setupRxStreams(rxSettings);

        // Configure TCP filtering with hash distribution
        config.getNetworkConfig()
                .assignFilter("tcp")
                .priority(20)
                .ids(streamIds)
                .hash(HashMode.HASH_5_TUPLE_SORTED);
    }

    // Start capture with multiple processing threads
    try (NetTransceiver capture = framework.createTransceiver()) {
        // Fork stream processors (4 worker threads)
        capture.forkRxStreams(stream -> {
            RxPacket packet = new RxPacket();
            long totalSize = 0;

            while (stream.isActive()) {
                if (stream.get(packet, 100))
                    continue;

                totalSize += packet.length();
                stream.release(packet);
            }

            System.out.printf("Stream processed %d bytes%n", totalSize);
        }, 4);

        // Fork buffer processors (2 worker threads)
        capture.forkRxBuffers(buffer -> {
            RxSegment segment = buffer.newSegment();
            long totalSize = 0;

            while (buffer.isActive()) {
                if (buffer.get(segment, 100) || segment.isEmpty())
                    continue;

                totalSize += segment.byteSize();
                buffer.release(segment);
            }

            System.out.printf("Buffer processed %d bytes%n", totalSize);
        }, 2);

        // Start capture and wait
        capture.startCapture();
        capture.awaitCaptureStart();
        capture.awaitCaptureStop();
    }
}