Skip to content

armgit / Filee

Public Imported from GitHub
0

Free, open-source file converter. Convert 263 formats offline by drag & drop — images, PDF, Word, Excel, PowerPoint, HWP/HWPX, video, audio, e-books and archives. No upload, no Office needed.

18.1 KB
Raw Blame
// The clip window's editing without the window (ClipCutter) and what it hands the conversion (ClipEdit): the blade,
// pieces cut out with and without the magnet, volume and speed, silences taken out, undo, and the clip's length and
// times as played.

using System.Text.Json;
using Filee.Core.Presets;
using Filee.Core.Settings;

namespace Filee.Core.Tests;

public class ClipCutterTests
{
    /// <summary>A 5:12.4 video with the 30 seconds from 1:00 chosen.</summary>
    private static ClipCutter Cutter() => new(312.4, new ClipRange(60, 90));

    [Fact]
    public void A_new_clip_is_one_piece_as_recorded()
    {
        var cutter = Cutter();
        var piece = Assert.Single(cutter.Pieces);
        Assert.Equal(new ClipPiece(60, 90), piece);
        Assert.Equal(30, cutter.Length);
        Assert.False(cutter.CanUndo);
        var edit = cutter.ToEdit();
        Assert.True(edit.IsPlainCut);
        Assert.Equal((60.0, 90.0), (edit.Start, edit.End));
    }

    [Fact]
    public void The_blade_cuts_a_piece_in_two_but_not_next_to_a_cut()
    {
        var cutter = Cutter();
        Assert.True(cutter.Split(70));
        Assert.Equal([new ClipPiece(60, 70), new ClipPiece(70, 90)], cutter.Pieces);
        Assert.False(cutter.Split(70.05)); // too close to the cut
        Assert.False(cutter.Split(95)); // outside the clip
        Assert.False(cutter.Split(60)); // at the start
        Assert.Equal(0, cutter.IndexAt(65));
        Assert.Equal(1, cutter.IndexAt(70));
        Assert.Equal(-1, cutter.IndexAt(50));
        // Two pieces as recorded, one after the other: still one stretch to write, copied as it is.
        Assert.True(cutter.ToEdit().IsPlainCut);
    }

    [Fact]
    public void With_the_magnet_a_removed_piece_closes_up_without_it_a_pause_stays()
    {
        var cutter = Cutter();
        cutter.Split(70);
        cutter.Split(80);

        Assert.True(cutter.Remove(1, closeUp: true));
        Assert.Equal(20, cutter.Length);
        var edit = cutter.ToEdit();
        Assert.Equal([(60.0, 70.0, false), (80.0, 90.0, false)], edit.Parts.Select(p => (p.Start, p.End, p.Blank)));
        Assert.False(edit.IsPlainCut);

        Assert.True(cutter.Remove(1, closeUp: false));
        Assert.True(cutter.HasGaps);
        Assert.Equal(30, cutter.Length);
        Assert.Equal([false, true, false], cutter.ToEdit().Parts.Select(p => p.Blank));

        Assert.Equal(1, cutter.CloseGaps());
        Assert.False(cutter.HasGaps);
        Assert.Equal(20, cutter.Length);

        Assert.True(cutter.Restore(1));
        Assert.Equal(30, cutter.Length);
    }

    [Fact]
    public void The_last_piece_that_plays_cant_be_removed()
    {
        var cutter = Cutter();
        Assert.False(cutter.Remove(0, closeUp: true));
        cutter.Split(75);
        Assert.True(cutter.Remove(0, closeUp: true));
        Assert.False(cutter.Remove(1, closeUp: true));
        Assert.False(cutter.Remove(1, closeUp: false));
        Assert.Single(cutter.ToEdit().Parts);
    }

    [Fact]
    public void Volume_and_speed_belong_to_a_piece_and_speed_changes_the_length()
    {
        var cutter = Cutter();
        cutter.Split(70);
        cutter.SetSpeed(1, 2);
        cutter.SetVolume(0, 0.5);
        Assert.Equal(10 + 10, cutter.Length);
        cutter.SetSpeed(1, 99);
        Assert.Equal(ClipPart.MaxSpeed, cutter.Pieces[1].Speed);
        cutter.SetVolume(0, -1);
        Assert.Equal(0, cutter.Pieces[0].Volume);
        cutter.SetVolume(0, 9);
        Assert.Equal(ClipPart.MaxVolume, cutter.Pieces[0].Volume);

        var edit = cutter.ToEdit();
        Assert.Equal([(ClipPart.MaxVolume, 1.0), (1.0, ClipPart.MaxSpeed)], edit.Parts.Select(p => (p.Volume, p.Speed)));
        Assert.Equal(10 + 20 / ClipPart.MaxSpeed, edit.Length, 6);
    }

    [Fact]
    public void Moving_the_ends_keeps_the_cuts_inside_and_drops_what_falls_out()
    {
        var cutter = Cutter();
        cutter.Split(70);
        cutter.Split(80);
        cutter.SetVolume(2, 2);

        cutter.MoveStart(72);
        Assert.Equal([(72.0, 80.0), (80.0, 90.0)], cutter.Pieces.Select(p => (p.Start, p.End)));
        cutter.MoveEnd(100);
        Assert.Equal((80.0, 100.0, 2.0), (cutter.Pieces[1].Start, cutter.Pieces[1].End, cutter.Pieces[1].Volume));
        // An end left as a sliver joins its neighbour.
        cutter.MoveEnd(80.02);
        Assert.Equal([(72.0, 80.02)], cutter.Pieces.Select(p => (p.Start, Math.Round(p.End, 2))));

        // Past the other end: the clip goes along, as far as the video goes.
        var moving = Cutter();
        moving.Split(70);
        moving.MoveStart(300);
        Assert.Equal((300.0, 312.4), (moving.Start, moving.End));
        Assert.Equal(2, moving.Pieces.Count); // the cut came along: 300 + 10 = 310
        Assert.Equal(310, moving.Pieces[0].End, 6);
        moving.MoveEnd(3);
        Assert.Equal((0.0, 3.0), (moving.Start, moving.End));
    }

    [Fact]
    public void Moving_the_clip_and_quick_lengths_stay_in_the_video()
    {
        var cutter = Cutter();
        cutter.Split(70);
        cutter.Move(300);
        Assert.Equal((312.4 - 30, 312.4), (cutter.Start, cutter.End));
        Assert.Equal(cutter.Start + 10, cutter.Pieces[0].End, 6);
        cutter.Move(-4);
        Assert.Equal((0.0, 30.0), (cutter.Start, cutter.End));

        cutter.SetLength(60);
        Assert.Equal((0.0, 60.0), (cutter.Start, cutter.End));
        cutter.Move(290);
        cutter.SetLength(60);
        Assert.Equal((312.4 - 60, 312.4), (cutter.Start, cutter.End));
    }

    [Fact]
    public void Silences_are_taken_out_keeping_a_little_next_to_sound()
    {
        var cutter = Cutter();
        var removed = cutter.RemoveSilences([new ClipRange(55, 62), new ClipRange(70, 73), new ClipRange(80, 80.3), new ClipRange(88, 95)]);

        Assert.Equal(3, removed); // the 0.3-second pause stays
        var edit = cutter.ToEdit();
        var p = ClipCutter.SilencePadding;
        Assert.Equal([(62 - p, 70 + p), (73 - p, 88 + p)], edit.Parts.Select(x => (Math.Round(x.Start, 6), Math.Round(x.End, 6))));
        // At the clip's ends the silence goes entirely (no sound next to it there).
        Assert.Equal(30 - (2 - p) - (3 - 2 * p) - (2 - p), cutter.Length, 6);

        // One undo puts them all back.
        Assert.True(cutter.Undo());
        Assert.Equal(30, cutter.Length);
        Assert.True(cutter.Redo());
        Assert.Equal(edit.Length, cutter.Length, 6);

        // All silent: something stays.
        var quiet = Cutter();
        Assert.Equal(0, quiet.RemoveSilences([new ClipRange(0, 312.4)]));
        Assert.Equal(30, quiet.Length);
    }

    [Fact]
    public void Every_change_can_be_undone_and_redone()
    {
        var cutter = Cutter();
        var changes = 0;
        cutter.Changed += () => changes++;
        cutter.Split(70);
        cutter.Remove(0, closeUp: true);
        cutter.FadeIn = 1;
        cutter.FadeOut = 99;
        Assert.Equal(ClipEdit.MaxFade, cutter.FadeOut);
        Assert.Equal(4, changes);

        Assert.True(cutter.Undo());
        Assert.Equal(0, cutter.FadeOut);
        Assert.True(cutter.Undo());
        Assert.True(cutter.Undo());
        Assert.Equal(30, cutter.Length);
        Assert.True(cutter.Undo());
        Assert.Single(cutter.Pieces);
        Assert.False(cutter.Undo());
        Assert.True(cutter.Redo());
        Assert.Equal(2, cutter.Pieces.Count);
        // A volume slider dragged is one step.
        cutter.SetVolume(1, 0.9);
        cutter.SetVolume(1, 0.8);
        cutter.SetVolume(1, 0.7);
        Assert.True(cutter.Undo());
        Assert.Equal(1, cutter.Pieces[1].Volume);
        // A new change after undoing forgets what could be redone.
        cutter.SetVolume(0, 2);
        Assert.False(cutter.CanRedo);
        // Moving to where it is already is no change.
        changes = 0;
        cutter.MoveStart(cutter.Start);
        cutter.SetVolume(0, 2);
        Assert.Equal(0, changes);
    }

    [Fact]
    public void A_pieces_sound_can_be_muted_while_its_picture_plays()
    {
        var cutter = Cutter();
        cutter.Split(70);
        cutter.SetMuted(1, true);
        Assert.True(cutter.Pieces[1].Muted);
        var edit = cutter.ToEdit();
        Assert.Equal([false, true], edit.Parts.Select(p => p.Muted));
        Assert.Equal(0, edit.Parts[1].PlayVolume);
        Assert.Equal(1, edit.Parts[1].Volume); // kept for unmuting
        Assert.False(edit.IsPlainCut);
        Assert.Equal(30, cutter.Length); // the picture still plays
        cutter.SetMuted(1, false);
        Assert.True(cutter.ToEdit().IsPlainCut);
    }

    [Fact]
    public void A_gap_is_closed_on_its_own()
    {
        var cutter = Cutter();
        cutter.Split(70);
        cutter.Split(80);
        cutter.Remove(0, closeUp: false);
        cutter.Remove(1, closeUp: false);
        Assert.True(cutter.CloseGap(1));
        Assert.Equal([ClipPieceState.Blank, ClipPieceState.Removed, ClipPieceState.Kept], cutter.Pieces.Select(p => p.State));
        Assert.False(cutter.CloseGap(2)); // not a gap
        Assert.Equal(20, cutter.Length);
    }

    [Fact]
    public void Dragging_an_edge_out_takes_back_what_was_cut_next_to_it()
    {
        var cutter = Cutter();
        cutter.Split(70);
        cutter.Split(80);
        cutter.Remove(1, closeUp: true); // [60-70][70-80 out][80-90]
        Assert.Equal(20, cutter.Length);

        // A little back.
        cutter.TrimEdge(0, end: true, 74);
        Assert.Equal([(60.0, 74.0, true), (74.0, 80.0, false), (80.0, 90.0, true)], cutter.Pieces.Select(p => (p.Start, p.End, p.IsKept)));
        Assert.Equal(24, cutter.Length);
        // All of it back: the piece cut out is used up, the cut lands on the next piece.
        cutter.TrimEdge(0, end: true, 80);
        Assert.Equal([(60.0, 80.0), (80.0, 90.0)], cutter.Pieces.Select(p => (p.Start, p.End)));
        Assert.Equal(30, cutter.Length);
        // The whole drag is one undo step.
        Assert.True(cutter.Undo());
        Assert.Equal(20, cutter.Length);

        // The next piece's start pulled back to the left.
        cutter.TrimEdge(2, end: false, 76);
        Assert.Equal([(60.0, 70.0, true), (70.0, 76.0, false), (76.0, 90.0, true)], cutter.Pieces.Select(p => (p.Start, p.End, p.IsKept)));
    }

    [Fact]
    public void Dragging_an_edge_in_cuts_that_much_out()
    {
        var cutter = Cutter();
        cutter.Split(70); // [60-70][70-90], both play
        cutter.TrimEdge(0, end: true, 65);
        Assert.Equal([(60.0, 65.0, true), (65.0, 70.0, false), (70.0, 90.0, true)], cutter.Pieces.Select(p => (p.Start, p.End, p.IsKept)));
        Assert.Equal(25, cutter.Length);

        var other = Cutter();
        other.Split(70);
        other.TrimEdge(1, end: false, 75);
        Assert.Equal([(60.0, 70.0, true), (70.0, 75.0, false), (75.0, 90.0, true)], other.Pieces.Select(p => (p.Start, p.End, p.IsKept)));
        // Never shorter than the least length.
        other.TrimEdge(2, end: false, 95);
        Assert.Equal(90 - ClipRange.MinLength, other.Pieces[^1].Start, 6);
    }

    [Fact]
    public void The_clips_outer_edges_reach_further_into_the_video()
    {
        var cutter = Cutter();
        cutter.Split(70);
        Assert.Equal(100, cutter.TrimEdge(1, end: true, 100));
        Assert.Equal(50, cutter.TrimEdge(0, end: false, 50));
        Assert.Equal((50.0, 100.0), (cutter.Start, cutter.End));
        Assert.Equal(312.4, cutter.TrimEdge(1, end: true, 999));
    }

    [Fact]
    public void Music_goes_under_the_clip_and_moves_and_changes_volume_with_undo()
    {
        var cutter = Cutter();
        cutter.SetMusic(new ClipMusic { Path = "song.mp3", Length = 200 });
        Assert.Equal(ClipMusic.DefaultVolume, cutter.Music!.Volume);
        cutter.MoveMusic(5);
        cutter.MoveMusic(8);
        cutter.SetMusicVolume(0.3);
        cutter.SetMusicVolume(0.25);
        cutter.MoveMusic(999);
        Assert.Equal(30 - ClipRange.MinLength, cutter.Music!.Offset, 6);
        var edit = cutter.ToEdit();
        Assert.Equal(("song.mp3", 0.25), (edit.Music!.Path, edit.Music.Volume));
        Assert.False(edit.IsPlainCut);

        Assert.True(cutter.Undo()); // the last move
        Assert.Equal(8, cutter.Music!.Offset);
        Assert.True(cutter.Undo()); // the volume drag at once
        Assert.Equal(ClipMusic.DefaultVolume, cutter.Music!.Volume);
        Assert.True(cutter.Undo()); // both moves at once
        Assert.Equal(0, cutter.Music!.Offset);
        Assert.True(cutter.Undo());
        Assert.Null(cutter.Music);
    }

    [Fact]
    public void Music_plays_while_both_last_and_keeps_its_place_when_playing_from_later()
    {
        var music = new ClipMusic { Path = "song.mp3", Offset = 4, From = 10, Length = 20 };
        Assert.Equal(10, music.PlayLength(30)); // the song ends first
        Assert.Equal(6, music.PlayLength(10)); // the clip ends first

        var edit = ClipEdit.Of(new ClipRange(0, 30));
        edit.Music = music;
        var later = edit.From(7);
        Assert.Equal((0.0, 13.0), (later.Music!.Offset, later.Music.From));
        var sooner = edit.From(1);
        Assert.Equal((3.0, 10.0), (sooner.Music!.Offset, sooner.Music.From));

        // Music past the clip's end isn't written.
        edit.Music = new ClipMusic { Path = "song.mp3", Offset = 40, Length = 20 };
        Assert.Null(edit.Clamped(100).Music);
        edit.Music = new ClipMusic { Path = "song.mp3", Offset = -3, Volume = 9, Length = 20 };
        Assert.Equal((0.0, 2.0), (edit.Clamped(100).Music!.Offset, edit.Clamped(100).Music!.Volume));
    }

    [Fact]
    public void Several_changes_in_a_batch_are_one_undo_step()
    {
        var cutter = Cutter();
        cutter.Split(70);
        cutter.Split(80);
        var told = 0;
        cutter.Changed += () => told++;
        cutter.Batch(() =>
        {
            cutter.Remove(0, closeUp: false);
            cutter.Remove(2, closeUp: false);
            cutter.SetVolume(1, 1.5);
        });
        Assert.Equal(1, told);
        Assert.Equal([ClipPieceState.Blank, ClipPieceState.Kept, ClipPieceState.Blank], cutter.Pieces.Select(p => p.State));
        Assert.True(cutter.Undo());
        Assert.All(cutter.Pieces, p => Assert.True(p.IsKept && p.Volume == 1));
        Assert.Equal(2, cutter.Pieces.Count(p => p.Start > 60)); // the cuts stay: they were made before
        // A batch that changes nothing leaves nothing to undo.
        var steps = 0;
        while (cutter.Undo())
            steps++;
        cutter.Batch(() => cutter.SetVolume(0, 1));
        Assert.False(cutter.CanUndo);
        Assert.Equal(2, steps);
    }

    // ───────────────────────── The edit ─────────────────────────

    private static ClipEdit Edit() => new()
    {
        Parts =
        [
            new ClipPart { Start = 10, End = 20 },
            new ClipPart { Start = 20, End = 24, Blank = true },
            new ClipPart { Start = 30, End = 40, Speed = 2 },
        ],
        FadeIn = 1,
        FadeOut = 2,
    };

    [Fact]
    public void A_clip_plays_its_parts_pauses_and_speeds()
    {
        var edit = Edit();
        Assert.Equal(10 + 4 + 5, edit.Length);
        Assert.Equal((10.0, 40.0), (edit.Start, edit.End));
        Assert.False(edit.IsPlainCut);

        Assert.Equal(15, edit.SourceTimeAt(5));
        Assert.Equal(22, edit.SourceTimeAt(12)); // in the pause
        Assert.Equal(34, edit.SourceTimeAt(16)); // two seconds of video a second
        Assert.Equal(40, edit.SourceTimeAt(99));
        Assert.Equal(5, edit.ClipTimeAt(15));
        Assert.Equal(16, edit.ClipTimeAt(34));
        Assert.Equal(14, edit.ClipTimeAt(27)); // cut out: where the next part starts
    }

    [Fact]
    public void Playing_from_later_starts_in_the_part_then_playing()
    {
        var rest = Edit().From(16);
        var part = Assert.Single(rest.Parts);
        Assert.Equal((34.0, 40.0, 2.0), (part.Start, part.End, part.Speed));
        Assert.Equal(3, rest.Length);
        Assert.Equal(0, rest.FadeIn);
        Assert.Equal(2, rest.FadeOut);
        Assert.Equal(0.5, Edit().From(0.5).FadeIn); // still fading in
        Assert.Equal(Edit().Length, Edit().From(0).Length);
    }

    [Fact]
    public void Clamping_keeps_parts_in_the_video_in_order_and_drops_pauses_at_the_ends()
    {
        var edit = new ClipEdit
        {
            Parts =
            [
                new ClipPart { Start = 0, End = 2, Blank = true },
                new ClipPart { Start = 5, End = 8, Speed = 99, Volume = double.NaN },
                new ClipPart { Start = 7, End = 12 }, // overlaps the one before
                new ClipPart { Start = 12, End = 12.05 }, // too short
                new ClipPart { Start = 290, End = 400 }, // past the end
                new ClipPart { Start = 400, End = 410, Blank = true },
            ],
            FadeIn = 99,
            FadeOut = -3,
        }.Clamped(300);

        Assert.Equal([(5.0, 8.0), (8.0, 12.0), (290.0, 300.0)], edit.Parts.Select(p => (p.Start, p.End)));
        Assert.Equal((ClipPart.MaxSpeed, 1.0), (edit.Parts[0].Speed, edit.Parts[0].Volume));
        Assert.Equal(Math.Min(ClipEdit.MaxFade, edit.Length / 2), edit.FadeIn); // at most half the clip
        Assert.Equal(0, edit.FadeOut);
        // Fades are at most half the clip.
        var shortClip = ClipEdit.Of(new ClipRange(0, 4));
        shortClip.FadeIn = 5;
        Assert.Equal(2, shortClip.Clamped(10).FadeIn);
        Assert.Throws<InvalidOperationException>(() => ClipEdit.Of(new ClipRange(400, 410)).Clamped(300));
    }

    [Fact]
    public void A_clip_survives_saving_with_its_conversion()
    {
        var conversion = ClipTool.ConversionOf(BuiltInData.CreatePresets().Single(p => p.Id == "tool-clip"), "mp4", Edit());
        var json = JsonSerializer.Serialize(new List<Preset> { conversion }, FileeJsonContext.Default.ListPreset);
        var read = JsonSerializer.Deserialize(json, FileeJsonContext.Default.ListPreset)!.Single().Media.Clip!;
        Assert.Equal(Edit().Parts.Select(p => (p.Start, p.End, p.Blank, p.Speed)), read.Parts.Select(p => (p.Start, p.End, p.Blank, p.Speed)));
        Assert.Equal((1.0, 2.0), (read.FadeIn, read.FadeOut));
        // A copy of the preset is a copy of its clip too.
        var copy = conversion.Clone();
        copy.Media.Clip!.Parts[0].Start = 0;
        Assert.Equal(10, conversion.Media.Clip!.Parts[0].Start);
    }
}