Unified Stream trait: read() and write() on one type

Stream trait: read() returns PesFrame, write() accepts PesFrame.
A stream is a stream — you read from it or write to it.
No separate Input/Output traits.

API: libfreemkv::input(url) and libfreemkv::output(url, title, codecs)
Returns Box<dyn Stream>.

src/disc/bluray.rs

@@ -104,8 +104,8 @@ impl Disc {
                     1 | 6 | 7 => Some(Stream::Video(VideoStream {
                         pid: s.pid,
                         codec,
-                        resolution: format_resolution(s.video_format, s.video_rate),
-                        frame_rate: format_framerate(s.video_rate),
+                        resolution: Resolution::from_video_format(s.video_format),
+                        frame_rate: FrameRate::from_video_rate(s.video_rate),
                         hdr: match s.dynamic_range {
                             1 => HdrFormat::Hdr10,
                             2 => HdrFormat::DolbyVision,
@@ -137,9 +137,9 @@ impl Disc {
                             Some(Stream::Audio(AudioStream {
                                 pid: s.pid,
                                 codec,
-                                channels: format_channels(s.audio_format),
+                                channels: AudioChannels::from_audio_format(s.audio_format),
                                 language: s.language.clone(),
-                                sample_rate: format_samplerate(s.audio_rate),
+                                sample_rate: SampleRate::from_audio_rate(s.audio_rate),
                                 secondary: s.stream_type == 5,
                                 label: String::new(),
                             }))

src/disc/dvd.rs

@@ -20,20 +20,13 @@ impl Disc {
         let mut title_number: u16 = 0;
 
         for ts in &dvd_info.title_sets {
-            // Map DvdVideoAttr to Stream::Video
-            let video_codec = match ts.video.codec.as_str() {
-                "mpeg2" => Codec::Mpeg2,
-                "mpeg1" => Codec::Mpeg2, // treat MPEG-1 as MPEG-2 for container purposes
-                _ => Codec::Mpeg2,
-            };
-
             let video_stream = Stream::Video(VideoStream {
                 pid: 0xE0, // DVD video PID (standard MPEG PS video stream)
-                codec: video_codec,
-                resolution: ts.video.resolution.clone(),
+                codec: ts.video.codec,
+                resolution: ts.video.resolution,
                 frame_rate: match ts.video.standard.as_str() {
-                    "PAL" => "25".to_string(),
-                    _ => "29.97".to_string(),
+                    "PAL" => FrameRate::F25,
+                    _ => FrameRate::F29_97,
                 },
                 hdr: HdrFormat::Sdr,
                 color_space: ColorSpace::Bt709,
@@ -47,31 +40,13 @@ impl Disc {
                 .iter()
                 .enumerate()
                 .map(|(i, a)| {
-                    let codec = match a.codec.as_str() {
-                        "ac3" => Codec::Ac3,
-                        "dts" => Codec::Dts,
-                        "lpcm" => Codec::Lpcm,
-                        "mpeg1" | "mpeg2" => Codec::Mpeg2,
-                        _ => Codec::Unknown(0),
-                    };
-                    let channels = match a.channels {
-                        1 => "mono".to_string(),
-                        2 => "stereo".to_string(),
-                        6 => "5.1".to_string(),
-                        8 => "7.1".to_string(),
-                        n => format!("{n}ch"),
-                    };
-                    let sample_rate = match a.sample_rate {
-                        48000 => "48kHz".to_string(),
-                        96000 => "96kHz".to_string(),
-                        sr => format!("{}kHz", sr / 1000),
-                    };
+                    let codec = a.codec;
                     Stream::Audio(AudioStream {
                         pid: 0xBD00 + i as u16, // DVD private stream 1 sub-IDs
                         codec,
-                        channels,
+                        channels: AudioChannels::from_count(a.channels),
                         language: a.language.clone(),
-                        sample_rate,
+                        sample_rate: SampleRate::from_hz(a.sample_rate),
                         secondary: false,
                         label: String::new(),
                     })