wave-edit/sound_state.py at master · zeropointnine/wave-edit · GitHub

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
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
import os
from pathlib import Path

from sound import Sound
from segments import Segments
from util import clamp


class SoundState:
    """
    Wraps correlated properties that make up the state of a loaded sound in the app:
    - File path
    - Sound
    - Start/end pos
    - Segments
    """

    _segments: Segments | None = None
    _sound_dirty: bool = False

    def __init__(self, file_path: str, sound: Sound | None):

        self._file_path = file_path

        self._is_set_sound_init = True
        self.sound = sound
        self._is_set_sound_init = False

        self._subtitle_segments: Segments | None = None
        if self._file_path:
            srt_path = str( Path(self._file_path).with_suffix(".srt") )
            if os.path.exists(srt_path):
                self._subtitle_segments = Segments.load_from_srt_file(srt_path) or None

    @property
    def file_path(self) -> str:
        """ Read-only """
        return self._file_path

    @property
    def sound(self) -> Sound | None:
        return self._sound

    @sound.setter
    def sound(self, value: Sound | None) -> None:
        """
        Setting sound also initializes dependent values (including segments 'file state')
        Note special case where sound is being set on-init using flag _is_set_sound_init (eww)
        """
        self._sound = value

        if self._sound:
            self._min_max_position = (0.0, self._sound.duration)

            if not self._is_set_sound_init:
                # Changing sound 'invalidates' segments
                assert self._segments is not None
                self._segments.segments.clear()
                self._segments.delete_json()
                self._sound_dirty = True

            self._segments = Segments(self._file_path, self._sound.duration)

        else:
            self._min_max_position = (0.0, 0.0)
            json_path = Segments.make_json_path_using(self._file_path)
            Segments.delete_json_at_path(json_path)
            self._segments = None

    @property
    def has_sound(self) -> bool:
        return self._sound is not None

    @property
    def duration(self) -> float:
        return self._sound.duration if self._sound else 0.0

    @property
    def sound_dirty(self) -> bool:
        """ Simple 'dirty' flag, must be turned on/off manually """
        return self._sound_dirty

    @sound_dirty.setter
    def sound_dirty(self, value: bool) -> None:
        self._sound_dirty = value

    # Segments

    @property
    def segments(self) -> Segments | None:
        return self._segments

    @segments.setter
    def segments(self, value: Segments | None) -> None:
        self._segments = value

    @property
    def has_segments(self) -> bool:
        return self._segments is not None and bool(self._segments.segments)

    @property
    def num_segments(self) -> int:
        return len(self._segments.segments) if self._segments else 0

    def delete_segment_at(self, index: int) -> None:
        if self._segments:
            self._segments.delete_at(index)

    def insert_segment(self, start: float, end: float, can_merge: bool=False) -> int:
        if self._segments:
            return self._segments.insert(start, end, can_merge)
        else:
            return -1

    def index_of_segment(self, position: float) -> int:
        if self._segments:
            return self._segments.index_of(position)
        else:
            return -1

    def invert_segments(self) -> None:
        if self._sound is None or self._segments is None:
            return
        self._segments.invert()
        self._segments._dirty = True

    # Subtitles

    @property
    def subtitle_segments(self) -> Segments | None:
        return self._subtitle_segments

    @subtitle_segments.setter
    def subtitle_segments(self, value: Segments) -> None:
        self._subtitle_segments = value

    def get_subtitle_at(self, position: float) -> str:
        if not self._subtitle_segments:
            return ""
        i = self._subtitle_segments.index_of(position)
        if i == -1:
            return ""
        data = self._subtitle_segments.segments[i].data
        return data if isinstance(data, str) else ""

    # === Start/end

    @property
    def min_max_position(self) -> tuple[float, float]:
        return self._min_max_position

    def set_min_max_position(self, value: tuple[float, float]) -> bool:
        """Set start/end position with validation. Returns True if successful."""
        if not self._sound:
            return False
        min_position, max_position = value
        min_position = clamp(min_position, 0.0, self._sound.duration)
        max_position = clamp(max_position, 0.0, self._sound.duration)
        if min_position >= max_position:
            return False
        self._min_max_position = (min_position, max_position)
        return True