write more code

1 files changed, 0 insertions, 133 deletions

diff --git a/tools/src/bin/gen_meta.rs b/tools/src/bin/gen_meta.rs
deleted file mode 100644
index 4abbb8b..0000000
--- a/tools/src/bin/gen_meta.rs
+++ /dev/null
@@ -1,133 +0,0 @@
-use anyhow::{anyhow, bail};
-use clap::Parser;
-use jellycommon::{ItemInfo, Source, SourceTrack, SourceTrackKind};
-use jellyebml::{
-    matroska::MatroskaTag,
-    read::EbmlReader,
-    unflatten::{Unflat, Unflatten},
-    Master,
-};
-use log::error;
-use std::{collections::BTreeMap, fs::File, io::Write, path::PathBuf};
-
-#[derive(Parser)]
-struct Args {
-    #[clap(short = 'I', long)]
-    identifier: String,
-    #[clap(short = 'O', long)]
-    write_json: bool,
-    #[clap(short, long)]
-    title: String,
-    #[clap(short = 'i', long)]
-    input: PathBuf,
-}
-
-fn main() -> anyhow::Result<()> {
-    env_logger::init_from_env("LOG");
-    let args = Args::parse();
-
-    let mut tracks = BTreeMap::new();
-    let input = File::open(args.input.clone()).unwrap();
-    let mut input = EbmlReader::new(input);
-
-    // TODO dont traverse the entire file, if the tracks are listed at the end
-    while let Some(item) = input.next() {
-        let item = item?;
-        match item {
-            MatroskaTag::Tracks(_) => {
-                let mut iter = Unflatten::new(&mut input);
-                while let Some(Ok(Unflat { children, item })) = iter.next() {
-                    if !matches!(item, MatroskaTag::TrackEntry(_)) {
-                        panic!("no")
-                    }
-                    let mut children = children.unwrap();
-                    let (
-                        mut index,
-                        mut language,
-                        mut codec,
-                        mut kind,
-                        mut sample_rate,
-                        mut channels,
-                        mut width,
-                        mut height,
-                        mut name,
-                    ) = (None, None, None, None, None, None, None, None, None);
-                    while let Some(Ok(Unflat { children, item })) = children.next() {
-                        match item {
-                            MatroskaTag::CodecID(b) => codec = Some(b),
-                            MatroskaTag::Language(v) => language = Some(v),
-                            MatroskaTag::TrackNumber(v) => index = Some(v),
-                            MatroskaTag::TrackType(v) => kind = Some(v),
-                            MatroskaTag::Name(v) => name = Some(v),
-                            MatroskaTag::Audio(_) => {
-                                let mut children = children.unwrap();
-                                while let Some(Ok(Unflat { item, .. })) = children.next() {
-                                    match item {
-                                        MatroskaTag::Channels(v) => channels = Some(v as usize),
-                                        MatroskaTag::SamplingFrequency(v) => sample_rate = Some(v),
-                                        _ => (),
-                                    }
-                                }
-                            }
-                            MatroskaTag::Video(_) => {
-                                let mut children = children.unwrap();
-                                while let Some(Ok(Unflat { item, .. })) = children.next() {
-                                    match item {
-                                        MatroskaTag::PixelWidth(v) => width = Some(v),
-                                        MatroskaTag::PixelHeight(v) => height = Some(v),
-                                        _ => (),
-                                    }
-                                }
-                            }
-                            _ => (),
-                        }
-                    }
-                    tracks.insert(
-                        index.unwrap(),
-                        SourceTrack {
-                            name: name.unwrap_or_else(|| "unnamed".to_string()),
-                            codec: codec.unwrap(),
-                            language: language.unwrap_or_else(|| "none".to_string()),
-                            kind: match kind.ok_or(anyhow!("track type required"))? {
-                                1 => SourceTrackKind::Video {
-                                    fps: 0.0, // TODO
-                                    width: width.unwrap(),
-                                    height: height.unwrap(),
-                                },
-                                2 => SourceTrackKind::Audio {
-                                    bit_depth: 0, // TODO
-                                    channels: channels.unwrap(),
-                                    sample_rate: sample_rate.unwrap(),
-                                },
-                                17 => SourceTrackKind::Subtitles,
-                                _ => bail!("invalid track type"),
-                            },
-                        },
-                    );
-                }
-                error!("break!");
-                drop(iter);
-                error!("break done!");
-                break;
-            }
-            _ => (),
-        }
-    }
-
-    let k = serde_json::to_string_pretty(&ItemInfo {
-        title: args.title,
-        source: Source {
-            path: args.input.clone(),
-            tracks,
-        },
-    })?;
-
-    if args.write_json {
-        let mut f = File::create(format!("{}.json", args.identifier))?;
-        f.write_all(k.as_bytes())?;
-    } else {
-        println!("{k}")
-    }
-
-    Ok(())
-}