netprotomvds 0.1.0__py3-none-any.whl

netprotomvds/__init__.py

@@ -0,0 +1,11 @@
+"""netprotomvds — быстрая передача видео по UDP."""
+from .version import __version__
+from .packet import split_frame, reassemble_frame
+from .server import VideoServer
+from .client import VideoClient
+
+__all__ = [
+    "__version__",
+    "split_frame", "reassemble_frame",
+    "VideoServer", "VideoClient",
+]

netprotomvds/client.py

@@ -0,0 +1,76 @@
+"""Клиентская часть (Контроллер). Принимает кадры."""
+import socket
+import struct
+import threading
+import queue
+import time
+from .packet import reassemble_frame, HEADER_FORMAT, HEADER_SIZE
+
+class VideoClient:
+    def __init__(self, server_ip, server_port=8081, buffer_size=3):
+        self.server_addr = (server_ip, server_port)
+        self.buffer_size = buffer_size
+        
+        self.sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+        self.sock.bind(("0.0.0.0", 0)) # Слушаем на случайном порту
+        
+        self._running = False
+        self._thread = None
+        self._recv_queue = queue.Queue()
+        self._frame_buffer = []
+        self._lock = threading.Lock()
+
+    def start(self):
+        self._running = True
+        self._thread = threading.Thread(target=self._listen_loop, daemon=True)
+        self._thread.start()
+        print(f"[VideoClient] Слушаю {self.server_addr}...")
+
+    def stop(self):
+        self._running = False
+        if self._thread:
+            self._thread.join(timeout=1.0)
+        self.sock.close()
+
+    def _listen_loop(self):
+        current_frame_id = None
+        current_packets = []
+        expected_chunks = 0
+
+        while self._running:
+            try:
+                data, addr = self.sock.recvfrom(2048)
+                if len(data) < HEADER_SIZE:
+                    continue
+
+                frame_id, total_chunks, chunk_idx = struct.unpack(HEADER_FORMAT, data[:HEADER_SIZE])
+                
+                # Если пришел новый кадр — сбрасываем старый (потеряли кусок)
+                if current_frame_id != frame_id:
+                    current_frame_id = frame_id
+                    current_packets = [None] * total_chunks
+                    expected_chunks = total_chunks
+
+                current_packets[chunk_idx] = data
+                
+                # Если собрали все чанки
+                if all(p is not None for p in current_packets):
+                    frame_data = reassemble_frame(current_packets)
+                    
+                    with self._lock:
+                        self._frame_buffer.append(frame_data)
+                        if len(self._frame_buffer) > self.buffer_size:
+                            self._frame_buffer.pop(0) # Удаляем старый (Jitter Buffer)
+                            
+                    current_frame_id = None
+                    current_packets = []
+            except Exception as e:
+                if self._running:
+                    print(f"[VideoClient] Ошибка приема: {e}")
+
+    def get_latest_frame(self):
+        """Возвращает самый свежий собранный кадр (bytes)."""
+        with self._lock:
+            if self._frame_buffer:
+                return self._frame_buffer[-1]
+        return None

netprotomvds/packet.py

@@ -0,0 +1,56 @@
+"""Нарезка и сборка пакетов для UDP-видеопотока."""
+import struct
+import zlib
+
+HEADER_FORMAT = "<IHH" # packet_id (4), total_chunks (2), chunk_index (2)
+HEADER_SIZE = struct.calcsize(HEADER_FORMAT)
+MAX_PAYLOAD_SIZE = 1400  # Безопасный размер для прохождения через NAT
+
+def compress_data(data: bytes) -> bytes:
+    """Сжимает данные, чтобы уменьшить трафик."""
+    return zlib.compress(data, level=1) # level=1 самый быстрый
+
+def decompress_data(data: bytes) -> bytes:
+    """Распаковывает данные."""
+    return zlib.decompress(data)
+
+def split_frame(frame_id: int, data: bytes, compressed: bool = True) -> list:
+    """Нарезает кадр на список пакетов."""
+    if compressed:
+        payload = compress_data(data)
+    else:
+        payload = data
+
+    total_size = len(payload)
+    total_chunks = (total_size + MAX_PAYLOAD_SIZE - 1) // MAX_PAYLOAD_SIZE
+    if total_chunks > 65535:
+        raise ValueError("Кадр слишком большой (больше 65535 чанков)")
+
+    packets = []
+    for i in range(total_chunks):
+        start = i * MAX_PAYLOAD_SIZE
+        end = start + MAX_PAYLOAD_SIZE
+        chunk = payload[start:end]
+        
+        # Header: frame_id, total_chunks, chunk_index
+        header = struct.pack(HEADER_FORMAT, frame_id, total_chunks, i)
+        packets.append(header + chunk)
+        
+    return packets
+
+def reassemble_frame(packets: list) -> bytes:
+    """Собирает кадр из списка пакетов. 
+    Ожидает, что список уже отсортирован по chunk_index и полный.
+    """
+    if not packets:
+        return b""
+
+    # Извлекаем заголовок из первого пакета, чтобы узнать, сжат ли он
+    header = packets[0][:HEADER_SIZE]
+    frame_id, total_chunks, _ = struct.unpack(HEADER_FORMAT, header)
+    
+    payload = bytearray()
+    for pkt in packets:
+        payload.extend(pkt[HEADER_SIZE:])
+        
+    return decompress_data(bytes(payload))

netprotomvds/server.py

@@ -0,0 +1,46 @@
+"""Серверная часть (Агент). Отправляет кадры."""
+import socket
+import threading
+import time
+from .packet import split_frame
+
+class VideoServer:
+    def __init__(self, host="0.0.0.0", port=8081):
+        self.host = host
+        self.port = port
+        self.sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+        self.sock.bind((self.host, self.port))
+        
+        self.target_addr = None
+        self._running = False
+        self._frame_id = 0
+        self._lock = threading.Lock()
+
+    def set_target(self, ip, port):
+        """Устанавливает адрес клиента (Controller)."""
+        self.target_addr = (ip, port)
+
+    def start(self):
+        self._running = True
+        print(f"[VideoServer] UDP-сервер запущен на {self.host}:{self.port}")
+
+    def stop(self):
+        self._running = False
+        self.sock.close()
+        print("[VideoServer] Остановлен.")
+
+    def send_frame(self, image_bytes):
+        """Нарезает и отправляет один кадр."""
+        if not self.target_addr or not self._running:
+            return
+
+        with self._lock:
+            self._frame_id = (self._frame_id + 1) & 0xFFFFFFFF
+            
+        packets = split_frame(self._frame_id, image_bytes, compressed=True)
+        for pkt in packets:
+            try:
+                self.sock.sendto(pkt, self.target_addr)
+            except Exception as e:
+                print(f"[VideoServer] Ошибка отправки: {e}")
+                break

netprotomvds/test_stream.py

@@ -0,0 +1,35 @@
+import time
+import threading
+from netprotomvds import VideoServer, VideoClient
+
+# 1. Настраиваем сервер
+server = VideoServer(host="127.0.0.1", port=8081)
+server.start()
+
+# 2. Настраиваем клиент
+client = VideoClient(server_ip="127.0.0.1", server_port=8081)
+client.start()
+
+# Говорим серверу, куда слать видео (в тесте шлем сами себе)
+time.sleep(0.5) # Ждем старта
+# Узнаем порт, на который клиент сел
+client_port = client.sock.getsockname()[1]
+server.set_target("127.0.0.1", client_port)
+
+print("Начинаем передачу...")
+for i in range(5):
+    test_data = f"Это тестовый кадр номер {i}".encode("utf-8") * 100 # ~3 КБ
+    server.send_frame(test_data)
+    time.sleep(0.2)
+
+time.sleep(0.5) # Ждем, пока долетит
+frame = client.get_latest_frame()
+
+if frame:
+    print(f"Успех! Получен кадр размером {len(frame)} байт.")
+    print(f"Начало данных: {frame[:50].decode('utf-8')}...")
+else:
+    print("Ошибка: кадр не получен.")
+
+server.stop()
+client.stop()

netprotomvds/version.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

netprotomvds-0.1.0.dist-info/METADATA

@@ -0,0 +1,38 @@
+Metadata-Version: 2.4
+Name: netprotomvds
+Version: 0.1.0
+Summary: Network Protocol Multithreaded Video Data Share: быстрая передача видео по UDP.
+Author-email: CharmLxt <reception.mailspypi@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/CharmLxt/netprotomvds
+Project-URL: Source, https://github.com/CharmLxt/netprotomvds
+Project-URL: Tracker, https://github.com/CharmLxt/netprotomvds/issues
+Keywords: udp,video,streaming,networking,multithreading
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Multimedia :: Video
+Classifier: Topic :: System :: Networking
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: numpy>=1.21.0
+Requires-Dist: 9was9>=0.2.0
+
+netprotomvds. Версия 0.1.0. Автор CharmLxt (PyPI: CharmLxt, email: reception.mailspypi@gmail.com). Ссылка на GitHub: https://github.com/CharmLxt/netprotomvds.
+
+
+
+netprotomvds (Network Protocol Multithreaded Video Data Share) — это специализированная библиотека для сверхбыстрой передачи видеопотока или изображений по сети с использованием протокола UDP. Она создавалась специально для проекта Monogrammer, но может использоваться в любых задачах, где нужна трансляция экрана или видеозвонки (например, удаленный рабочий стол, стриминг игр или камеры).
+
+
+
+В основе библиотеки лежит идея, что для видео надежность TCP не так важна, как скорость. Если один пакет с частью картинки потерялся в сети, мы просто отбрасываем весь этот кадр и показываем следующий. Из-за этого нет задержек на повторную отправку (как в TCP), и картинка движется максимально плавно. Библиотека автоматически нарезает большие кадры на маленькие пакеты, подходящие под размер MTU, отправляет их и собирает обратно на другом конце.
+
+
+
+В версии 0.1.0 реализован базовый каркас. Модуль packet отвечает за нарезку и склейку данных с порядковыми номерами. VideoServer и VideoClient используют многопоточность (модуль threading) для фоновой отправки и приема, чтобы не блокировать основной интерфейс программы. Для сжатия данных используется стандартный zlib (чтобы не тащить тяжелые зависимости, но в будущем мы добавим JPEG через C#-мост Sowanna). Также встроен Jitter Buffer, который сглаживает неровности сети, храня пару последних кадров.
+
+
+
+Установка: pip install netprotomvds. Зависимости: numpy и 9was9 (для быстрой математики, если понадобится обработка изображений). Библиотека кроссплатформенная, работает везде, где есть сокеты и Python 3.8+. Связь с автором: reception.mailspypi@gmail.com.
+

netprotomvds-0.1.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+netprotomvds/__init__.py,sha256=pT_B_LkDm8qT9Kh3_MdgFI8c8ZLE8UO7m20C9Wttz3s,339
+netprotomvds/client.py,sha256=yGXcfZrGc5SmDeekjBGNFIvv5TckOFVrueg1MCtM43I,3009
+netprotomvds/packet.py,sha256=gjRF4_gs2DwQ1u8zXePQnR9n5wxLJxM7ef7TRaf4f30,2208
+netprotomvds/server.py,sha256=uh42XWT3Ge_BuqcUDzJQB68Z_1u-d9PFDmT3sqroRGI,1603
+netprotomvds/test_stream.py,sha256=rBY_wy9y0e4xA9rfic8LhLuDybrOwuJODfWERwpL9Mw,1209
+netprotomvds/version.py,sha256=Pru0BlFBASFCFo7McHdohtKkUtgMPDwbGfyUZlE2_Vw,21
+netprotomvds-0.1.0.dist-info/METADATA,sha256=HC-aKJW5pumtOMFICNfdrtxpzfs5nx6aZotTdviwv7I,3785
+netprotomvds-0.1.0.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+netprotomvds-0.1.0.dist-info/top_level.txt,sha256=v-A9bkucctQKxfVvLG4zuhogfnClkAHFPa5s4KkXcZc,13
+netprotomvds-0.1.0.dist-info/RECORD,,

netprotomvds-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.2.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

netprotomvds-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+netprotomvds