Struct Analyzer

pub struct Analyzer<P: AsRef<Path>> { /* private fields */ }

Analyzes one or more videos and converts them into FrameHashes.

If threaded_decoding is set to true, video files will be distributed across multiple threads based on the number of CPUs available. If force is set, any existing frame hash data on disk will be ignored.

At a high-level, the analyzer does the following for a given video:

1. Extracts the most suitable audio stream
2. Decodes the audio frame-by-frame and resamples it for fingerprinting
3. Builds a fingerprint (or hash) based on the provided hash_duration
4. Returns a FrameHashes instance that contains the raw data and (optionally) writes it to disk alongside the video

Example

use std::path::PathBuf;
use needle::audio::Analyzer;

let video_paths: Vec<PathBuf> = get_sample_paths();
let analyzer = Analyzer::from_files(video_paths, false, false);
let frame_hashes = analyzer.run(1.0, 3.0, false).unwrap();

Implementations

impl<P: AsRef<Path>> Analyzer<P>

pub fn from_files( videos: impl Into<Vec<P>>, threaded_decoding: bool, force: bool, ) -> Self

Constructs a new Analyzer from a list of video paths.

pub fn videos(&self) -> &[P]

Returns the video paths used by this analyzer.

pub fn with_force(self, force: bool) -> Self

Returns a new Analyzer with force set to the provided value.

pub fn with_threaded_decoding(self, threaded_decoding: bool) -> Self

Returns a new Analyzer with thread_decoding set to the provided value.

impl<P: AsRef<Path> + Sync> Analyzer<P>

pub fn run( &self, hash_period: f32, hash_duration: f32, persist: bool, threading: bool, ) -> Result<Vec<FrameHashes>>

Runs this analyzer.

Trait Implementations

impl<P: Debug + AsRef<Path>> Debug for Analyzer<P>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<P: AsRef<Path>> Default for Analyzer<P>

fn default() -> Self

Returns the “default value” for a type.

impl<P: AsRef<Path>> From<Analyzer<P>> for Comparator<P>

fn from(analyzer: Analyzer<P>) -> Self

Constructs a Comparator from an Analyzer. This allows you to re-use the paths and destroy the Analyzer when you’re done with it.