h265: reimplementation

changes.d/pr-425.toml

@@ -0,0 +1,31 @@
+[[scuffle-bytes-util]]
+category = "feat"
+description = "add nal emulation prevention io"
+authors = ["@lennartkloock"]
+
+[[scuffle-flv]]
+category = "chore"
+description = "update tests to use new h265 version"
+authors = ["@lennartkloock"]
+
+[[scuffle-h264]]
+category = "refactor"
+description = "move nal emulation prevention io to scuffle-bytes-util"
+breaking = true
+authors = ["@lennartkloock"]
+
+[[scuffle-h265]]
+category = "refactor"
+description = "reimplement h265 SPS parsing"
+breaking = true
+authors = ["@lennartkloock"]
+
+[[scuffle-mp4]]
+category = "chore"
+description = "update to use new h265 version"
+authors = ["@lennartkloock"]
+
+[[scuffle-transmuxer]]
+category = "chore"
+description = "update to use new h265 version"
+authors = ["@lennartkloock"]

crates/bytes-util/src/lib.rs

@@ -16,6 +16,7 @@ mod bit_read;
 mod bit_write;
 mod bytes_cursor;
 mod cow;
+mod nal_emulation_prevention;
 pub mod zero_copy;
 
 pub use bit_read::BitReader;
@@ -26,3 +27,4 @@ pub use cow::string::StringCow;
 #[cfg(feature = "serde")]
 #[cfg_attr(docsrs, doc(cfg(feature = "serde")))]
 pub use cow::string::serde::StringCowDeserializer;
+pub use nal_emulation_prevention::EmulationPreventionIo;

crates/h264/src/io.rs → crates/bytes-util/src/nal_emulation_prevention.rs

@@ -1,5 +1,9 @@
 /// A wrapper around a [`std::io::Read`] or [`std::io::Write`] that automatically inserts or removes
-/// emulation prevention bytes, when reading or writing respectively.
+/// [NAL](https://en.wikipedia.org/wiki/Network_Abstraction_Layer) emulation prevention bytes, when reading or writing respectively.
+///
+/// Defined by:
+/// - ISO/IEC 14496-10 - 7.4.1.1
+/// - ISO/IEC 23008-2 - 7.4.2.3
 pub struct EmulationPreventionIo<I> {
     inner: I,
     zero_count: u8,

crates/flv/src/lib.rs

@@ -43,6 +43,7 @@ mod tests {
     use scuffle_av1::seq::SequenceHeaderObu;
     use scuffle_bytes_util::StringCow;
     use scuffle_h264::Sps;
+    use scuffle_h265::{ConstantFrameRate, NumTemporalLayers};
 
     use crate::audio::AudioData;
     use crate::audio::body::AudioTagBody;
@@ -568,59 +569,16 @@ mod tests {
             ); // AAC
             assert_eq!(
                 on_meta_data.videocodecid,
-                Some(OnMetaDataVideoCodecId::Legacy(VideoCodecId::Avc))
-            ); // AVC
-            assert_eq!(on_meta_data.duration, Some(0.0)); // 0 seconds (this was a live stream)
-            assert_eq!(on_meta_data.width, Some(2560.0));
-            assert_eq!(on_meta_data.height, Some(1440.0));
-            assert_eq!(on_meta_data.framerate, Some(144.0));
+                Some(OnMetaDataVideoCodecId::Enhanced(VideoFourCc::Hevc))
+            ); // HEVC
+            assert_eq!(on_meta_data.duration, Some(2.038));
+            assert_eq!(on_meta_data.width, Some(3840.0));
+            assert_eq!(on_meta_data.height, Some(2160.0));
+            assert_eq!(on_meta_data.framerate, Some(60.0));
             assert!(on_meta_data.videodatarate.is_some());
             assert!(on_meta_data.audiodatarate.is_some());
         }
 
-        // Audio Sequence Header Tag
-        {
-            let tag = tags.next().expect("expected tag");
-            assert_eq!(tag.timestamp_ms, 0);
-            assert_eq!(tag.stream_id, 0);
-
-            let (body, sound_rate, sound_size, sound_type) = match tag.data {
-                FlvTagData::Audio(AudioData {
-                    body,
-                    header:
-                        AudioTagHeader::Legacy(LegacyAudioTagHeader {
-                            sound_rate,
-                            sound_size,
-                            sound_type,
-                            ..
-                        }),
-                }) => (body, sound_rate, sound_size, sound_type),
-                _ => panic!("expected audio data"),
-            };
-
-            assert_eq!(sound_rate, SoundRate::Hz44000);
-            assert_eq!(sound_size, SoundSize::Bit16);
-            assert_eq!(sound_type, SoundType::Stereo);
-
-            // Audio data should be an AAC sequence header
-            let data = match body {
-                AudioTagBody::Legacy(LegacyAudioTagBody::Aac(AacAudioData::SequenceHeader(data))) => data,
-                _ => panic!("expected aac sequence header"),
-            };
-
-            // The aac sequence header should be able to be decoded into an aac decoder
-            // configuration record
-            let aac_decoder_configuration_record =
-                PartialAudioSpecificConfig::parse(&data).expect("expected aac decoder configuration record");
-
-            assert_eq!(
-                aac_decoder_configuration_record.audio_object_type,
-                AudioObjectType::AacLowComplexity
-            );
-            assert_eq!(aac_decoder_configuration_record.sampling_frequency, 48000);
-            assert_eq!(aac_decoder_configuration_record.channel_configuration, 2);
-        }
-
         // Video Sequence Header Tag
         {
             let tag = tags.next().expect("expected tag");
@@ -642,16 +600,15 @@ mod tests {
 
             assert_eq!(frame_type, VideoFrameType::KeyFrame);
 
-            assert_eq!(config.configuration_version, 1);
             assert_eq!(config.avg_frame_rate, 0);
-            assert_eq!(config.constant_frame_rate, 0);
-            assert_eq!(config.num_temporal_layers, 1);
+            assert_eq!(config.constant_frame_rate, ConstantFrameRate::Unknown);
+            assert_eq!(config.num_temporal_layers, NumTemporalLayers::NotScalable);
 
             // We should be able to find a SPS NAL unit in the sequence header
             let Some(sps) = config
                 .arrays
                 .iter()
-                .find(|a| a.nal_unit_type == scuffle_h265::NaluType::Sps)
+                .find(|a| a.nal_unit_type == scuffle_h265::NALUnitType::SpsNut)
                 .and_then(|v| v.nalus.first())
             else {
                 panic!("expected sps");
@@ -661,32 +618,63 @@ mod tests {
             let Some(_) = config
                 .arrays
                 .iter()
-                .find(|a| a.nal_unit_type == scuffle_h265::NaluType::Pps)
+                .find(|a| a.nal_unit_type == scuffle_h265::NALUnitType::PpsNut)
                 .and_then(|v| v.nalus.first())
             else {
                 panic!("expected pps");
             };
 
             // We should be able to decode the SPS NAL unit
-            let sps = scuffle_h265::Sps::parse(sps.clone()).expect("expected sps");
+            let sps = scuffle_h265::SpsNALUnit::parse(io::Cursor::new(sps.clone())).expect("expected sps");
+
+            insta::assert_debug_snapshot!(sps);
+        }
+
+        // Audio Sequence Header Tag
+        {
+            let tag = tags.next().expect("expected tag");
+            assert_eq!(tag.timestamp_ms, 0);
+            assert_eq!(tag.stream_id, 0);
+
+            let (body, sound_rate, sound_size, sound_type) = match tag.data {
+                FlvTagData::Audio(AudioData {
+                    body,
+                    header:
+                        AudioTagHeader::Legacy(LegacyAudioTagHeader {
+                            sound_rate,
+                            sound_size,
+                            sound_type,
+                            ..
+                        }),
+                }) => (body, sound_rate, sound_size, sound_type),
+                _ => panic!("expected audio data"),
+            };
+
+            assert_eq!(sound_rate, SoundRate::Hz44000);
+            assert_eq!(sound_size, SoundSize::Bit16);
+            assert_eq!(sound_type, SoundType::Stereo);
+
+            // Audio data should be an AAC sequence header
+            let data = match body {
+                AudioTagBody::Legacy(LegacyAudioTagBody::Aac(AacAudioData::SequenceHeader(data))) => data,
+                _ => panic!("expected aac sequence header"),
+            };
+
+            // The aac sequence header should be able to be decoded into an aac decoder
+            // configuration record
+            let aac_decoder_configuration_record =
+                PartialAudioSpecificConfig::parse(&data).expect("expected aac decoder configuration record");
 
-            assert_eq!(sps.frame_rate, 144.0);
-            assert_eq!(sps.width, 2560);
-            assert_eq!(sps.height, 1440);
             assert_eq!(
-                sps.color_config,
-                Some(scuffle_h265::ColorConfig {
-                    full_range: false,
-                    color_primaries: 1,
-                    transfer_characteristics: 1,
-                    matrix_coefficients: 1,
-                })
-            )
+                aac_decoder_configuration_record.audio_object_type,
+                AudioObjectType::AacLowComplexity
+            );
+            assert_eq!(aac_decoder_configuration_record.sampling_frequency, 48000);
+            assert_eq!(aac_decoder_configuration_record.channel_configuration, 2);
         }
 
         // Rest of the tags should be video / audio data
         let mut last_timestamp = 0;
-        let mut read_seq_end = false;
         for tag in tags {
             assert!(tag.timestamp_ms >= last_timestamp || tag.timestamp_ms == 0); // Timestamps should be monotonically increasing or 0
             assert_eq!(tag.stream_id, 0);
@@ -719,29 +707,16 @@ mod tests {
                     body:
                         VideoTagBody::Enhanced(ExVideoTagBody::NoMultitrack {
                             video_four_cc: VideoFourCc::Hevc,
-                            packet,
+                            ..
                         }),
-                }) => {
-                    match frame_type {
-                        VideoFrameType::KeyFrame => (),
-                        VideoFrameType::InterFrame => (),
-                        _ => panic!("expected keyframe or interframe"),
-                    }
-
-                    match packet {
-                        VideoPacket::CodedFrames(_) => assert!(!read_seq_end),
-                        VideoPacket::CodedFramesX { .. } => assert!(!read_seq_end),
-                        VideoPacket::SequenceEnd => {
-                            assert!(!read_seq_end);
-                            read_seq_end = true;
-                        }
-                        _ => panic!("expected hevc nalu packet: {packet:?}"),
-                    };
-                }
+                }) => match frame_type {
+                    VideoFrameType::KeyFrame => (),
+                    VideoFrameType::InterFrame => (),
+                    VideoFrameType::Command => (),
+                    _ => panic!("expected keyframe, interframe or command"),
+                },
                 _ => panic!("unexpected data"),
             };
         }
-
-        assert!(read_seq_end);
     }
 }