#!/bin/bash

IFS=$'\012'  # IFS="\n"

echo "FILENAME of your language subtitle: "
read MYL_SUB
echo "FILENAME of foreign language subtitle: "
read FOR_SUB

ARR_MYL=(`cat $MYL_SUB`)
ARR_FOR=(`cat $FOR_SUB`)


rm DBLang.srt


NEX_FOR=0
ARR_POS=-1
CEASE=0
TICK=0



currLineFOR()
{
	ARR_POS_FOR=$NEX_FOR
	CEASE_FOR=0
	FIRST_FOR=0
	while [ $FIRST_FOR -eq 0 ];do
		VAL_FIR_FOR=${ARR_FOR[$ARR_POS_FOR]}
		VAL_FIR3_FOR=${VAL_FIR_FOR:2:1}
		if [ "$VAL_FIR3_FOR" == ":" ]; then
			let FIRST_FOR=1
		else
			let ARR_POS_FOR=ARR_POS_FOR+1	
		fi
	
	done
	
	CUR_LIN_FOR=${ARR_FOR[$ARR_POS_FOR]}
	IFS=":"
	TIM_GAP_FOR=${CUR_LIN_FOR:1:2}
	TIM_GAP_FOR=($CUR_LIN_FOR)
	IFS=" --> "
	arrOW_FOR=(${TIM_GAP_FOR[2]})
	IFS=":"
	
	
	CURR_FOR_HR=$((10#${TIM_GAP_FOR[0]}))
	CURR_FOR_MN=$((10#${TIM_GAP_FOR[1]}))
	CURR_FOR_SC=$((10#${arrOW_FOR[0]:0:2}))
	
	unset IFS
}


nextLineFOR() 
{
	CEASE=0
	NEX_FOR=$(( $ARR_POS_FOR+1 ))
	while [ $CEASE_FOR -eq 0 ] && [ $NEX_FOR -lt $(( $ARR_POS_FOR+17)) ]; do
		VAL_NEX_FOR=${ARR_FOR[$NEX_FOR]}
		VAL_NEX3_FOR=${VAL_NEX_FOR:2:1}
		if [ "$VAL_NEX3_FOR" == ":" ]; then
			let CEASE_FOR=CEASE_FOR+1
			DIF_VAL_FOR=$(( $NEX_FOR-$ARR_POS_FOR ))
		else
			let NEX_FOR=NEX_FOR+1
		fi
	done
	
	NEX_LIN_FOR=${ARR_FOR[$NEX_FOR]}
	IFS=":"
	TIM_NEX_FOR=${NEX_LIN_FOR:1:2}
	TIM_NEX_FOR=($NEX_LIN_FOR)
	IFS=" --> "
	arrOW_FOR_NEX=(${TIM_NEX_FOR[2]})
	IFS=":"
	
	unset IFS
}




currLineFOR
nextLineFOR




nextLine()
{
	CEASE=0
	NEX=$(( $ARR_POS+1 ))
	while [ $CEASE -eq 0 ] && [ $NEX -lt $(( $ARR_POS+17)) ]; do
		VAL_NEX=${ARR_MYL[$NEX]}
		VAL_NEX3=${VAL_NEX:2:1}
		if [ "$VAL_NEX3" == ":" ]; then
			let CEASE=CEASE+1
			DIF_VAL=$(( $NEX-$ARR_POS ))
		else
			let NEX=NEX+1
		fi
	done
	
	NEX_LIN=${ARR_MYL[$NEX]}
	IFS=":"
	TIM_GAP_NEX=${NEX_LIN:1:2}
	TIM_GAP_NEX=($NEX_LIN)
	IFS=" --> "
	arrOW_GAP_NEX=(${TIM_GAP_NEX[2]})
	IFS=":"
	
	CURR_NEX_HR=$((10#${TIM_GAP_NEX[0]}))
	CURR_NEX_MN=$((10#${TIM_GAP_NEX[1]}))
	CURR_NEX_SC=$((10#${arrOW_GAP_NEX[0]:0:2}))
}




loopLineFOR()
{
	CHECK=1
	let DIF_VAL_FOR=DIF_VAL_FOR-2
	while [ $CHECK -lt $DIF_VAL_FOR ]; do
		echo ${ARR_FOR[$(( $ARR_POS_FOR+$CHECK ))]}>>DBLang.srt
		let CHECK=CHECK+1
	done
}




loopLine()
{
	CHECK=1
	let DIF_VAL=DIF_VAL-2
	while [ $CHECK -lt $DIF_VAL ]; do
		echo ${ARR_MYL[$(( $ARR_POS+$CHECK ))]}>>DBLang.srt
		let CHECK=CHECK+1
	done
}




################################################
################################################

checkHIGH()
{
	CURR_LIN_HR=$((10#${TIM_GAP[0]}))
	CURR_LIN_MN=$((10#${TIM_GAP[1]}))
	CURR_LIN_SC=$((10#${arrOW[0]:0:2}))


	CURR_NEX_HR=$((10#${TIM_GAP_NEX[0]}))
	CURR_NEX_MN=$((10#${TIM_GAP_NEX[1]}))
	CURR_NEX_SC=$((10#${arrOW_GAP_NEX[0]:0:2}))
	
	
	CURR_FOR_HR=$((10#${TIM_GAP_FOR[0]}))
	CURR_FOR_MN=$((10#${TIM_GAP_FOR[1]}))
	CURR_FOR_SC=$((10#${arrOW_FOR[0]:0:2}))
	
	GAP_CUR_FOR_HR=$(( $CURR_LIN_HR-$CURR_FOR_HR ))
	GAP_NEX_FOR_HR=$(( $CURR_NEX_HR-$CURR_FOR_HR ))
	
	if [ $CURR_LIN_HR == 1 ]; then
		CURR_LIN_DEC=`echo -e "scale=2; ($CURR_LIN_SC/60)+$CURR_LIN_MN+60" | bc`
	else
		CURR_LIN_DEC=`echo -e "scale=2; ($CURR_LIN_SC/60)+$CURR_LIN_MN" | bc`
	fi
		
	if [ $CURR_FOR_HR == 1 ]; then
		CURR_FOR_DEC=`echo -e "scale=2; ($CURR_FOR_SC/60)+$CURR_FOR_MN+60" | bc`
	else
		CURR_FOR_DEC=`echo -e "scale=2; ($CURR_FOR_SC/60)+$CURR_FOR_MN" | bc`
	fi	
	
	if [ $CURR_NEX_HR == 1 ]; then
		CURR_NEX_DEC=`echo -e "scale=2; ($CURR_NEX_SC/60)+$CURR_NEX_MN+60" | bc`
	else
		CURR_NEX_DEC=`echo -e "scale=2; ($CURR_NEX_SC/60)+$CURR_NEX_MN" | bc`
	fi


	GAP_CUR_FOR_DC=`echo -e "scale=2; ($CURR_LIN_DEC-$CURR_FOR_DEC)*100" | bc`
	GAP_CUR_FOR_IN=`echo -e "scale=0; $GAP_CUR_FOR_DC/1" | bc`
	
	GAP_NEX_FOR_DC=`echo -e "scale=2; ($CURR_NEX_DEC-$CURR_FOR_DEC)*100" | bc`
	GAP_NEX_FOR_IN=`echo -e "scale=0; $GAP_NEX_FOR_DC/1" | bc`
	
	

	if [ ${GAP_CUR_FOR_IN#-} -lt ${GAP_NEX_FOR_IN#-} ]; then
		if [ -z "${ARR_FOR[$(( $ARR_POS_FOR+3 ))]}" ];then
			echo -e "\ni7h43"
			exit
		fi
		loopLineFOR
		currLineFOR
		nextLineFOR
		checkHIGH
	else
		loopLine
		echo -ne "    $CURR_LIN_HR:$CURR_LIN_MN:$CURR_LIN_SC    \r"
		let TICK=TICK+1
	fi
}


################################################
################################################



IFS=$'\012'  # IFS="\n"
for CUR_LIN in ${ARR_MYL[@]}
do
	let ARR_POS=ARR_POS+1
	LIN_TRD=${CUR_LIN:2:1}
	if [ "$LIN_TRD" == ":" ];then
		IFS=":"
		TIM_GAP=${CUR_LIN:1:2}
		TIM_GAP=($CUR_LIN)
		IFS=" --> "
		arrOW=(${TIM_GAP[2]})
		IFS=":"
		
		nextLine
		echo -e "\n$TICK\n$CUR_LIN">>DBLang.srt
		checkHIGH
	fi
done
exit
unset IFS

IFS=" --> "

ARR_MYL=(`cat $MYL_SUB`)
ARR_FOR=(`cat $FOR_SUB`)

#!/bin/bash

# This script merges two srt language subtitle files into one that displays
# both subtitles at once.  If the display times are different between the files
# it will use the longest value.

# If no arguments are given print usage message and exit.
if [[ -z $1 ]]; then
	echo "Merges two .srt files into one."
	echo
	echo "Usage: ${0##*/} <infile1> <infile2> [outfile]"
	echo "If no output file is given, it will print to stdout."
	echo
	echo "Requires bash v.4.2 or higher."
	exit 1
fi >&2


# Set the output to a file descriptor that goes to the filename given
# as parameter $3, or to stdout if not supplied.
if [[ -n $3 ]]; then
	exec 6>"$3"
else
	exec 6>&1
fi

shopt -s extquote	# Needed to handle newlines and carriage returns inside parameters.
LANG=C			# Ensure that the locale uses straight ascii, due to string comparisons used.

# The readfile function reads the input srt files and sets two matching arrays
# from them (time and dialog). The actual array names it uses are passed to it
# during execution, while the indexes of the arrays are taken from the files entries.
# This function requires a recent version of bash (4.2+), because it sets dynamic
# array names with printf -v, and older versions don't accept array elements
# in that option.
# $1 is the filename, $2 is the time array name, and $3 is the dialog array name.
readfile() {

	# Set local regexes to match the index line and the time line, plus local variables.
	local re1='^([0-9]+)$' re2='[:].*-->.*[:]' line idx dlg

	# Loop through the input file.
	while read -r line || [[ -n $line ]]; do

		line=${line%$'\r'}	# Remove any trailing dos carriage returns.

		if [[ -z $line ]]; then		# Reset dlg on blank lines.

			dlg=""
			lastline=$line
			continue

		elif [[ -z $lastline && $line =~ $re1 ]]; then	# If the line contains only a number (and was
								# preceded by a blank line to avoid false
								# positives), use it as the next array index.
			idx=${BASH_REMATCH[1]}			
			lastline=$line
			continue
		
		elif [[ $line =~ $re2 ]]; then	# If the line matches the time regex, add it to the tm array.
			
			printf -v "$2[idx]" '%s' "$line"
		
		else				# All other lines get concatenated with newlines between them.
			
			dlg="${dlg:+$dlg$'\n'}$line"
		
		fi
		
		# Set the current dlg array index to the value of dlg.
		printf -v "$3[idx]" '%s' "$dlg"
		lastline=$line

done <"$1"

}

# Call the file-reading function, and pass it the names of the arrays.
readfile "$1" lang1tm lang1dlg
readfile "$2" lang2tm lang2dlg

# See if the two files have an equal number of indexes,
# and print a warning in such cases.
if (( ${#lang1tm[@]} != ${#lang2tm[@]} )); then
	echo
	echo "=================================================================="
	echo "Warning!  The two files do not contain an equal number of indexes."
	echo              "The lines may not merge correctly."
	echo "=================================================================="
	echo
fi >&2

# Get the longest array value.
(( ln = ${#lang1tm[@]} > ${#lang2tm[@]} ? ${#lang1tm[@]} : ${#lang2tm[@]} )) 

# Loop through the arrays.
for (( i=1; i<=ln; i++ )); do

	# Compare start and end times from the two arrays.
	# Simple string comparison turns out to be adequate in this case.
	# Use the lowest start time and the highest end time.
	# In addition, if one array has no entry, use the value of the other.

	start1=${lang1tm[i]%% *}
	end1=${lang1tm[i]##* }
	start2=${lang2tm[i]%% *}
	end2=${lang2tm[i]##* }

	[[ $start1 < $start2 ]] && start=${start1:-$start2} || start=${start2:-$start1}
	[[ $end1 > $end2 ]] && end=${end1:-$end2} || end=${end2:-$end1}

	# Format and print the completed entry to file (or stdout).
	# Note that the output uses unix newlines.  replace \n with \r\n if dos format is required.
		printf "%s\n" "$i"
		printf "%s --> %s\n" "$start" "$end"
		printf "%s\n" "${lang1dlg[i]}"
		printf "%s\n\n" "${lang2dlg[i]}"

done >&6

exit 0

IFS=$'\012'  # IFS="\n"

i7h43

# IFS="shit"; echo "hello shitty husband">FIZL; ARR=(`cat FIZL`); echo ${ARR[0]} .. ${ARR[1]} .. ${ARR[2]} .. ${#ARR[@]}; rm FIZL
.. ello  .. .. 9
# IFS=" shit "; echo "hello shitty husband">FIZL; ARR=(`cat FIZL`); echo ${ARR[0]} .. ${ARR[1]} .. ${ARR[2]} .. ${#ARR[@]}; rm FIZL
.. ello .. .. 9
# IFS=" "; echo "hello shitty husband">FIZL; # ARR=(`cat FIZL`); echo ${ARR[0]} .. ${ARR[1]} .. ${ARR[2]} .. ${#ARR[@]}; rm FIZL
hello .. shitty .. husband .. 3
# IFS=" s "; echo "hello shitty husband">FIZL; # ARR=(`cat FIZL`); echo ${ARR[0]} .. ${ARR[1]} .. ${ARR[2]} .. ${#ARR[@]}; rm FIZL
hello .. hitty .. hu .. 4
# IFS="s"; echo "hello shitty husband">FIZL; ARR=(`cat FIZL`); echo ${ARR[0]} .. ${ARR[1]} .. ${ARR[2]} .. ${#ARR[@]}; rm FIZL
hello  .. hitty hu .. band .. 3

#!/usr/bin/env python
# -*- coding: utf8 -*-
from pysrt import SubRipFile
from pysrt import SubRipItem
import sys

#need 3 arguments at least, (4 because first is the program name itself)
if len(sys.argv) < 4:
	print "usage : ./submerge.py lang1.srt lang2.srt [langn.srt ...] out.srt"
	sys.exit()

#load and parse input subtitles, merge in one list
subs = SubRipFile.open(sys.argv[1], encoding='iso-8859-1')
for i in range(2,(len(sys.argv) - 1)):
	subs.extend(SubRipFile.open(sys.argv[i], encoding='iso-8859-1'))

#sort all languages mixed by start time
subs.sort(key=lambda item:item.start)

#init output file
out = SubRipFile()

#init the buffer : the current displayed subtitles (0..n). Loads the first title to start, and curTime to the first start time
buffer = list()
buffer.append(subs.pop(0))
curTime = buffer[0].start

while len(subs) > 0:
	#init output item
	itemMerge = SubRipItem() 

	#load in the buffer all items starting at the same time
	while len(subs) > 0 and buffer[0].start == subs[0].start:
		buffer.append(subs.pop(0))

	#merge text from all items in buffer
	for item in buffer:
		itemMerge.text = itemMerge.text + item.text + '\n'
	itemMerge.text.strip() #remove last \n

	#output start time
	itemMerge.start = curTime

	#find the first item in buffer that will end	
	firstEnd = min(buffer,key=lambda item:item.end).end

	#if next title start before the first in buffer to end, we add the next title to the buffer, and end the current output item to the start of the new item
	if len(subs) > 0 and subs[0].start < firstEnd:
		curTime = subs[0].start
		buffer.append(subs.pop(0))
		itemMerge.end = curTime

	#else, we output item is ended with the first item in buffer to end
	else:
		curTime = firstEnd
		itemMerge.end = firstEnd

		#we remove from buffer all items ending at the same time
		buffer = [item for item in buffer if item.end > firstEnd]

		#if buffer is empty, we load the next one.
		if len(subs) > 0 and len(buffer) == 0 :
			curTime = subs[0].start
			buffer.append(subs.pop(0))

	#add item to output file
	out.append(itemMerge)

#write to disk ouput file
out.save(sys.argv[-1])