Video Cut Automation with ffmpeg

  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
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201

#######################################################
# Carries out a cutting plan containing several videos,
# each video can have a list of cuts.
#######################################################

which ffmpeg >/dev/null || {
	echo "You must have ffmpeg installed to cut videos with this script!" >&2
	exit 1
}

[ -z "$1" ] && {
	echo "SYNTAX: $0 videoDir/[cuts.txt] [-mpegts]" >&2
	echo "	All files.MP4 must be in same directory as cuts.txt is." >&2
	echo "	cuts.txt contains video names and start - end times of cuts below it." >&2
	echo "	Example:" >&2
	echo "		GOPR0123.MP4" >&2
	echo "		0:59 - 1:2:34.5" >&2
	echo "		1:30 - end" >&2
	echo "		GOPR0456.MP4" >&2
	echo "		all" >&2
	echo "	Lines starting with spaces will be ignored." >&2
	echo "	'End' (end of video) and 'All' (whole video) are case-insensitive keywords." >&2
	echo "	Use -mpegts option when videos have different codecs, but mind that results are not .MP4 then, they are to be joined by concat.sh!" >&2
	exit 2
}

if [ -d $1 ]	# assume default cuts.txt
then
	videoDir=$1
	cuttingPlan=cuts.txt
elif [ -f $1 ]	# explicitly named cutting plan
then
	videoDir=`dirname \$1`
	cuttingPlan=`basename \$1`
else
	echo "Could not find directory or file $1" >&2
	exit 3
fi

if [ "$2" = "-mpegts" ]	# write cuts in transport stream format for concat.sh
then
	mpegts=true	# this is needed when videos come from different sources
else
	mpegts=false
fi

cd $videoDir || exit 4

cutsDir=cuts
rm -rf $cutsDir 2>/dev/null	# remove all former clips
mkdir $cutsDir || exit 5

# read the cutting plan and execute it
awk '
	BEGIN	{
		IGNORECASE = 1	# make all pattern matching case-insensitive
		toMpegTs = ("'$mpegts'" == "true")	# mpegts comes from underlying shell
		cutsDir = "'$cutsDir'"
		
		if (exists("TITLE.MP4"))
			if (toMpegTs)	{	# must convert to transport-stream format
				videoFile = "TITLE.MP4"
				addCommand("0:0", "end")
			}
			else	# no need to cut title
				system("cp TITLE.MP4 " cutsDir "/000_TITLE_CUT.MP4")
	}
	
	function nextClipFile()	{	# build the name "001_GOPR01234_CUT.MP4"
		if ( ! fileNr )
			fileNr = 0
		fileNr++
		
		videoClipFile = toupper(videoFile)
		sub(/\.MP4$/, "", videoClipFile)	# remove extension
		sortNumber = sprintf("%03i", fileNr)	# zero-padded sort number
		videoClipFile = sortNumber "_" videoClipFile "_CUT.MP4" (toMpegTs ? "TS" : "")
		
		return cutsDir "/" videoClipFile	# cutsDir comes from underlying shell
	}
	
	function addCommand(fromTime, toTime)	{
		if (toTime ~ /^end/)	 {
			checkWithinVideo(calculateSeconds(fromTime))
			toTime = ""		# take all until end
			duration = ""
		}
		else	{
			durationSeconds = checkFromTo(fromTime, toTime)	# checks both for correctness and existence
			toTime = "-to " toTime
			duration = "-t " durationSeconds
		}
		
		mpegts = toMpegTs ? " -bsf:v h264_mp4toannexb -f mpegts " : ""
		
		# output seeking by decoding, slow, fails with MPEGTS
		# commands[fileNr] = "ffmpeg -v error -y -i " videoFile " -ss " fromTime " " toTime " -c copy -avoid_negative_ts 1 " mpegts nextClipFile()
		
		# input seeking by keyframes, fast, not precise, works with MPEGTS
		commands[fileNr] = "ffmpeg -v error -y -ss " fromTime " " duration " -i " videoFile " -c copy -avoid_negative_ts 1 " mpegts nextClipFile()
	}
	
	function executeCommand(command)	{
		print command
		exitCode = system(command)
		if (exitCode != 0)
			executionError("Command failed with exit " exitCode ": " command, exitCode)
	}
	
	function checkFromTo(from, to)	{
		fromSeconds = calculateSeconds(from)
		toSeconds = calculateSeconds(to)
		
		if (fromSeconds < 0)
			error("Begin-time " fromSeconds " is negative: " $0, 7)
			
		if (fromSeconds >= toSeconds)
			error("Begin-time " from " is greater or equal end-time " to, 7)
		
		checkWithinVideo(toSeconds)
		return toSeconds - fromSeconds
	}
	
	function checkWithinVideo(timeInSeconds)	{
		if (timeInSeconds > 0)	{	# no need to check zero
			durationCommand = "ffprobe -v error -show_entries format=duration -of default=noprint_wrappers=1:nokey=1 " videoFile
			durationCommand | getline videoSeconds
			close(durationCommand)
			if ( ! videoSeconds )
				error("Could not read video seconds from " videoFile)
			
			print "Checking if " videoFile " having " videoSeconds " seconds contains " timeInSeconds >"/dev/stderr"
			if (timeInSeconds >= videoSeconds)
				error("Time " timeInSeconds " is out of video bounds (" videoSeconds " seconds): " $0, 7)
		}
		return videoSeconds
	}
	
	function calculateSeconds(time)	{
		numberOfTimeParts = split(time, timeParts, ":")
		resultTime = 0
		for (i in timeParts)	{
			timePart = timeParts[i]
			if (timePart !~ /^[0-9\.]+$/)
				error("Invalid time part: " timePart, 7)
			
			resultTime += timePart
			if (i < numberOfTimeParts)
				resultTime *= 60
		}
		return resultTime
	}
	
	function error(message, exitCode)	{
		print "ERROR in '$cuttingPlan' at line " NR ": " message >"/dev/stderr"
		quit(exitCode)
	}
	
	function executionError(message, exitCode)	{
		print "EXECUTION ERROR: " message >"/dev/stderr"
		quit(exitCode)
	}
	
	function quit(exitCode)	{
		errNo = exitCode	# make END do nothing
		exit exitCode
	}
	
	function exists(filePath)	{
		return system("test -f " filePath) == 0
	}
	
	
	/^[a-zA-Z0-9_\-]+\.MP4[ \t]*$/	{	# next video file
		videoFile = $1
		if ( ! exists(videoFile) )
			error("file does not exist or is empty: " videoFile, 8)
	}
	
	/^[0-9]+:[0-9]+/	{	# next start - end times of a clip to extract
		if (videoFile)	# there was a video file name before
			addCommand($1, ($2 == "-" ? $3 : $2))
		else
			error("Found start - end time without video file: " $0, 9)
	}
	
	/^all/	{	# copy the whole video as clip
		addCommand("0", "end")
	}
	
	END	{
		if ( ! errNo )	# error() would set this
			if ( ! fileNr )
				error("No videos were found in '$cuttingPlan' !", 9)
			else
				for (c in commands)	# execute all collected commands
					executeCommand(commands[c])
	}
' $cuttingPlan || exit $?

echo "Generated cut videos in `pwd`/$cutsDir"

 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

#######################################################
# Joins together video clips created by cutVideos.sh.
#######################################################

allCutsFile=ALLCUTS.MP4

[ -z "$1" ] && {
	echo "SYNTAX: $0 videoDir" >&2
	echo "	Generates $allCutsFile from all _CUT.MP4 videos." >&2
	echo "	videoDir: location of original videos where 'cuts' directory is below." >&2
	exit 1
}

cd $1/cuts || exit 2	# naming convention used in cuts.sh

concatFile=concat.txt
rm -f $concatFile

formatProperties()	{	# $1 = property name, $2 = video file path
	ffprobe -v error -show_entries format=$1 -of default=noprint_wrappers=1 $2 | sort | uniq | sed 's/^/format /'
}

streamProperties()	{	# $1 = property name, $2 = stream name, $3 = video file path
	ffprobe -v error -select_streams $2 -show_entries stream=$1 -of default=noprint_wrappers=1 $3 | sort | uniq | sed 's/^/'$2' /'
}

cleanup()	{
	rm -f ffprobe1.check ffprobe2.check $concatFile
}

error()	{	# message, exitcode
	echo $1 >&2
	cleanup
	exit $2
}

cleanup

for videoClip in `ls -1 *_CUT.MP4* | sort`	# naming convention used in cutVideos.sh
do
	case $videoClip in
		*.MP4TS)
			[ "$mpegts" = "false" ] && error "Can not mix .MP4 and .MP4TS files: $videoClip" 6
			mpegts=true
			;;
		*.MP4)
			[ "$mpegts" = "true" ] && error "Can not mix .MP4TS and .MP4 files: $videoClip" 7
			mpegts=false
			;;
	esac
	
	[ "$mpegts" = "false" ] &&	{	# check if different codecs
		if [ -f ffprobe1.check ]
		then
			checkfile=ffprobe2.check
		else
			checkfile=ffprobe1.check
			firstClip=$videoClip
		fi
		
		formatProperties format_name $videoClip >$checkfile
		streamProperties codec_name,profile,time_base,pix_fmt,r_frame_rate,width,height v:0 $videoClip >>$checkfile
		streamProperties codec_name,sample_rate,channels a:0 $videoClip >>$checkfile
		
		[ -f ffprobe2.check ] && 	{	# being at second file
			diff ffprobe1.check ffprobe2.check || error "The video $firstClip (left) seems not to be combinable with $videoClip (right)!" 8
		}
	}
	
	echo "file $videoClip" >>$concatFile
done

[ -f $concatFile ] || error "No *_CUT.MP4* files found in given directory: $1" 9


# concatenate the videos
[ -f $allCutsFile ] && { rm -f $allCutsFile || exit 4; }
[ "$mpegts" = "true" ] && fromMpegTs="-bsf:a aac_adtstoasc -brand avc1 -f 3gp"

ffmpeg -v error -y -f concat -i $concatFile -c copy $fromMpegTs $allCutsFile

cleanup
echo "Generated $allCutsFile in `pwd`"