Complete PES pipeline — all streams, clean API

- Unified Stream trait: read() and write() on one type
- PesFrame serialize/deserialize for wire format
- TsDemuxReader: shared BD-TS demux for any Read source
- MkvStream: PES read from MKV (EBML → PesFrame)
- M2tsStream: PES read via TsDemuxReader
- Network/Stdio output: PES serialization directly (no BD-TS wrap)
- Network/Stdio input: deferred (needs PES deserialization protocol)
- TsMuxer for M2TS output from PES frames
- input() and output() functions return Box<dyn Stream>

src/mux/tsreader.rs

@@ -0,0 +1,108 @@
+//! TsDemuxReader — reads from any source, demuxes BD-TS, produces PES frames.
+//!
+//! Wraps any Read source with a TsDemuxer + CodecParsers.
+//! One implementation used by M2TS, Network, Stdio, and any other BD-TS input.
+
+use super::codec::{self, CodecParser};
+use super::ts::TsDemuxer;
+use crate::disc::Stream as DiscStream;
+use crate::pes::PesFrame;
+use std::collections::VecDeque;
+use std::io::{self, Read};
+
+const READ_BUF_SIZE: usize = 192 * 1024; // 1024 BD-TS packets
+
+/// Generic BD-TS → PES frame reader.
+pub struct TsDemuxReader<R: Read> {
+    reader: R,
+    demuxer: TsDemuxer,
+    parsers: Vec<(u16, Box<dyn CodecParser>)>,
+    pid_to_track: Vec<(u16, usize)>,
+    pending: VecDeque<PesFrame>,
+    buf: Vec<u8>,
+    eof: bool,
+}
+
+impl<R: Read> TsDemuxReader<R> {
+    /// Create from a reader and stream metadata.
+    pub fn new(reader: R, streams: &[DiscStream]) -> Self {
+        let mut pids = Vec::new();
+        let mut parsers: Vec<(u16, Box<dyn CodecParser>)> = Vec::new();
+        let mut pid_to_track = Vec::new();
+        for (i, s) in streams.iter().enumerate() {
+            let (pid, c) = match s {
+                DiscStream::Video(v) => (v.pid, v.codec),
+                DiscStream::Audio(a) => (a.pid, a.codec),
+                DiscStream::Subtitle(s) => (s.pid, s.codec),
+            };
+            pids.push(pid);
+            pid_to_track.push((pid, i));
+            parsers.push((pid, codec::parser_for_codec(c)));
+        }
+
+        Self {
+            reader,
+            demuxer: TsDemuxer::new(&pids),
+            parsers,
+            pid_to_track,
+            pending: VecDeque::new(),
+            buf: vec![0u8; READ_BUF_SIZE],
+            eof: false,
+        }
+    }
+
+    /// Get the next PES frame. Returns None at EOF.
+    pub fn next_frame(&mut self) -> io::Result<Option<PesFrame>> {
+        if let Some(frame) = self.pending.pop_front() {
+            return Ok(Some(frame));
+        }
+        if self.eof {
+            return Ok(None);
+        }
+
+        loop {
+            let n = self.reader.read(&mut self.buf)?;
+            if n == 0 {
+                self.eof = true;
+                return Ok(None);
+            }
+
+            let packets = self.demuxer.feed(&self.buf[..n]);
+            for pes in &packets {
+                if let Some((_, track)) = self.pid_to_track.iter().find(|(pid, _)| *pid == pes.pid) {
+                    if let Some((_, parser)) = self.parsers.iter_mut().find(|(pid, _)| *pid == pes.pid) {
+                        for frame in parser.parse(pes) {
+                            self.pending.push_back(PesFrame::from_codec_frame(*track, frame));
+                        }
+                    }
+                }
+            }
+
+            if let Some(frame) = self.pending.pop_front() {
+                return Ok(Some(frame));
+            }
+        }
+    }
+
+    /// Codec private data for a track.
+    pub fn codec_private(&self, track: usize) -> Option<Vec<u8>> {
+        let pid = self.pid_to_track.iter()
+            .find(|(_, idx)| *idx == track)
+            .map(|(pid, _)| *pid)?;
+        self.parsers.iter()
+            .find(|(p, _)| *p == pid)
+            .and_then(|(_, parser)| parser.codec_private())
+    }
+
+    /// True when all primary video tracks have codec_private.
+    pub fn headers_ready(&self, streams: &[DiscStream]) -> bool {
+        for (idx, s) in streams.iter().enumerate() {
+            if let DiscStream::Video(v) = s {
+                if !v.secondary && self.codec_private(idx).is_none() {
+                    return false;
+                }
+            }
+        }
+        true
+    }
+}