#include "rtp/rtp.h"

int main() {
  // Create a transmitter with SAP/SDP announcements
  mediax::RtpSapTransmit<mediax::rtp::uncompressed::RtpUncompressedPayloader> rtp(
      "239.192.1.1",    // Multicast IP address
      5004,             // Port
      "my-stream",      // Session name
      640, 480,         // Width x Height
      30,               // Framerate
      "RGB24"           // Colorspace
  );

  // Get a test pattern buffer
  std::vector<uint8_t> &buffer = rtp.GetBufferTestPattern();

  // Transmit 100 frames
  for (int i = 0; i < 100; i++) {
    rtp.Transmit(buffer.data(), false);
  }

  return 0;
}

import sys
sys.path.append('/usr/local/lib/python3/dist-packages/mediax')

import rtp_uncompressed_payloader
import rtp_types

# Create payloader
payloader = rtp_uncompressed_payloader.RtpUncompressedPayloader()

# Configure stream
stream_info = rtp_types.StreamInformation()
stream_info.session_name = "my-stream"
stream_info.hostname = "239.192.1.1"
stream_info.port = 5004
stream_info.width = 640
stream_info.height = 480
stream_info.framerate = 30
stream_info.encoding = rtp_types.ColourspaceType_kColourspaceRgb24

payloader.SetStreamInfo(stream_info)
payloader.Open()

# Transmit frame data
frame_data = bytes(640 * 480 * 3)  # RGB24 buffer
payloader.Transmit(frame_data, True)

payloader.Close()

#include <chrono>
#include <iostream>
#include <thread>
#include <vector>
#include "rtp/rtp.h"
#include "uncompressed/rtp_uncompressed_depayloader.h"

int main() {
  // Create a receiver — waits for SAP announcement for "my-stream"
  mediax::RtpSapRecieve<mediax::rtp::uncompressed::RtpUncompressedDepayloader> rtp(
      "239.192.1.1", 5004, "my-stream", 480, 640, 30, "RGB24");

  // Poll for frames — blocks up to 80 ms per call
  mediax::rtp::RtpFrameData frame;
  std::vector<uint8_t>& buffer = rtp.GetBuffer();

  for (int i = 0; i < 100; i++) {
    if (rtp.Receive(&frame, buffer.size())) {
      std::cout << "Received frame " << i
                << " (" << frame.resolution.width
                << "x" << frame.resolution.height << ")\n";
    } else {
      // SAP not yet seen or timeout — wait and retry
      std::this_thread::sleep_for(std::chrono::milliseconds(100));
    }
  }

  return 0;
}

import sys
sys.path.append('/usr/local/lib/python3/dist-packages/mediax')

import sap_listener
import time

# Get SAP listener instance
listener = sap_listener.SapListener.GetInstance()
listener.Start()

# Wait for announcements
time.sleep(5)

listener.Stop()

# Get discovered streams
streams = listener.GetSapAnnouncements()
for name, sdp in streams.items():
    print(f"Found: {sdp.session_name} at {sdp.ip_address}:{sdp.port}")

# Transmit a test pattern
./rtp-transmit --ipaddr 239.192.1.1 --port 5004 --width 640 --height 480

# Receive and display video
./rtp-receive --ipaddr 239.192.1.1 --port 5004

#include <iostream>
#include "gige/gige_receiver.h"
#include "gige/gvsp/gvsp_receiver.h"

int main() {
  mediax::gige::GigEReceiver receiver;
  receiver.SetReceivePort(55100);

  if (!receiver.Connect("192.168.1.100")) {  // camera IP
    std::cerr << "Connect failed\n";
    return 1;
  }
  receiver.Open();  // sends AcquisitionStart

  mediax::gige::gvsp::GvspFrameData frame;
  for (int i = 0; i < 100; i++) {
    if (receiver.Receive(&frame, 2000))
      std::cout << "Frame " << i << ": "
                << frame.width << "x" << frame.height
                << "  " << frame.pixels.size() << " bytes\n";
  }

  receiver.Close();
  return 0;
}