emacs-elpa-diffs
[Top][All Lists]
Advanced

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

[nongnu] elpa/subed fe09133aa5 6/8: Untabify everything


From: ELPA Syncer
Subject: [nongnu] elpa/subed fe09133aa5 6/8: Untabify everything
Date: Sun, 18 Jun 2023 16:02:31 -0400 (EDT)

branch: elpa/subed
commit fe09133aa562b1f0ce6ec636dc31b957ffa075ee
Author: Sacha Chua <sacha@sachachua.com>
Commit: Sacha Chua <sacha@sachachua.com>

    Untabify everything
---
 .dir-locals.el          |   2 +
 subed/subed-align.el    |   4 +-
 subed/subed-ass.el      |   4 +-
 subed/subed-common.el   | 460 ++++++++++++++++++++++++------------------------
 subed/subed-config.el   |   8 +-
 subed/subed-mpv.el      |  34 ++--
 subed/subed-srt.el      |   4 +-
 subed/subed-tsv.el      |   8 +-
 subed/subed-vtt.el      |   6 +-
 subed/subed-waveform.el | 242 ++++++++++++-------------
 10 files changed, 387 insertions(+), 385 deletions(-)

diff --git a/.dir-locals.el b/.dir-locals.el
new file mode 100644
index 0000000000..3a491ef96b
--- /dev/null
+++ b/.dir-locals.el
@@ -0,0 +1,2 @@
+((emacs-lisp-mode
+  (indent-tabs-mode . nil)))
diff --git a/subed/subed-align.el b/subed/subed-align.el
index 4c8def2adb..bb25d545e5 100644
--- a/subed/subed-align.el
+++ b/subed/subed-align.el
@@ -95,7 +95,7 @@ Return a buffer with FORMAT."
         (goto-char (point-min))
         (flush-lines "^[0-9]+$")
         ;; reinsert comments
-                               (subed-align-reinsert-comments subtitles)))))
+        (subed-align-reinsert-comments subtitles)))))
 
 (defun subed-align-reinsert-comments (subtitles)
   "Reinsert the comments from SUBTITLES."
@@ -105,7 +105,7 @@ Return a buffer with FORMAT."
      (when (elt sub 4)
        ;; find the first subtitle that matches the sub, although the times may 
have changed.
        ;; Probably the midpoint of the subtitle will still be within the sub
-                        ;; TODO: Accommodate comments in other formats
+       ;; TODO: Accommodate comments in other formats
        (when (subed-jump-to-subtitle-id-at-msecs (/ (+ (elt sub 2) (elt sub 
1)) 2))
          (insert (elt sub 4)))))
    subtitles))
diff --git a/subed/subed-ass.el b/subed/subed-ass.el
index 9f534ad0b3..9e26057e57 100644
--- a/subed/subed-ass.el
+++ b/subed/subed-ass.el
@@ -273,8 +273,8 @@ function for MAJOR-MODE."
             (subed-jump-to-subtitle-text)
             (delete-region pos (point))
             (insert " ")
-                                               (let 
((subed-enforce-time-boundaries nil))
-                                                       
(subed-set-subtitle-time-stop new-end)))
+            (let ((subed-enforce-time-boundaries nil))
+              (subed-set-subtitle-time-stop new-end)))
         (error "No subtitle to merge into")))))
 
 (cl-defmethod subed--auto-insert (&context (major-mode subed-ass-mode))
diff --git a/subed/subed-common.el b/subed/subed-common.el
index 0e465e3152..3c683042c8 100644
--- a/subed/subed-common.el
+++ b/subed/subed-common.el
@@ -349,9 +349,9 @@ If SUB-ID is not given, set the text of the current 
subtitle."
   nil)
 
 (subed-define-generic-function set-subtitle-time-start (msecs
-                                                                               
                                                                                
                                                                &optional sub-id
-                                                                               
                                                                                
                                                                
ignore-negative-duration
-                                                                               
                                                                                
                                                                ignore-overlap)
+                                                        &optional sub-id
+                                                        
ignore-negative-duration
+                                                        ignore-overlap)
   "Set subtitle start time to MSECS milliseconds.
 
 If SUB-ID is not given, set the start of the current subtitle.
@@ -369,66 +369,66 @@ Return the new subtitle start time in milliseconds."
   (save-excursion
     (when (or (not sub-id)
               (and sub-id (subed-jump-to-subtitle-id sub-id)))
-                       (when (< msecs 0)
-                               (if     (eq subed-enforce-time-boundaries 
'error)
-                                               (error "Start time %d is 
negative." msecs)
-                                       (setq msecs 0)))
-                       (when (and
-                                                (not ignore-negative-duration)
-                                                subed-enforce-time-boundaries
-                                                (> msecs 
(subed-subtitle-msecs-stop)))
-                               (pcase subed-enforce-time-boundaries
-                                       ('error
-                                        (error "Start time %s will be after 
stop time %s"
-                                                                       
(subed-msecs-to-timestamp msecs)
-                                                                       
(subed-msecs-to-timestamp (subed-subtitle-msecs-stop))))
-                                       ('clip
-                                        (setq msecs 
(subed-subtitle-msecs-stop))
-                                        (message "Clipping to %s" 
(subed-msecs-to-timestamp msecs)))
-                                       ('adjust
-                                        (let ((subed-enforce-time-boundaries 
nil))
-                                                (subed-set-subtitle-time-stop 
msecs)
-                                                (message "Adjusted stop time 
to %s to avoid negative duration"
-                                                                               
        (subed-msecs-to-timestamp (subed-subtitle-msecs-stop)))))))
-                       (when (and subed-enforce-time-boundaries
-                                                                (not 
ignore-overlap))
-                               (subed-save-excursion
-                                (when (and (subed-backward-subtitle-time-stop)
-                                                                               
subed-subtitle-spacing
-                                                                               
(> (subed-subtitle-msecs-stop)
-                                                                               
         (- msecs subed-subtitle-spacing)))
-                                        (pcase subed-enforce-time-boundaries
-                                                ('error
-                                                       (error "Start time %s 
will be too close to previous stop time of %s"
-                                                                               
 (subed-msecs-to-timestamp msecs)
-                                                                               
 (subed-msecs-to-timestamp (subed-subtitle-msecs-stop))))
-                                                ('clip
-                                                       (setq msecs (+ 
(subed-subtitle-msecs-stop) subed-subtitle-spacing))
-                                                       (message "Clipping to 
%s to maintain spacing from previous stop time of %s"
-                                                                               
         msecs
-                                                                               
         (subed-subtitle-msecs-stop)))
-                                                ('adjust
-                                                       (let 
((subed-enforce-time-boundaries nil))
-                                                               
(subed-set-subtitle-time-stop (- msecs subed-subtitle-spacing))
-                                                               (message 
"Adjusted previous stop time to %s to maintain spacing"
-                                                                               
                 (subed-msecs-to-timestamp (subed-subtitle-msecs-stop)))))))))
-                       ;; Update loop start if it's within the current subtitle
-                       (when (and subed--subtitle-loop-start
-                                                                (>= 
subed--subtitle-loop-start
-                                                                               
(floor (- (subed-subtitle-msecs-start)
-                                                                               
                                        (* 1000 (or subed-loop-seconds-before 
0)))))
-                                                                (< 
subed--subtitle-loop-start (subed-subtitle-msecs-stop)))
-                               (setq subed--subtitle-loop-start
-                                                       (floor (- msecs (* 1000 
(or subed-loop-seconds-before 0))))))
-                       (when (and (subed-jump-to-subtitle-time-start sub-id)
+      (when (< msecs 0)
+        (if (eq subed-enforce-time-boundaries 'error)
+            (error "Start time %d is negative." msecs)
+          (setq msecs 0)))
+      (when (and
+             (not ignore-negative-duration)
+             subed-enforce-time-boundaries
+             (> msecs (subed-subtitle-msecs-stop)))
+        (pcase subed-enforce-time-boundaries
+          ('error
+           (error "Start time %s will be after stop time %s"
+                  (subed-msecs-to-timestamp msecs)
+                  (subed-msecs-to-timestamp (subed-subtitle-msecs-stop))))
+          ('clip
+           (setq msecs (subed-subtitle-msecs-stop))
+           (message "Clipping to %s" (subed-msecs-to-timestamp msecs)))
+          ('adjust
+           (let ((subed-enforce-time-boundaries nil))
+             (subed-set-subtitle-time-stop msecs)
+             (message "Adjusted stop time to %s to avoid negative duration"
+                      (subed-msecs-to-timestamp 
(subed-subtitle-msecs-stop)))))))
+      (when (and subed-enforce-time-boundaries
+                 (not ignore-overlap))
+        (subed-save-excursion
+         (when (and (subed-backward-subtitle-time-stop)
+                    subed-subtitle-spacing
+                    (> (subed-subtitle-msecs-stop)
+                       (- msecs subed-subtitle-spacing)))
+           (pcase subed-enforce-time-boundaries
+             ('error
+              (error "Start time %s will be too close to previous stop time of 
%s"
+                     (subed-msecs-to-timestamp msecs)
+                     (subed-msecs-to-timestamp (subed-subtitle-msecs-stop))))
+             ('clip
+              (setq msecs (+ (subed-subtitle-msecs-stop) 
subed-subtitle-spacing))
+              (message "Clipping to %s to maintain spacing from previous stop 
time of %s"
+                       msecs
+                       (subed-subtitle-msecs-stop)))
+             ('adjust
+              (let ((subed-enforce-time-boundaries nil))
+                (subed-set-subtitle-time-stop (- msecs subed-subtitle-spacing))
+                (message "Adjusted previous stop time to %s to maintain 
spacing"
+                         (subed-msecs-to-timestamp 
(subed-subtitle-msecs-stop)))))))))
+      ;; Update loop start if it's within the current subtitle
+      (when (and subed--subtitle-loop-start
+                 (>= subed--subtitle-loop-start
+                    (floor (- (subed-subtitle-msecs-start)
+                              (* 1000 (or subed-loop-seconds-before 0)))))
+                 (< subed--subtitle-loop-start (subed-subtitle-msecs-stop)))
+        (setq subed--subtitle-loop-start
+              (floor (- msecs (* 1000 (or subed-loop-seconds-before 0))))))
+      (when (and (subed-jump-to-subtitle-time-start sub-id)
                  (looking-at subed--regexp-timestamp))
         (replace-match
          (save-match-data (subed-msecs-to-timestamp msecs)))
-                               (subed-subtitle-msecs-start)))))
+        (subed-subtitle-msecs-start)))))
 
 (subed-define-generic-function set-subtitle-time-stop (msecs &optional sub-id
-                                                                               
                                                                                
                                                                                
 ignore-negative-duration
-                                                                               
                                                                                
                                                                                
 ignore-overlap)
+                                                             
ignore-negative-duration
+                                                             ignore-overlap)
   "Set subtitle stop time to MSECS milliseconds.
 
 If SUB-ID is not given, set the stop of the current subtitle.
@@ -445,61 +445,61 @@ checking.
 
 Return the new subtitle stop time in milliseconds."
   (save-excursion
-               (when (or (not sub-id)
+    (when (or (not sub-id)
               (and sub-id (subed-jump-to-subtitle-id sub-id)))
-                       (let ((current-start (subed-subtitle-msecs-start)))
-                               (when (subed-jump-to-subtitle-time-stop sub-id)
-                                       (when (and subed-enforce-time-boundaries
-                                                                               
 (not ignore-negative-duration)
-                                                                               
 (< msecs current-start))
-                                               (pcase 
subed-enforce-time-boundaries
-                                                       ('error
-                                                        (error "Stop time %s 
will be before start time %s"
-                                                                               
        (subed-msecs-to-timestamp msecs)
-                                                                               
        (subed-msecs-to-timestamp current-start)))
-                                                       ('clip
-                                                        (message "Clipping 
time to %s" (subed-msecs-to-timestamp current-start))
-                                                        (setq msecs 
(subed-subtitle-msecs-start)))
-                                                       ('adjust
-                                                        (let 
((subed-enforce-time-boundaries nil))
-                                                                
(subed-set-subtitle-time-start msecs)
-                                                                (message 
"Adjusted start time to %s to avoid negative duration"
-                                                                               
                        (subed-msecs-to-timestamp current-start))))))))
-                       (when (and subed-enforce-time-boundaries
-                                                                (not 
ignore-overlap))
-                               (subed-save-excursion
-                                (when (and (subed-forward-subtitle-time-stop)
-                                                                               
subed-subtitle-spacing
-                                                                               
(< (subed-subtitle-msecs-start)
-                                                                               
         (+ msecs subed-subtitle-spacing)))
-                                        (pcase subed-enforce-time-boundaries
-                                                ('error
-                                                       (error "Stop time %s 
will be too close to next start time of %s"
-                                                                               
 (subed-msecs-to-timestamp msecs)
-                                                                               
 (subed-msecs-to-timestamp (subed-subtitle-msecs-start))))
-                                                ('clip
-                                                       (setq msecs (- 
(subed-subtitle-msecs-start) subed-subtitle-spacing))
-                                                       (message "Clipping to 
%s to preserve spacing"
-                                                                               
         (subed-msecs-to-timestamp msecs)))
-                                                ('adjust
-                                                       (let 
((subed-enforce-time-boundaries nil))
-                                                               
(subed-set-subtitle-time-start (+ msecs subed-subtitle-spacing))
-                                                               (message 
"Adjusted next start time to %s to maintain spacing"
-                                                                               
                 (subed-msecs-to-timestamp (subed-subtitle-msecs-start)))))))))
-                       ;; Update loop end if it's within the current subtitle
-                       (when (and subed--subtitle-loop-stop
-                                                                (> 
subed--subtitle-loop-stop (subed-subtitle-msecs-start))
-                                                                (<= 
subed--subtitle-loop-stop
-                                                                               
 (floor (+ (subed-subtitle-msecs-stop)
-                                                                               
                                         (* 1000 (or subed-loop-seconds-after 
0))))))
-                               (setq subed--subtitle-loop-stop
-                                                       (floor (+ msecs (* 1000 
(or subed-loop-seconds-after 0))))))
-                       (when (and
-                                                
(subed-jump-to-subtitle-time-stop)
-                                                (looking-at 
subed--regexp-timestamp))
-                               (replace-match
-                                (save-match-data (subed-msecs-to-timestamp 
msecs)))
-                               (subed-subtitle-msecs-stop)))))
+      (let ((current-start (subed-subtitle-msecs-start)))
+        (when (subed-jump-to-subtitle-time-stop sub-id)
+          (when (and subed-enforce-time-boundaries
+                     (not ignore-negative-duration)
+                     (< msecs current-start))
+            (pcase subed-enforce-time-boundaries
+              ('error
+               (error "Stop time %s will be before start time %s"
+                      (subed-msecs-to-timestamp msecs)
+                      (subed-msecs-to-timestamp current-start)))
+              ('clip
+               (message "Clipping time to %s" (subed-msecs-to-timestamp 
current-start))
+               (setq msecs (subed-subtitle-msecs-start)))
+              ('adjust
+               (let ((subed-enforce-time-boundaries nil))
+                 (subed-set-subtitle-time-start msecs)
+                 (message "Adjusted start time to %s to avoid negative 
duration"
+                          (subed-msecs-to-timestamp current-start))))))))
+      (when (and subed-enforce-time-boundaries
+                 (not ignore-overlap))
+        (subed-save-excursion
+         (when (and (subed-forward-subtitle-time-stop)
+                    subed-subtitle-spacing
+                    (< (subed-subtitle-msecs-start)
+                       (+ msecs subed-subtitle-spacing)))
+           (pcase subed-enforce-time-boundaries
+             ('error
+              (error "Stop time %s will be too close to next start time of %s"
+                     (subed-msecs-to-timestamp msecs)
+                     (subed-msecs-to-timestamp (subed-subtitle-msecs-start))))
+             ('clip
+              (setq msecs (- (subed-subtitle-msecs-start) 
subed-subtitle-spacing))
+              (message "Clipping to %s to preserve spacing"
+                       (subed-msecs-to-timestamp msecs)))
+             ('adjust
+              (let ((subed-enforce-time-boundaries nil))
+                (subed-set-subtitle-time-start (+ msecs 
subed-subtitle-spacing))
+                (message "Adjusted next start time to %s to maintain spacing"
+                         (subed-msecs-to-timestamp 
(subed-subtitle-msecs-start)))))))))
+      ;; Update loop end if it's within the current subtitle
+      (when (and subed--subtitle-loop-stop
+                 (> subed--subtitle-loop-stop (subed-subtitle-msecs-start))
+                 (<= subed--subtitle-loop-stop
+                     (floor (+ (subed-subtitle-msecs-stop)
+                               (* 1000 (or subed-loop-seconds-after 0))))))
+        (setq subed--subtitle-loop-stop
+              (floor (+ msecs (* 1000 (or subed-loop-seconds-after 0))))))
+      (when (and
+             (subed-jump-to-subtitle-time-stop)
+             (looking-at subed--regexp-timestamp))
+        (replace-match
+         (save-match-data (subed-msecs-to-timestamp msecs)))
+        (subed-subtitle-msecs-stop)))))
 
 (subed-define-generic-function make-subtitle (&optional id start stop text 
comment)
   "Generate new subtitle string.
@@ -556,18 +556,18 @@ If MODE-FUNC is non-nil, use that function to initialize 
the mode.
 Otherwise, initialize the mode based on the filename."
   (when (and filename (file-exists-p filename))
     (with-temp-buffer
-                       (let ((subed-auto-play-media nil))
-                               (insert-file-contents filename)
-                               (if mode-func
-                                               (funcall mode-func)
-                                       (let ((mode-entry
-                                                                (seq-find 
(lambda (mode-alist)
-                                                                               
                                 (string-match (car mode-alist) filename))
-                                                                               
                         auto-mode-alist)))
-                                               (if mode-entry
-                                                               (funcall (cdr 
mode-entry))
-                                                       (subed-tsv-mode))))
-                               (subed-subtitle-list)))))
+      (let ((subed-auto-play-media nil))
+        (insert-file-contents filename)
+        (if mode-func
+            (funcall mode-func)
+          (let ((mode-entry
+                 (seq-find (lambda (mode-alist)
+                             (string-match (car mode-alist) filename))
+                           auto-mode-alist)))
+            (if mode-entry
+                (funcall (cdr mode-entry))
+              (subed-tsv-mode))))
+        (subed-subtitle-list)))))
 
 (defun subed-subtitle ()
   "Return the subtitle at point as a list.
@@ -729,10 +729,10 @@ nil if nothing changed."
     (when msecs-new
       ;; MSECS-NEW must be bigger than the current start time if we are adding
       ;; or smaller if we are subtracting.
-                       (setq msecs-new
-                                               (subed-set-subtitle-time-start 
msecs-new nil
-                                                                               
                                                                                
         ignore-negative-duration
-                                                                               
                                                                                
         ignore-overlap))
+      (setq msecs-new
+            (subed-set-subtitle-time-start msecs-new nil
+                                           ignore-negative-duration
+                                           ignore-overlap))
       (subed--run-subtitle-time-adjusted-hook)
       (- msecs-new msecs-start))))
 
@@ -758,11 +758,11 @@ nil if nothing changed."
          (msecs-new (when msecs-stop (+ msecs-stop msecs))))
     ;; MSECS-NEW must be bigger than the current stop time if we are adding or
     ;; smaller if we are subtracting.
-    (when (and (>= msecs-new 0)        ;; Ignore negative times
-               (or (and (> msecs 0) (> msecs-new msecs-stop))  ;; Adding
-                   (and (< msecs 0) (< msecs-new msecs-stop))))        ;; 
Subtracting
-                       (setq msecs-new
-                                               (subed-set-subtitle-time-stop 
msecs-new nil ignore-negative-duration ignore-overlap))
+    (when (and (>= msecs-new 0) ;; Ignore negative times
+               (or (and (> msecs 0) (> msecs-new msecs-stop)) ;; Adding
+                   (and (< msecs 0) (< msecs-new msecs-stop)))) ;; Subtracting
+      (setq msecs-new
+            (subed-set-subtitle-time-stop msecs-new nil 
ignore-negative-duration ignore-overlap))
       (subed--run-subtitle-time-adjusted-hook)
       (- msecs-new msecs-stop))))
 
@@ -817,7 +817,7 @@ See `subed-increase-start-time' about ARG."
   "Replace current subtitle's start time with current playback time."
   (interactive)
   (when (and subed-mpv-playback-position
-                (subed-subtitle-msecs-start))
+           (subed-subtitle-msecs-start))
     (subed-set-subtitle-time-start subed-mpv-playback-position)
     (subed--run-subtitle-time-adjusted-hook)
     subed-mpv-playback-position))
@@ -826,7 +826,7 @@ See `subed-increase-start-time' about ARG."
   "Replace current subtitle's stop time with current playback time."
   (interactive)
   (when (and subed-mpv-playback-position
-                (subed-subtitle-msecs-stop))
+           (subed-subtitle-msecs-stop))
     (subed-set-subtitle-time-stop subed-mpv-playback-position)
     (subed--run-subtitle-time-adjusted-hook)
     subed-mpv-playback-position))
@@ -876,7 +876,7 @@ but we move the start time first."
 BEG and END specify a region.  This stretches the subtitles so
 that they cover the new timespan.  If you want to shift all the
 subtitles by the same offset, use `subed-move-subtitles' instead."
-  (let* ((beg-point (save-excursion    ; normalized to fixed location over BEG
+  (let* ((beg-point (save-excursion ; normalized to fixed location over BEG
                       (goto-char beg)
                       (subed-jump-to-subtitle-end)
                       (point)))
@@ -915,24 +915,24 @@ subtitles by the same offset, use `subed-move-subtitles' 
instead."
     ;; check for range with 0 time interval
     (unless (/= beg-start-msecs old-end-start-msecs)
       (user-error "Can't scale subtitle range with 0 time interval"))
-               ;; check for overlap
-               (when (and (> msecs 0) (eq subed-enforce-time-boundaries 
'error))
-                       (subed-save-excursion
-                        (goto-char end-point)
-                        (let ((old-stop (subed-subtitle-msecs-stop)))
-                                (when (and (subed-forward-subtitle-time-start)
-                                                                               
(> (+ old-stop msecs subed-subtitle-spacing)
-                                                                               
         (subed-subtitle-msecs-start)))
-                                        (user-error "Can't scale when 
extension would overlap subsequent subtitles")))))
-               ;; check for non-chronological: last will start before previous 
subtitle stops
-               (let ((list
-                                        (subed-subtitle-list beg end)))
-                       ;; make sure each subtitle ends before the next 
subtitle starts
-                       (while list
-                               (when (and (cdr list)
-                                                                        (> 
(elt (car list) 2) (elt (cadr list) 1)))
-                                       (user-error "Can't scale when 
nonchronological subtitles exist"))
-                               (setq list (cdr list))))
+    ;; check for overlap
+    (when (and (> msecs 0) (eq subed-enforce-time-boundaries 'error))
+      (subed-save-excursion
+       (goto-char end-point)
+       (let ((old-stop (subed-subtitle-msecs-stop)))
+         (when (and (subed-forward-subtitle-time-start)
+                    (> (+ old-stop msecs subed-subtitle-spacing)
+                       (subed-subtitle-msecs-start)))
+           (user-error "Can't scale when extension would overlap subsequent 
subtitles")))))
+    ;; check for non-chronological: last will start before previous subtitle 
stops
+    (let ((list
+           (subed-subtitle-list beg end)))
+      ;; make sure each subtitle ends before the next subtitle starts
+      (while list
+        (when (and (cdr list)
+                   (> (elt (car list) 2) (elt (cadr list) 1)))
+          (user-error "Can't scale when nonchronological subtitles exist"))
+        (setq list (cdr list))))
     (unless (= msecs 0)
       (subed-with-subtitle-replay-disabled
         (cl-flet ((move-subtitle (subed--get-move-subtitle-func msecs)))
@@ -1002,8 +1002,8 @@ subtitles by the same offset, use `subed-move-subtitles' 
instead."
               (unless (setq msecs (move-subtitle msecs))
                 (throw 'bumped-into-subtitle t))
               (subed-forward-subtitle-id)
-                                                       
(subed-for-each-subtitle (point) end nil
-                                                               (move-subtitle 
msecs :ignore-negative-duration)))))))))
+              (subed-for-each-subtitle (point) end nil
+                (move-subtitle msecs :ignore-negative-duration)))))))))
 
 (defun subed-scale-subtitles (msecs &optional beg end)
   "Scale subtitles between BEG and END after moving END MSECS.
@@ -1013,12 +1013,12 @@ If BEG is nil, BEG will be the first subtitle in the 
buffer.
 
 If you want to shift all the subtitles by the same offset, use
 `subed-move-subtitles' instead."
-       (interactive (list (if current-prefix-arg
-                                                                               
                 (prefix-numeric-value current-prefix-arg)
-                                                                               
         (read-number "Milliseconds: "))
-                                                                               
 (when (region-active-p) (point))
-                                                                               
 (when (region-active-p) (mark))))
-       (let ((beg (or beg (point-min)))
+  (interactive (list (if current-prefix-arg
+                         (prefix-numeric-value current-prefix-arg)
+                       (read-number "Milliseconds: "))
+                     (when (region-active-p) (point))
+                     (when (region-active-p) (mark))))
+  (let ((beg (or beg (point-min)))
         (end (or end (point-max))))
     (subed--scale-subtitles-in-region msecs beg end)
     (when (subed-replay-adjusted-subtitle-p)
@@ -1092,11 +1092,11 @@ If END is nil, move all subtitles from BEG to end of 
buffer.
 If BEG is nil, move only the current subtitle.
 After subtitles are moved, replay the first moved subtitle if
 replaying is enabled."
-       (interactive (list (if current-prefix-arg
-                                                                               
                 (prefix-numeric-value current-prefix-arg)
-                                                                               
         (read-number "Milliseconds: "))
-                                                                               
 (when (region-active-p) (point))
-                                                                               
 (when (region-active-p) (mark))))
+  (interactive (list (if current-prefix-arg
+                         (prefix-numeric-value current-prefix-arg)
+                       (read-number "Milliseconds: "))
+                     (when (region-active-p) (point))
+                     (when (region-active-p) (mark))))
   (cond ((and beg end) (subed--move-subtitles-in-region msecs beg end))
         (beg (subed--move-subtitles-in-region msecs beg (point-max)))
         (t (subed--move-current-subtitle msecs)))
@@ -1532,27 +1532,27 @@ If QUIET is non-nil, do not display a message in the 
minibuffer."
 
 If QUIET is non-nil, do not display a message in the minibuffer."
   (interactive)
-       ;; If looping over a subtitle, don't immediately enable it. Set it to 
be enabled after the loop ends.
-       (if (subed-loop-over-current-subtitle-p)
-                       (setq 
subed--enable-point-to-player-sync-after-disabling-loop t)
-               (unless (subed-sync-point-to-player-p)
-                       (add-hook 'subed-mpv-playback-position-hook 
#'subed--sync-point-to-player :append :local)
-                       (subed-debug "Enabled syncing point to playback 
position: %s" subed-mpv-playback-position-hook)
-                       (unless quiet
-                               (message "Enabled syncing point to playback 
position")))))
+  ;; If looping over a subtitle, don't immediately enable it. Set it to be 
enabled after the loop ends.
+  (if (subed-loop-over-current-subtitle-p)
+      (setq subed--enable-point-to-player-sync-after-disabling-loop t)
+    (unless (subed-sync-point-to-player-p)
+      (add-hook 'subed-mpv-playback-position-hook 
#'subed--sync-point-to-player :append :local)
+      (subed-debug "Enabled syncing point to playback position: %s" 
subed-mpv-playback-position-hook)
+      (unless quiet
+        (message "Enabled syncing point to playback position")))))
 
 (defun subed-disable-sync-point-to-player (&optional quiet)
   "Do not move point automatically to the currently playing subtitle.
 
 If QUIET is non-nil, do not display a message in the minibuffer."
   (interactive)
-       (when (subed-loop-over-current-subtitle-p)
-               (setq subed--enable-point-to-player-sync-after-disabling-loop 
nil))
-       (when (subed-sync-point-to-player-p)
-               (remove-hook 'subed-mpv-playback-position-hook 
#'subed--sync-point-to-player :local)
-               (subed-debug "Disabled syncing point to playback position: %s" 
subed-mpv-playback-position-hook)
-               (unless quiet
-                       (message "Disabled syncing point to playback 
position"))))
+  (when (subed-loop-over-current-subtitle-p)
+    (setq subed--enable-point-to-player-sync-after-disabling-loop nil))
+  (when (subed-sync-point-to-player-p)
+    (remove-hook 'subed-mpv-playback-position-hook 
#'subed--sync-point-to-player :local)
+    (subed-debug "Disabled syncing point to playback position: %s" 
subed-mpv-playback-position-hook)
+    (unless quiet
+      (message "Disabled syncing point to playback position"))))
 
 (defun subed-toggle-sync-point-to-player ()
   "Enable/disable moving point to the currently playing subtitle."
@@ -1583,8 +1583,8 @@ If QUIET is non-nil, do not display a message in the 
minibuffer."
 
 After `subed-point-sync-delay-after-motion' seconds point is re-synced."
   (if subed--point-sync-delay-after-motion-timer
-                       (when (timerp 
subed--point-sync-delay-after-motion-timer)
-                               (cancel-timer 
subed--point-sync-delay-after-motion-timer))
+      (when (timerp subed--point-sync-delay-after-motion-timer)
+        (cancel-timer subed--point-sync-delay-after-motion-timer))
     (setq subed--point-was-synced (subed-sync-point-to-player-p)))
   (when subed--point-was-synced
     (subed-disable-sync-point-to-player :quiet))
@@ -1812,15 +1812,15 @@ Return nil if function `buffer-file-name' returns nil."
   (when (buffer-file-name)
     (catch 'found-file
       (let* ((file-base (file-name-sans-extension (buffer-file-name)))
-                  (file-stem (file-name-sans-extension file-base)))
-             (dolist (extension
+             (file-stem (file-name-sans-extension file-base)))
+        (dolist (extension
                  (or extensions (append subed-video-extensions 
subed-audio-extensions)))
-               (let ((file-base-media (format "%s.%s" file-base extension))
-                           (file-stem-media (format "%s.%s" file-stem 
extension)))
-                 (when (file-exists-p file-base-media)
-                   (throw 'found-file file-base-media))
-                 (when (file-exists-p file-stem-media)
-                   (throw 'found-file file-stem-media))))))))
+          (let ((file-base-media (format "%s.%s" file-base extension))
+                (file-stem-media (format "%s.%s" file-stem extension)))
+            (when (file-exists-p file-base-media)
+              (throw 'found-file file-base-media))
+            (when (file-exists-p file-stem-media)
+              (throw 'found-file file-stem-media))))))))
 (define-obsolete-function-alias 'subed-guess-video-file 
'subed-guess-media-file "1.0.20")
 
 ;;; Inserting HTML-like tags
@@ -1837,12 +1837,12 @@ If region is not active, insert a pair of tags and put 
the point
 between them.  If called with a prefix argument, also ask for
 ATTRIBUTE(s)."
   (interactive (let* ((region-p (use-region-p))
-                                 (begin (if region-p (region-beginning) 
(point)))
-                                 (end (if region-p (region-end) (point)))
-                                 (tag (read-string "Tag: " nil 
'subed--html-tag-history))
-                                 (attributes (when current-prefix-arg
-                                                           (read-string 
"Attribute(s): " nil 'subed--html-attr-history))))
-                            (list begin end tag attributes)))
+                      (begin (if region-p (region-beginning) (point)))
+                      (end (if region-p (region-end) (point)))
+                      (tag (read-string "Tag: " nil 'subed--html-tag-history))
+                      (attributes (when current-prefix-arg
+                                    (read-string "Attribute(s): " nil 
'subed--html-attr-history))))
+                 (list begin end tag attributes)))
   (save-excursion
     (push (point) buffer-undo-list)
     (goto-char end)
@@ -1856,18 +1856,18 @@ ATTRIBUTE(s)."
   "Insert a pair of <i> tags at point or around the region.
 The region is defined by BEGIN and END."
   (interactive (let* ((region-p (use-region-p))
-                                 (begin (if region-p (region-beginning) 
(point)))
-                                 (end (if region-p (region-end) (point))))
-                            (list begin end)))
+                      (begin (if region-p (region-beginning) (point)))
+                      (end (if region-p (region-end) (point))))
+                 (list begin end)))
   (subed-insert-html-tag begin end "i"))
 
 (defun subed-insert-html-tag-bold (begin end)
   "Insert a pair of <b> tags at point or around the region.
 The region is defined by BEGIN and END."
   (interactive (let* ((region-p (use-region-p))
-                                 (begin (if region-p (region-beginning) 
(point)))
-                                 (end (if region-p (region-end) (point))))
-                            (list begin end)))
+                      (begin (if region-p (region-beginning) (point)))
+                      (end (if region-p (region-end) (point))))
+                 (list begin end)))
   (subed-insert-html-tag begin end "b"))
 
 ;;; Characters per second computation
@@ -1897,7 +1897,7 @@ If QUIET is nil, show a message."
   (remove-hook 'subed-subtitle-motion-hook 
#'subed--move-cps-overlay-to-current-subtitle t)
   (remove-hook 'after-save-hook #'subed--move-cps-overlay-to-current-subtitle 
t)
   (when subed--cps-overlay
-         (remove-overlays (point-min) (point-max) 'subed 'cps)
+    (remove-overlays (point-min) (point-max) 'subed 'cps)
     (setq subed--cps-overlay nil))
   (unless quiet
     (message "Disabled showing characters per second")))
@@ -1925,29 +1925,29 @@ If QUIET is nil, show a message."
 if PRINT-MESSAGE is non-nil, display a message."
   (interactive "p")
   (let* ((msecs-start (ignore-errors (subed-subtitle-msecs-start)))
-              (msecs-stop (ignore-errors (subed-subtitle-msecs-stop)))
-              (text (if (fboundp subed-transform-for-cps)
-                              (funcall subed-transform-for-cps 
(subed-subtitle-text))
-                            (subed-subtitle-text)))
-              (length (length text))
-              (cps (when (and (numberp msecs-stop)
-                                          (numberp msecs-start))
-                           (/ length 0.001 (- msecs-stop msecs-start)))))
+         (msecs-stop (ignore-errors (subed-subtitle-msecs-stop)))
+         (text (if (fboundp subed-transform-for-cps)
+                   (funcall subed-transform-for-cps (subed-subtitle-text))
+                 (subed-subtitle-text)))
+         (length (length text))
+         (cps (when (and (numberp msecs-stop)
+                         (numberp msecs-start))
+                (/ length 0.001 (- msecs-stop msecs-start)))))
     (if (and print-message cps)
-             (message "%.1f characters per second" cps)
-           cps)))
+        (message "%.1f characters per second" cps)
+      cps)))
 
 (defun subed--move-cps-overlay-to-current-subtitle ()
   "Move the CPS overlay to the current subtitle."
   (unless subed--batch-editing
     (let* ((begin (save-excursion
-                               (subed-jump-to-subtitle-time-start)
-                               (point)))
-                (end (save-excursion
-                             (goto-char begin)
-                             (line-end-position))))
+                    (subed-jump-to-subtitle-time-start)
+                    (point)))
+           (end (save-excursion
+                  (goto-char begin)
+                  (line-end-position))))
       (if subed--cps-overlay
-               (move-overlay subed--cps-overlay begin end (current-buffer))
+          (move-overlay subed--cps-overlay begin end (current-buffer))
         (setq subed--cps-overlay (make-overlay begin end))
         (overlay-put subed--cps-overlay 'subed 'cps))
       (subed--update-cps-overlay))))
@@ -2036,13 +2036,13 @@ Return the new stop time."
                                 (subed-subtitle-msecs-start))))
         (this-sub-stop-time (subed-subtitle-msecs-stop)))
     (when (and next-sub-start-time this-sub-stop-time
-                                                        (> this-sub-stop-time
-                                                                       (- 
next-sub-start-time
-                                                                               
 (if (numberp msecs) msecs subed-subtitle-spacing))))
+               (> this-sub-stop-time
+                  (- next-sub-start-time
+                     (if (numberp msecs) msecs subed-subtitle-spacing))))
       (subed-set-subtitle-time-stop
        (- next-sub-start-time
           (if (numberp msecs) msecs subed-subtitle-spacing))
-                        nil
+       nil
        ignore-negative-duration
        t))))
 
@@ -2065,12 +2065,12 @@ Return the new start time."
       (when (and this-sub-stop-time
                  next-sub-start-time
                  (or msecs subed-subtitle-spacing)
-                                                                (< 
next-sub-start-time
-                                                                               
(+ this-sub-stop-time
-                                                                               
         (if (numberp msecs) msecs subed-subtitle-spacing))))
+                 (< next-sub-start-time
+                    (+ this-sub-stop-time
+                       (if (numberp msecs) msecs subed-subtitle-spacing))))
         (subed-set-subtitle-time-start
-                                (+ this-sub-stop-time (or msecs 
subed-subtitle-spacing))
-                                nil
+         (+ this-sub-stop-time (or msecs subed-subtitle-spacing))
+         nil
          ignore-negative-duration
          t)))))
 
diff --git a/subed/subed-config.el b/subed/subed-config.el
index 7507afd374..c726bf7fb9 100644
--- a/subed/subed-config.el
+++ b/subed/subed-config.el
@@ -170,10 +170,10 @@ If set to zero or smaller, playback is paused."
 
 Other values aside from the ones specified above will be treated as nil."
   :type '(choice
-                                       (const :tag "Adjust other times as 
needed" adjust)
-                                       (const :tag "Limit changes" clip)
-                                       (const :tag "Report an error" error)
-                                       (const :tag "Do not check" nil))
+          (const :tag "Adjust other times as needed" adjust)
+          (const :tag "Limit changes" clip)
+          (const :tag "Report an error" error)
+          (const :tag "Do not check" nil))
   :group 'subed)
 
 (defcustom subed-sanitize-functions
diff --git a/subed/subed-mpv.el b/subed/subed-mpv.el
index 9e0457eab4..8b395af998 100644
--- a/subed/subed-mpv.el
+++ b/subed/subed-mpv.el
@@ -148,7 +148,7 @@ again with (cdr DELAYS) as arguments."
                                     :family 'local
                                     :service (subed-mpv--socket)
                                     :coding '(utf-8 . utf-8)
-                                                       :buffer 
(subed-mpv--client-buffer)
+                          :buffer (subed-mpv--client-buffer)
                                     :filter #'subed-mpv--client-filter
                                     :noquery t
                                     :nowait t)))
@@ -218,28 +218,28 @@ string."
   (when (buffer-live-p (process-buffer proc))
     (let ((orig-buffer (current-buffer)))
       (when (derived-mode-p 'subed-mode)
-             (with-current-buffer (process-buffer proc)
+        (with-current-buffer (process-buffer proc)
           ;; Insert new response where previous response ended
-               (let* ((proc-mark (process-mark proc))
+          (let* ((proc-mark (process-mark proc))
                  (moving (= (point) proc-mark)))
-                       (save-excursion
-                         (goto-char proc-mark)
-                         (insert response)
-                         (set-marker proc-mark (point)))
-                       (if moving (goto-char proc-mark)))
-               ;; Process and remove all complete lines of JSON (lines are 
complete if
-               ;; they end with \n)
-               (let ((p0 (point-min)))
-                       (while (progn (goto-char p0)
+            (save-excursion
+              (goto-char proc-mark)
+              (insert response)
+              (set-marker proc-mark (point)))
+            (if moving (goto-char proc-mark)))
+          ;; Process and remove all complete lines of JSON (lines are complete 
if
+          ;; they end with \n)
+          (let ((p0 (point-min)))
+            (while (progn (goto-char p0)
                           (end-of-line)
-                                           (equal (following-char) ?\n))
-                         (let* ((p1 (point))
-                                      (line (buffer-substring p0 p1)))
-                                 (delete-region p0 (+ p1 1))
+                          (equal (following-char) ?\n))
+              (let* ((p1 (point))
+                     (line (buffer-substring p0 p1)))
+                (delete-region p0 (+ p1 1))
                 ;; Return context to the subtitle file buffer because we're 
using
                 ;; buffer-local variables to store player state.
                 (with-current-buffer orig-buffer
-                                   (subed-mpv--client-handle-json 
line))))))))))
+                  (subed-mpv--client-handle-json line))))))))))
 
 (defun subed-mpv--client-handle-json (json-string)
   "Process server response JSON-STRING."
diff --git a/subed/subed-srt.el b/subed/subed-srt.el
index d56fb0914e..3c68624193 100644
--- a/subed/subed-srt.el
+++ b/subed/subed-srt.el
@@ -282,8 +282,8 @@ Use the format-specific function for MAJOR-MODE."
             (subed-jump-to-subtitle-text)
             (delete-region pos (point))
             (insert "\n")
-                                               (let 
((subed-enforce-time-boundaries nil))
-                                                       
(subed-set-subtitle-time-stop new-end))
+            (let ((subed-enforce-time-boundaries nil))
+              (subed-set-subtitle-time-stop new-end))
             (subed-regenerate-ids-soon))
         (error "No subtitle to merge into")))))
 
diff --git a/subed/subed-tsv.el b/subed/subed-tsv.el
index 54346c0d4f..1345798cc8 100644
--- a/subed/subed-tsv.el
+++ b/subed/subed-tsv.el
@@ -25,8 +25,8 @@
 ;; This file supports tab-separated values such as labels exported from 
Audacity.
 ;; Example:
 ;;
-;; 6.191196    27.488912       This is a test
-;; 44.328966   80.733201       This is another line, a little longer than the 
first.
+;; 6.191196 27.488912 This is a test
+;; 44.328966  80.733201 This is another line, a little longer than the first.
 
 ;;; Code:
 
@@ -430,8 +430,8 @@ Use the format-specific function for MAJOR-MODE."
             (subed-jump-to-subtitle-text)
             (delete-region pos (point))
             (insert " ")
-                                               (let 
((subed-enforce-time-boundaries nil))
-                                                       
(subed-set-subtitle-time-stop new-end)))
+            (let ((subed-enforce-time-boundaries nil))
+              (subed-set-subtitle-time-stop new-end)))
         (error "No subtitle to merge into")))))
 
 
diff --git a/subed/subed-vtt.el b/subed/subed-vtt.el
index 6682e6f379..fd6159891b 100644
--- a/subed/subed-vtt.el
+++ b/subed/subed-vtt.el
@@ -236,7 +236,7 @@ Make sure COMMENT ends with a blank line."
                        (concat comment
                                (if (string-match "\n\n\\'" comment)
                                    "" "\n\n")))
-                                comment)
+         comment)
         ((string-match "\n" comment) (concat "NOTE\n" comment "\n\n"))
         (t (concat "NOTE " comment))))
 
@@ -315,8 +315,8 @@ Use the format-specific function for MAJOR-MODE."
             (subed-jump-to-subtitle-text)
             (delete-region pos (point))
             (insert "\n")
-                                               (let 
((subed-enforce-time-boundaries nil))
-                                                       
(subed-set-subtitle-time-stop new-end)))
+            (let ((subed-enforce-time-boundaries nil))
+              (subed-set-subtitle-time-stop new-end)))
         (error "No subtitle to merge into")))))
 
 ;;; Maintenance
diff --git a/subed/subed-waveform.el b/subed/subed-waveform.el
index c4b05380b6..9a8d7ae401 100644
--- a/subed/subed-waveform.el
+++ b/subed/subed-waveform.el
@@ -124,9 +124,9 @@ The keys in it are `:start', `:stop' and `:current'.  The 
values are
 SVG parameters of the displayed bars.  Every bar must have a unique
 `:id' parameter."
   :type '(alist :key-type (choice (const :tag "Start" :start)
-                                 (const :tag "Stop" :stop)
-                                 (const :tag "Current" :current))
-               :value-type (plist :key-type symbol :value-type string))
+          (const :tag "Stop" :stop)
+          (const :tag "Current" :current))
+    :value-type (plist :key-type symbol :value-type string))
   :group 'subed-waveform)
 
 (defcustom subed-waveform-preview-msecs-before 2000
@@ -164,39 +164,39 @@ rounded to the nearest multiple of this number."
 (defun subed-waveform-remove ()
   "Remove waveform overlay."
   (interactive)
-       (remove-overlays (point-min) (point-max) 'subed-waveform t)
+  (remove-overlays (point-min) (point-max) 'subed-waveform t)
   (when (overlayp subed-waveform--image-overlay)
     (delete-overlay subed-waveform--image-overlay)))
 
 ;;;###autoload
 (define-minor-mode subed-waveform-minor-mode
   "Display waveforms for subtitles. Update on motion."
-       :lighter "w"
-       :require 'subed
+  :lighter "w"
+  :require 'subed
   (if subed-waveform-minor-mode
       (progn
         (add-hook 'before-save-hook #'subed-waveform-remove nil t)
         (add-hook 'after-save-hook #'subed-waveform-put-svg nil t)
         (add-hook 'subed-subtitle-motion-hook #'subed-waveform-put-svg nil t)
         (add-hook 'after-change-motion-hook #'subed-waveform-put-svg nil t)
-                               (add-hook 'subed-mpv-playback-position-hook 
#'subed-waveform--update-current-bar t)
+        (add-hook 'subed-mpv-playback-position-hook 
#'subed-waveform--update-current-bar t)
         (add-hook 'subed-subtitle-time-adjusted-hook #'subed-waveform-put-svg 
nil t)
-                               (subed-waveform-put-svg))
+        (subed-waveform-put-svg))
     (subed-waveform-remove)
     (remove-hook 'before-save-hook #'subed-waveform-remove t)
     (remove-hook 'after-save-hook #'subed-waveform-put-svg t)
     (remove-hook 'subed-subtitle-motion-hook #'subed-waveform-put-svg t)
     (remove-hook 'subed-subtitle-time-adjusted-hook #'subed-waveform-put-svg t)
-               (remove-hook 'subed-mpv-playback-position-hook 
#'subed-waveform--update-current-bar t)
+    (remove-hook 'subed-mpv-playback-position-hook 
#'subed-waveform--update-current-bar t)
     (remove-hook 'after-change-motion-hook #'subed-waveform-put-svg t)))
 
 (defvar subed-waveform-minor-mode-map
-       (let ((map (make-sparse-keymap)))
-               (define-key map (kbd "C-c C-=") 
#'subed-waveform-volume-increase)
+  (let ((map (make-sparse-keymap)))
+    (define-key map (kbd "C-c C-=") #'subed-waveform-volume-increase)
     (define-key map (kbd "C-c C--") #'subed-waveform-volume-decrease)
     (define-key map (kbd "C-c |") #'subed-waveform-put-svg)
-               map)
-       "Keymap for `subed-waveform-minor-mode'.")
+    map)
+  "Keymap for `subed-waveform-minor-mode'.")
 
 (defconst subed-waveform-volume-map
   (let ((map (make-sparse-keymap)))
@@ -217,7 +217,7 @@ rounded to the nearest multiple of this number."
   "Increase `subed-waveform-value' by AMOUNT/2."
   (interactive "p")
   (setq subed-waveform-volume (max 1.0
-                                  (- subed-waveform-volume (/ amount 2.0))))
+           (- subed-waveform-volume (/ amount 2.0))))
   (message "Waveform volume multiplier is now set to %s" subed-waveform-volume)
   (subed-waveform-put-svg)
   (set-transient-map subed-waveform-volume-map))
@@ -225,48 +225,48 @@ rounded to the nearest multiple of this number."
 (defun subed-waveform-fancy-filter (width height)
   "Display green waveforms on a dark green background with a grid.
 WIDTH and HEIGHT are given in pixels."
-       (concat
-        ":colors=#9cf42f[fg];"
+  (concat
+   ":colors=#9cf42f[fg];"
    (format 
"color=s=%dx%d:color=#44582c,drawgrid=width=iw/10:height=ih/5:color=#9cf42f@0.1[bg];"
            width height)
    
"[bg][fg]overlay=format=auto,drawbox=x=(iw-w)/2:y=(ih-h)/2:w=iw:h=1:color=#9cf42f"))
 
 (defun subed-waveform--from-file (filename from to width height)
-       "Returns a string representing the image data in PNG format.
+  "Returns a string representing the image data in PNG format.
 FILENAME is the input file, FROM and TO are time positions, WIDTH
 and HEIGHT are dimensions in pixels."
-       (let* ((args
-                                       (append
-                                        (list "-accurate_seek"
-                                                                "-ss" (format 
"%s" from)
-                                                                "-to" (format 
"%s" to))
-                                        (list "-i" filename)
-                                        (list
-                                               "-loglevel"
-                                               "0"
-                                               "-filter_complex"
-                                               (format 
"volume=%s,showwavespic=s=%dx%d%s"
-                                                                               
subed-waveform-volume
-                                                                               
width height
-                                                                               
(cond
+  (let* ((args
+          (append
+           (list "-accurate_seek"
+                 "-ss" (format "%s" from)
+                 "-to" (format "%s" to))
+           (list "-i" filename)
+           (list
+            "-loglevel"
+            "0"
+            "-filter_complex"
+            (format "volume=%s,showwavespic=s=%dx%d%s"
+                    subed-waveform-volume
+                    width height
+                    (cond
                      ((functionp subed-waveform-ffmpeg-filter-args)
                       (funcall subed-waveform-ffmpeg-filter-args width height))
                      ((stringp subed-waveform-ffmpeg-filter-args)
                       subed-waveform-ffmpeg-filter-args)
                      (t "")))
-                                               "-frames:v" "1"
-                                               "-c:v" "png"
-                                               "-f" "image2" "-"))))
-               (with-temp-buffer
-                       (apply 'call-process subed-waveform-ffmpeg-executable 
nil t nil args)
-                       (encode-coding-string (buffer-string) 'binary))))
+            "-frames:v" "1"
+            "-c:v" "png"
+            "-f" "image2" "-"))))
+    (with-temp-buffer
+      (apply 'call-process subed-waveform-ffmpeg-executable nil t nil args)
+      (encode-coding-string (buffer-string) 'binary))))
 
 (defvar-local subed-waveform--start nil
   "Timestamp (in milliseconds) of the start of the waveform.")
 (defvar-local subed-waveform--stop nil
   "Timestamp (in milliseconds) of the stop of the waveform.")
 (defvar-local subed-waveform--pixels-per-second nil
-       "Number of pixels used for displaying one second.")
+  "Number of pixels used for displaying one second.")
 
 (defun subed-waveform--msecs-to-ffmpeg (msecs)
   "Convert MSECS to string in the format HH:MM:SS.MS."
@@ -275,8 +275,8 @@ and HEIGHT are dimensions in pixels."
 
 (defun subed-waveform--position-to-percent (pos start stop)
   "Return a percentage of POS relative to START/STOP."
-       (when pos
-               (format "%s%%" (/ (* 100 (- pos start)) (- stop start)))))
+  (when pos
+    (format "%s%%" (/ (* 100 (- pos start)) (- stop start)))))
 
 (defvar-local subed-waveform--pos nil
   "Buffer position of the image with the current waveform.")
@@ -293,61 +293,61 @@ and HEIGHT are dimensions in pixels."
 Set `subed-waveform--svg' and `subed-waveform--pos'."
   (save-excursion
     (let ((start (subed-subtitle-msecs-start))
-                                       (stop (subed-subtitle-msecs-stop)))
+          (stop (subed-subtitle-msecs-stop)))
       (setq subed-waveform--start
-                                               (floor (max 0 (- start 
subed-waveform-preview-msecs-before))))
+            (floor (max 0 (- start subed-waveform-preview-msecs-before))))
       (setq subed-waveform--stop
-                                               (floor (+ stop 
subed-waveform-preview-msecs-after)))
-                       (when (> subed-waveform--stop subed-waveform--start)
-                               (let* ((width (string-pixel-width (make-string 
fill-column ?*)))
-                                                        (height (save-excursion
-                                                                               
                 ;; don't count the current waveform towards the
-                                                                               
                 ;; line height
-                                                                               
                 (forward-line -1)
-                                                                               
                 (* 2 (line-pixel-height))))
-                                                        (image 
(subed-waveform--from-file
-                                                                               
         (or subed-mpv-media-file (error "No media file found"))
-                                                                               
         (subed-waveform--msecs-to-ffmpeg subed-waveform--start)
-                                                                               
         (subed-waveform--msecs-to-ffmpeg subed-waveform--stop)
-                                                                               
         width
-                                                                               
         height)))
-                                       (setq subed-waveform--pixels-per-second 
(/ width (* 0.001 (- stop start))))
-                                       (setq subed-waveform--svg (svg-create 
width height))
-                                       (svg-embed subed-waveform--svg image 
"image/png" t
-                                                                               
 :x 0 :y 0
-                                                                               
 :width "100%" :height "100%"
-                                                                               
 :preserveAspectRatio "none")
-                                       (subed-waveform--update-bars 
(subed-subtitle-msecs-start)))))))
+            (floor (+ stop subed-waveform-preview-msecs-after)))
+      (when (> subed-waveform--stop subed-waveform--start)
+        (let* ((width (string-pixel-width (make-string fill-column ?*)))
+               (height (save-excursion
+                         ;; don't count the current waveform towards the
+                         ;; line height
+                         (forward-line -1)
+                         (* 2 (line-pixel-height))))
+               (image (subed-waveform--from-file
+                       (or subed-mpv-media-file (error "No media file found"))
+                       (subed-waveform--msecs-to-ffmpeg subed-waveform--start)
+                       (subed-waveform--msecs-to-ffmpeg subed-waveform--stop)
+                       width
+                       height)))
+          (setq subed-waveform--pixels-per-second (/ width (* 0.001 (- stop 
start))))
+          (setq subed-waveform--svg (svg-create width height))
+          (svg-embed subed-waveform--svg image "image/png" t
+                     :x 0 :y 0
+                     :width "100%" :height "100%"
+                     :preserveAspectRatio "none")
+          (subed-waveform--update-bars (subed-subtitle-msecs-start)))))))
 
 (defun subed-waveform--move-bar (bar-type position)
   "Update `subed-waveform--svg', moving bar BAR-TYPE to POSITION.
 BAR-TYPE should be a symbol, one of :start, :stop, :current.
 POSITION should be a percentage as a string."
   (svg-remove subed-waveform--svg
-             (plist-get (alist-get bar-type subed-waveform-bar-params)
-                                                                        ":id"
-                                                                        
#'string=))
+        (plist-get (alist-get bar-type subed-waveform-bar-params)
+                   ":id"
+                   #'string=))
   (apply #'svg-line
-        subed-waveform--svg position 0 position "100%"
-        (alist-get bar-type subed-waveform-bar-params)))
+   subed-waveform--svg position 0 position "100%"
+   (alist-get bar-type subed-waveform-bar-params)))
 
 (defun subed-waveform--update-bars (subed-subtitle-msecs-start)
   "Update the bars in `subed-waveform--svg'.
 Recompute the waveform if the start bar is too far to the left or
 the stop bar is too far to the right."
   (let* ((start subed-subtitle-msecs-start)
-        (stop (subed-subtitle-msecs-stop))
-        (start-pos (subed-waveform--position-to-percent
-                    start
-                    subed-waveform--start
-                    subed-waveform--stop))
-        (stop-pos (subed-waveform--position-to-percent
-                   stop
-                   subed-waveform--start
-                   subed-waveform--stop)))
+   (stop (subed-subtitle-msecs-stop))
+   (start-pos (subed-waveform--position-to-percent
+         start
+         subed-waveform--start
+         subed-waveform--stop))
+   (stop-pos (subed-waveform--position-to-percent
+        stop
+        subed-waveform--start
+        subed-waveform--stop)))
     (when (or (not subed-waveform--svg)
-             (< start subed-waveform--start)
-             (> stop subed-waveform--stop))
+        (< start subed-waveform--start)
+        (> stop subed-waveform--stop))
       (subed-waveform--set-svg))
     (subed-waveform--move-bar :start start-pos)
     (subed-waveform--move-bar :stop stop-pos))
@@ -358,22 +358,22 @@ the stop bar is too far to the right."
 Assume all necessary variables are already set.  This function is
 meant to be as fast as possible so that it can be called many
 times per second."
-       (when subed-mpv-playback-position
-               (subed-waveform--move-bar
-                :current
-                (subed-waveform--position-to-percent
-                       subed-mpv-playback-position
-                       subed-waveform--start
-                       subed-waveform--stop)))
+  (when subed-mpv-playback-position
+    (subed-waveform--move-bar
+     :current
+     (subed-waveform--position-to-percent
+      subed-mpv-playback-position
+      subed-waveform--start
+      subed-waveform--stop)))
   (subed-waveform--update-overlay-svg))
 
 (defvar subed-waveform-svg-map
   (let ((subed-waveform-svg-map (make-keymap)))
     (define-key subed-waveform-svg-map [mouse-1] #'subed-waveform-set-start)
-               (define-key subed-waveform-svg-map [mouse-2] 
#'subed-waveform-jump-to-timestamp)
+    (define-key subed-waveform-svg-map [mouse-2] 
#'subed-waveform-jump-to-timestamp)
     (define-key subed-waveform-svg-map [mouse-3] #'subed-waveform-set-stop)
     (define-key subed-waveform-svg-map [down-mouse-3] #'ignore)
-               (define-key subed-waveform-svg-map [C-mouse-2] #'ignore)
+    (define-key subed-waveform-svg-map [C-mouse-2] #'ignore)
     (define-key subed-waveform-svg-map [S-mouse-3] #'ignore)
     (define-key subed-waveform-svg-map [C-mouse-3] #'ignore)
     (define-key subed-waveform-svg-map [S-down-mouse-1] #'ignore)
@@ -390,12 +390,12 @@ times per second."
   "Update the SVG in the overlay.
 Assume `subed-waveform--svg' is already set."
   (overlay-put subed-waveform--image-overlay
-              'before-string
-              (propertize
-                                       " "
-                                       'display (svg-image subed-waveform--svg)
-                                       'pointer 'arrow
-                                       'keymap subed-waveform-svg-map)))
+         'before-string
+         (propertize
+          " "
+          'display (svg-image subed-waveform--svg)
+          'pointer 'arrow
+          'keymap subed-waveform-svg-map)))
 
 (defun subed-waveform-put-svg (&rest _)
   "Put an overlay with the SVG in the current subtitle.
@@ -403,17 +403,17 @@ Set the relevant variables if necessary.
 This function ignores arguments and can be used in hooks."
   (interactive)
   (setq subed-waveform--pos (subed-jump-to-subtitle-text))
-       (when subed-waveform--pos
-               (if (overlayp subed-waveform--image-overlay)
-                               (move-overlay subed-waveform--image-overlay
-                                                                               
        subed-waveform--pos subed-waveform--pos)
-                       (setq subed-waveform--image-overlay
-                                               (make-overlay 
subed-waveform--pos subed-waveform--pos))
-                       (overlay-put subed-waveform--image-overlay 
'subed-waveform t)
-                       (overlay-put subed-waveform--image-overlay
-                                                                        
'after-string
-                                                                        "\n"))
-               (subed-waveform--set-svg)))
+  (when subed-waveform--pos
+    (if (overlayp subed-waveform--image-overlay)
+        (move-overlay subed-waveform--image-overlay
+                      subed-waveform--pos subed-waveform--pos)
+      (setq subed-waveform--image-overlay
+            (make-overlay subed-waveform--pos subed-waveform--pos))
+      (overlay-put subed-waveform--image-overlay 'subed-waveform t)
+      (overlay-put subed-waveform--image-overlay
+                   'after-string
+                   "\n"))
+    (subed-waveform--set-svg)))
 
 ;;; Adjusting based on the mouse
 
@@ -423,9 +423,9 @@ This function ignores arguments and can be used in hooks."
          (width (car (elt (cadr event) 9))))
     (* subed-waveform-timestamp-resolution
        (round (+ (* (/ (* 1.0 x) width)
-                                                                               
(- subed-waveform--stop subed-waveform--start))
-                                                                
subed-waveform--start)
-                                                       
subed-waveform-timestamp-resolution))))
+                    (- subed-waveform--stop subed-waveform--start))
+                 subed-waveform--start)
+              subed-waveform-timestamp-resolution))))
 
 (defun subed-waveform-set-start (event)
   "Set the start timestamp in the place clicked."
@@ -443,13 +443,13 @@ This function ignores arguments and can be used in hooks."
   "Make this subtitle start `subed-milliseconds-adjust' milliseconds earlier."
   (interactive "e")
   (save-excursion
-               (when subed-waveform--pixels-per-second
-           (let* ((x1 (car (elt (elt event 2) 2)))
-                                                (x2 (car (elt (elt event 1) 
2)))
-                                                (msecs
-                                                       (floor (* 1000 (/ (- x1 
x2)     ; pixels moved
-                                                                               
                                                
subed-waveform--pixels-per-second)))))
-                               (subed-adjust-subtitle-time-start msecs)))))
+    (when subed-waveform--pixels-per-second
+      (let* ((x1 (car (elt (elt event 2) 2)))
+             (x2 (car (elt (elt event 1) 2)))
+             (msecs
+              (floor (* 1000 (/ (- x1 x2) ; pixels moved
+                                subed-waveform--pixels-per-second)))))
+        (subed-adjust-subtitle-time-start msecs)))))
 
 (defun subed-waveform-increase-stop-time (event)
   "Make this subtitle stop later.
@@ -459,12 +459,12 @@ by `subed-milliseconds-adjust' milliseconds."
   (interactive "e")
   (save-excursion
     (when subed-waveform--pixels-per-second
-           (let* ((x1 (car (elt (elt event 2) 2)))
-                                                (x2 (car (elt (elt event 1) 
2)))
-                                                (msecs
-                                                       (floor (* 1000 (/ (- x1 
x2)     ; pixels moved
-                                                                               
                                                
subed-waveform--pixels-per-second)))))
-                               (subed-adjust-subtitle-time-stop msecs)))))
+      (let* ((x1 (car (elt (elt event 2) 2)))
+             (x2 (car (elt (elt event 1) 2)))
+             (msecs
+              (floor (* 1000 (/ (- x1 x2) ; pixels moved
+                                subed-waveform--pixels-per-second)))))
+        (subed-adjust-subtitle-time-stop msecs)))))
 
 (defun subed-waveform-split (event)
   "Split the current subtitle.



reply via email to

[Prev in Thread] Current Thread [Next in Thread]