Establish release CI matrix (#99)

crates/libremetaverse/src/asset_models.rs

@@ -155,20 +155,14 @@ raw_asset!(AssetScriptBinary, AssetType::LSLBytecode);
 raw_asset!(AssetSound, AssetType::Sound);
 
 impl AssetSound {
+    #[cfg(feature = "vorbis")]
     pub fn pcm_to_ogg(
         pcm_data: Vec<u8>,
         sample_rate: i32,
         channels: i32,
         bits_per_sample: Option<i32>,
     ) -> Result<Vec<u8>, Error> {
-        validate_bytes(&pcm_data)?;
-        if pcm_data.is_empty()
-            || sample_rate <= 0
-            || !matches!(channels, 1 | 2)
-            || !matches!(bits_per_sample.unwrap_or(16), 8 | 16)
-        {
-            return Err(Error::Argument);
-        }
+        validate_pcm(&pcm_data, sample_rate, channels, bits_per_sample)?;
         let bits = bits_per_sample.unwrap_or(16);
         let bytes_per_sample = usize::try_from(bits / 8).map_err(|_| Error::Argument)?;
         let channels = usize::try_from(channels).map_err(|_| Error::Argument)?;
@@ -215,6 +209,43 @@ impl AssetSound {
         validate_bytes(&ogg_data)?;
         Ok(ogg_data)
     }
+
+    #[cfg(not(feature = "vorbis"))]
+    pub fn pcm_to_ogg(
+        pcm_data: Vec<u8>,
+        sample_rate: i32,
+        channels: i32,
+        bits_per_sample: Option<i32>,
+    ) -> Result<Vec<u8>, Error> {
+        validate_pcm(&pcm_data, sample_rate, channels, bits_per_sample)?;
+        Err(Error::InvalidOperation)
+    }
+}
+
+fn validate_pcm(
+    pcm_data: &[u8],
+    sample_rate: i32,
+    channels: i32,
+    bits_per_sample: Option<i32>,
+) -> Result<(), Error> {
+    validate_bytes(pcm_data)?;
+    if pcm_data.is_empty()
+        || sample_rate <= 0
+        || !matches!(channels, 1 | 2)
+        || !matches!(bits_per_sample.unwrap_or(16), 8 | 16)
+    {
+        return Err(Error::Argument);
+    }
+    let bytes_per_sample =
+        usize::try_from(bits_per_sample.unwrap_or(16) / 8).map_err(|_| Error::Argument)?;
+    let channels = usize::try_from(channels).map_err(|_| Error::Argument)?;
+    let frame_size = bytes_per_sample
+        .checked_mul(channels)
+        .ok_or(Error::Argument)?;
+    if !pcm_data.len().is_multiple_of(frame_size) {
+        return Err(Error::Argument);
+    }
+    Ok(())
 }
 
 #[derive(Clone, Debug)]

crates/libremetaverse/src/asset_pipeline_semantics.rs

@@ -1,7 +1,10 @@
-use crate::assets::{AssetMesh, AssetMutable, AssetSound, AssetTexture};
+#[cfg(feature = "jpeg2000")]
+use crate::assets::AssetTexture;
+use crate::assets::{AssetMesh, AssetMutable, AssetSound};
 use crate::{
     AssetCache, AssetCacheComputeAssetCacheFilenameDelegate, Error, GridClient, ImageCodec,
 };
+#[cfg(feature = "jpeg2000")]
 use libremetaverse_imaging::{ManagedImage, ManagedImageImageChannels};
 use libremetaverse_types::{AssetType, UUID};
 use std::fs;
@@ -33,10 +36,28 @@ fn asset_models_retain_type_and_reject_malformed_meshes() {
 }
 
 #[test]
-fn sound_and_texture_codecs_produce_real_valid_payloads() {
+#[cfg(feature = "vorbis")]
+fn sound_codec_produces_real_valid_payload() {
     let ogg = AssetSound::pcm_to_ogg(vec![0_u8; 256 * 2], 44_100, 1, Some(16)).unwrap();
     assert!(ogg.starts_with(b"OggS"));
+}
 
+#[test]
+#[cfg(not(feature = "vorbis"))]
+fn sound_codec_is_explicitly_feature_gated() {
+    assert_eq!(
+        AssetSound::pcm_to_ogg(vec![0_u8; 256 * 2], 44_100, 1, Some(16)),
+        Err(Error::InvalidOperation)
+    );
+    assert_eq!(
+        AssetSound::pcm_to_ogg(Vec::new(), 44_100, 1, Some(16)),
+        Err(Error::Argument)
+    );
+}
+
+#[test]
+#[cfg(feature = "jpeg2000")]
+fn texture_codec_produces_real_valid_payload() {
     let mut image = ManagedImage::new(2, 2, ManagedImageImageChannels::COLOR).unwrap();
     image.red.fill(255);
     let texture = AssetTexture::new_with_managed_image(image).unwrap();

crates/libremetaverse/src/object_manager.rs

@@ -2913,12 +2913,10 @@ mod tests {
         block.name = b"Native object".to_vec();
         block.description = b"decoded".to_vec();
         packet.object_data = vec![block];
+        let wire = transport_wire(&packet.to_bytes_with_method().expect("wire packet"));
         manager
             .inner
-            .handle_object_properties(
-                &packet.to_bytes_with_method().expect("wire packet"),
-                simulator.clone(),
-            )
+            .handle_object_properties(&wire, simulator.clone())
             .expect("properties reply");
         assert!(observed.load(Ordering::Acquire));
         assert_eq!(