Re: rescale srt files

[A Soare <alinsoar@voila.fr>]

I wrote that script in 2006, and used it all the time since. I re wrote it
almost completely before yesterday.

Today I did a few minor changes.

I attach here again the last versin. If you need it, use and modify it as you
wish. The same if you want to install it in emacs. You are free to modify it to
conform to the emacs' writinf rules.





------------------------------------------ ***







(defun dialog-create (INDEX START-TIME END-TIME TEXT)
  (list INDEX START-TIME END-TIME TEXT) )

(defun dialog-index (what)
  (let ((vector '( INDEX START-TIME END-TIME TEXT ) )
	(r nil))
    (dotimes (x 4 r ) (if (eq (nth x vector) what) (setq r x) ) ) ) )

(defun dialog-get (what dialog)
  (let ((pos (dialog-index what) ) )
    (nth pos dialog) ) )

(defun dialog-set (what new dialog)
  (let ((pos (dialog-index what) ) )
    (setcar (nthcdr pos dialog) new) )
  dialog )

(defun timestamp-to-miliseconds (H M S MS)
  "convert a group (HOUR MINUTE SECONDS MILISECONDS) to
 TIMESTAMP (MILISECONDS)"
  (+ MS (* 1000 (+ S (* M 60) (* H 3600) ) ) ) )

(defun miliseconds-to-timestamp (TIMESTAMP)
  "convert TIMESTAMP (MILISECONDS) to the list
 (HOUR MINUTE SECONDS MILISECONDS)"
  (let (MS S M H)
    (setq
     MS (% TIMESTAMP 1000)		; miliseconds
     TIMESTAMP (/ (- TIMESTAMP MS) 1000)
     S (% TIMESTAMP 60)			; seconds
     TIMESTAMP (/ (- TIMESTAMP S) 60)
     M (% TIMESTAMP 60)			; minutes
     H (/ (- TIMESTAMP M) 60) )		; hours
    (list H M S MS) ) )

(defun read-text (limit &optional skip-first type)
  (and skip-first
       (re-search-forward skip-first) )
  (let ((data (buffer-substring
	       (point)
	       (- (re-search-forward limit)
		  (length limit) ) ) ) )
    (if (eq type 'S)
	data
      (string-to-number data ) ) ) )

;; 608
;; 1:0:27,650 --> 1:0:34,849
;; One hunk starts at `608', and ends before `609'.
;; This is the text of the current hunk.
;;
;; 609
;; 1:0:38,723 --> 1:0:41,839
;; TEXT-HUNK `609'
(defun read-one-hunk nil
  (setq index (+ (read-text "\n") last-index-first-file) )
  (let ((HHs (read-text ":") )
	(MMs (read-text ":") )
	(SSs (read-text ",") )
	(MSs (read-text " ") )
	(HHe (read-text ":" "-->") )
	(MMe (read-text ":") )
	(SSe (read-text ",") )
	(MSe (read-text "\n") )
	(text (read-text "\n\n" nil 'S) ) )
    ;; jumps to the beginning of the next hunk
    (skip-chars-forward "[:blank:]\n")
    (dialog-create
     index
     (+ (timestamp-to-miliseconds HHs MMs SSs MSs) offset )
     (+ (timestamp-to-miliseconds HHe MMe SSe MSe) offset )
     text ) ) )

(defun write-one-hunk (hunk)
    (set 'stime (dialog-get 'START-TIME hunk))
    (set 'etime (dialog-get 'END-TIME hunk))
    (insert (format "%d\n%02d:%02d:%02d,%03d --> %02d:%02d:%02d,%03d\n%s\n\n"
                    (dialog-get 'INDEX hunk)
                    (car stime) (cadr stime) (nth 2 stime) (nth 3 stime)
                    (car etime) (cadr etime) (nth 2 etime) (nth 3 etime)
                    (dialog-get 'TEXT hunk) ) ) )

(defun read-file-srt (file offset)
  (let (index prev-index)
    (with-current-buffer (find-file-noselect file)
      (goto-char 1)
      (while (> (buffer-size) (point) )
	(push (read-one-hunk) titrage)
	(if (and prev-index (> 1 (- index prev-index ) ) )
	    (error "srt file contains errrors [ at the index %d ]" prev-index) )
	(setq prev-index index) )
      (kill-buffer (current-buffer) ) ) ) )

(defun rescale (what)
  (+ first-required-dialog-time
     (truncate (* (- (dialog-get what x)
		     first-orginal-dialog-time)
		  speed) ) ) )

(defun re-titrage
  (File1
   first-required-dialog-time
   first-index
   second-required-dialog-time
   second-index
   &optional File2
   length-first-part
   )
  (let ((last-index-first-file 0)
	titrage
	first-orginal-dialog-time
	second-orginal-dialog-time)
    (read-file-srt File1 0)
    (setq last-index-first-file (dialog-get 'INDEX (car titrage) ) )
    (and File2 (read-file-srt File2 length-first-part) )
    (setq titrage (nreverse titrage))

    (setq
     second-orginal-dialog-time
     (dialog-get 'START-TIME (nth (1- second-index) titrage) )
     first-orginal-dialog-time
     (dialog-get 'START-TIME (nth (1- first-index) titrage) ) )

     (progn
       (let ((speed
	      (/ (float (- second-required-dialog-time
			   first-required-dialog-time) )
		 (float (- second-orginal-dialog-time
			   first-orginal-dialog-time) ) ) ) )
       (dolist (x titrage)
	(let ((new-start-time
	       (miliseconds-to-timestamp 
		(if first-required-dialog-time
		    (rescale 'START-TIME)
		  (dialog-get 'START-TIME x) ) ) )
	      (new-end-time
	       (miliseconds-to-timestamp
		(if first-required-dialog-time
		    (rescale 'END-TIME)
		(dialog-get 'END-TIME x) ) ) ) )
	  (dialog-set 'START-TIME new-start-time x )
	  (dialog-set 'END-TIME new-end-time x ) ) ) ) )
     titrage ) )

(defun make-new-file (titrage)
  (setq default-enable-multibyte-characters nil)
  (set-buffer-multibyte nil)
  (set-buffer (find-file "new") )
  (dolist (x titrage)
	(write-one-hunk x) ) )

(make-new-file
 (re-titrage
  "/1"
  ;; first-required-dialog-time = NIL lorsqu'on veut enchainer 2 fichiers
  ;; (la vitesse demeure toujours constante a 1 en ce cas)
  (timestamp-to-miliseconds 0 3 34 0)
  ;; nil
  ;; INDEX 1
  16
  ;; le deuxieme dialogue
  (timestamp-to-miliseconds 1 37 51 0 )
  ;; INDEX 2
  1467
  ;; le deuxieme fichier (quand existant) va avoir la meme vitesse que
  ;; le premier ( 1 lorsque first-required-dialog-time est NIL. )
  ;;
  ;; "/2"
  ;;
  ;; lorsqu'on a la deuxieme partie, on est cense d'y pourvoir la
  ;; longueur de la premiere partie
  ;;
  ;; (timestamp-to-miliseconds 1 7 6 0 )
  ) )


'( (eval-current-buffer)
   
   )