add numerous errors

video-encoder/src/encode.rs

@@ -46,6 +46,11 @@ impl EncodeSubcommand{
 			average_bitrate:self.target_bitrate.unwrap_or(6_000_000),
 			max_bitrate:self.max_bitrate.unwrap_or(6_000_000),
 			device:self.device,
+			output_file:self.output_file.unwrap_or_else(||{
+				let mut output_file:PathBuf=self.bot.file_stem().unwrap().into();
+				output_file.set_extension("h264");
+				output_file
+			}),
 			map:self.map,
 			bot:self.bot,
 		})
@@ -60,6 +65,15 @@ enum EncodeError{
 	DecodeSNF(strafesnet_snf::Error),
 	DecodeMap(strafesnet_snf::map::Error),
 	DecodeBot(strafesnet_roblox_bot_file::v0::Error),
+	CreateInstance(vk_video::VulkanInitError),
+	CreateAdapter(vk_video::VulkanInitError),
+	NoAdapter,
+	CreateDevice(vk_video::VulkanInitError),
+	VideoEncodeParams(vk_video::VulkanEncoderError),
+	VideoCreateTextures(vk_video::VulkanEncoderError),
+	VideoEncodeFrame(vk_video::VulkanEncoderError),
+	OutputCreateFile(std::io::Error),
+	OutputWriteFile(std::io::Error),
 }
 
 struct EncodeParams{
@@ -71,6 +85,7 @@ struct EncodeParams{
 	device:Option<String>,
 	map:PathBuf,
 	bot:PathBuf,
+	output_file:PathBuf,
 }
 
 fn encode(params:EncodeParams)->Result<(),EncodeError>{
@@ -90,14 +105,15 @@ fn encode(params:EncodeParams)->Result<(),EncodeError>{
 	let timelines=strafesnet_roblox_bot_file::v0::read_all_to_block(std::io::Cursor::new(bot_file))
 		.map_err(EncodeError::DecodeBot)?;
 
-	let vulkan_instance = vk_video::VulkanInstance::new().unwrap();
+	// vulkan init
+	let vulkan_instance = vk_video::VulkanInstance::new().map_err(EncodeError::CreateInstance)?;
 	let vulkan_adapter = if let Some(filter)=params.device.as_deref(){
 		vulkan_instance.iter_adapters(None)
-			.unwrap()
+			.map_err(EncodeError::CreateAdapter)?
 			.find(|adapter|adapter.info().name.contains(filter))
-			.unwrap()
+			.ok_or(EncodeError::NoAdapter)?
 	}else{
-		vulkan_instance.create_adapter(None).unwrap()
+		vulkan_instance.create_adapter(None).map_err(EncodeError::CreateAdapter)?
 	};
 	let vulkan_device = vulkan_adapter
 		.create_device(
@@ -105,7 +121,7 @@ fn encode(params:EncodeParams)->Result<(),EncodeError>{
 			wgpu::ExperimentalFeatures::disabled(),
 			wgpu::Limits::defaults(),
 		)
-		.unwrap();
+		.map_err(EncodeError::CreateDevice)?;
 
 	// playback
 	let bot=strafesnet_roblox_bot_player::bot::CompleteBot::new(timelines);
@@ -134,11 +150,12 @@ fn encode(params:EncodeParams)->Result<(),EncodeError>{
 						virtual_buffer_size: std::time::Duration::from_secs(2),
 					},
 				)
-				.unwrap(),
+				.map_err(EncodeError::VideoEncodeParams)?,
 		)
-		.unwrap();
+		.map_err(EncodeError::VideoCreateTextures)?;
 
-	let mut output_file = std::fs::File::create("output.h264").unwrap();
+	let mut output_file = std::fs::File::create(params.output_file)
+		.map_err(EncodeError::OutputCreateFile)?;
 
 	let duration = bot.duration();
 	for i in 0..duration.get()*target_framerate as i64/SessionTime::ONE_SECOND.get() {
@@ -147,19 +164,15 @@ fn encode(params:EncodeParams)->Result<(),EncodeError>{
 		let (pos,angles)=playback_head.get_position_angles(&bot,time);
 		wgpu_state.render(pos,angles);
 
-		let res = unsafe {
+		let frame=vk_video::Frame{
-			encoder
+			data:wgpu_state.video_texture.clone(),
-				.encode(
+			pts:None,
-					vk_video::Frame {
-						data: wgpu_state.video_texture.clone(),
-						pts: None,
-					},
-					false,
-				)
-				.unwrap()
 		};
+		let res=unsafe{encoder.encode(frame,false)}
+			.map_err(EncodeError::VideoEncodeFrame)?;
 
-		output_file.write_all(&res.data).unwrap();
+		output_file.write_all(&res.data)
+			.map_err(EncodeError::OutputWriteFile)?;
 	}
 
 	Ok(())