kino-core 0.1.0

Core video player library - HLS/DASH parsing, buffer management, and playback control
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80

//! Basic playback example
//!
//! Demonstrates the Kino types and configuration.
//!
//! Run with: cargo run -p kino-core --example basic_playback

use kino_core::{
    PlayerConfig, PlayerState, Resolution,
    AbrAlgorithmType,
};

fn main() {
    println!("Kino Core - Basic Playback Example");
    println!("=========================================\n");

    // Create player configuration
    let config = PlayerConfig {
        min_buffer_time: 10.0,
        max_buffer_time: 30.0,
        abr_algorithm: AbrAlgorithmType::Bola,
        prefetch_enabled: true,
        ..Default::default()
    };

    println!("Configuration:");
    println!("  - ABR Algorithm: {:?}", config.abr_algorithm);
    println!("  - Buffer: {:.1}s - {:.1}s", config.min_buffer_time, config.max_buffer_time);
    println!("  - Prefetch: {}", config.prefetch_enabled);
    println!("  - Analytics: {}\n", config.analytics_enabled);

    // Simulate available quality levels
    let levels = vec![
        Resolution::new(854, 480),
        Resolution::new(1280, 720),
        Resolution::new(1920, 1080),
        Resolution::new(3840, 2160),
    ];

    println!("Available quality levels:");
    for level in &levels {
        println!("  - {} ({}x{})", level.quality_name(), level.width, level.height);
    }
    println!();

    // Demonstrate state transitions
    println!("Player State Transitions:");
    println!("--------------------------");

    let transitions = [
        (PlayerState::Idle, PlayerState::Loading),
        (PlayerState::Loading, PlayerState::Buffering),
        (PlayerState::Buffering, PlayerState::Playing),
        (PlayerState::Playing, PlayerState::Paused),
        (PlayerState::Paused, PlayerState::Playing),
        (PlayerState::Playing, PlayerState::Buffering),
        (PlayerState::Buffering, PlayerState::Playing),
        (PlayerState::Playing, PlayerState::Ended),
    ];

    for (from, to) in transitions {
        let can_transition = from.can_transition_to(to);
        let symbol = if can_transition { "✓" } else { "✗" };
        println!("  {} {:?} -> {:?}", symbol, from, to);
    }
    println!();

    // Show invalid transitions
    println!("Invalid Transitions (blocked by state machine):");
    let invalid = [
        (PlayerState::Idle, PlayerState::Playing),
        (PlayerState::Playing, PlayerState::Idle),
        (PlayerState::Ended, PlayerState::Playing),
    ];

    for (from, to) in invalid {
        println!("  ✗ {:?} -> {:?}", from, to);
    }

    println!("\nExample complete!");
}