moshy 1.0.1 → 2.0.1

data/lib/moshy/bake.rb

@@ -1,68 +1,68 @@
-module Moshy
-	class Bake
-		def cli(args)
-			opts = Slop::Options.new
-			opts.separator 'Required Parameters:'
-			opts.string '-i', '--input', 'Input file path - can be anything that ffmpeg supports.'
-			opts.string '-o', '--output', 'File output path - should end in .avi.'
-			opts.separator 'Optional Parameters:'
-			opts.integer '-b', '--bitrate', 'Bitrate amount (kb/s). Defaults to 4196. Larger number means higher quality, but larger size.'
-			opts.string '-p', '--pframes', 'Makes sure that there are only P-Frames (no B-Frames). Set this true if you plan to mosh your baked file again. Defaults false.'
-			opts.integer '-n', '--iframe-interval', 'Ideal interval for I-Frames to be distributed. Set this to a high number (600) if you plan to mosh your baked file again.'
-
-			default = {
-				:bitrate => 4196
-			}
-
-			parser = Slop::Parser.new(opts)
-			slop_options = parser.parse(ARGV)
-			@options = default.merge(slop_options) { |key, oldval, newval|
-				if newval.nil?
-					oldval
-				else
-					newval
-				end
-			}
-
-			if @options[:pframes] == "false"
-				@options[:pframes] = false
-			else
-				@options[:pframes] = true
-			end
-
-			# Check mandatory params
-			mandatory = [:input, :output]
-			missing = mandatory.select{ |param| @options[param].nil? }
-			unless missing.empty?
-				puts "Missing options: #{missing.join(', ')}"
-				puts slop_options
-				exit
-			end
-
-			prep @options[:input], @options[:output], @options[:pframes], @options[:'iframe-interval'], @options[:bitrate]
-		end
-
-		def prep(file, output, pframes, iframe_interval, bitrate)
-			ffmpeg = Av::Commands::Ffmpeg.new
-			ffmpeg.add_source file
-			ffmpeg.add_destination output
-
-			# Ensures all frames come out as P-frames, B-frames don't
-			# dupe or mosh properly
-			if pframes
-				ffmpeg.add_output_param ['bf', 0]
-			end
-
-			# Keyframe interval, sets as few I-frames as possible.
-			# ffmpeg will complain about anything over 600 and cap it.
-			if iframe_interval
-				ffmpeg.add_output_param ['g', iframe_interval.to_s]
-			end
-
-			# Bitrate
-			ffmpeg.add_output_param ['b:v', bitrate.to_s + 'k']
-
-			ffmpeg.run
-		end
-	end
-end
+module Moshy
+	class Bake
+		def cli(args)
+			opts = Slop::Options.new
+			opts.separator 'Required Parameters:'
+			opts.string '-i', '--input', 'Input file path - can be anything that ffmpeg supports.'
+			opts.string '-o', '--output', 'File output path - should end in .avi.'
+			opts.separator 'Optional Parameters:'
+			opts.integer '-b', '--bitrate', 'Bitrate amount (kb/s). Defaults to 4196. Larger number means higher quality, but larger size.'
+			opts.string '-p', '--pframes', 'Makes sure that there are only P-Frames (no B-Frames). Set this true if you plan to mosh your baked file again. Defaults false.'
+			opts.integer '-n', '--iframe-interval', 'Ideal interval for I-Frames to be distributed. Set this to a high number (600) if you plan to mosh your baked file again.'
+
+			default = {
+				:bitrate => 4196
+			}
+
+			parser = Slop::Parser.new(opts)
+			slop_options = parser.parse(ARGV)
+			@options = default.merge(slop_options) { |key, oldval, newval|
+				if newval.nil?
+					oldval
+				else
+					newval
+				end
+			}
+
+			if @options[:pframes] == "false"
+				@options[:pframes] = false
+			else
+				@options[:pframes] = true
+			end
+
+			# Check mandatory params
+			mandatory = [:input, :output]
+			missing = mandatory.select{ |param| @options[param].nil? }
+			unless missing.empty?
+				puts "Missing options: #{missing.join(', ')}"
+				puts slop_options
+				exit
+			end
+
+			prep @options[:input], @options[:output], @options[:pframes], @options[:'iframe-interval'], @options[:bitrate]
+		end
+
+		def prep(file, output, pframes, iframe_interval, bitrate)
+			ffmpeg = Av::Commands::Ffmpeg.new
+			ffmpeg.add_source file
+			ffmpeg.add_destination output
+
+			# Ensures all frames come out as P-frames, B-frames don't
+			# dupe or mosh properly
+			if pframes
+				ffmpeg.add_output_param ['bf', 0]
+			end
+
+			# Keyframe interval, sets as few I-frames as possible.
+			# ffmpeg will complain about anything over 600 and cap it.
+			if iframe_interval
+				ffmpeg.add_output_param ['g', iframe_interval.to_s]
+			end
+
+			# Bitrate
+			ffmpeg.add_output_param ['b:v', bitrate.to_s + 'k']
+
+			ffmpeg.run
+		end
+	end
+end

data/lib/moshy/inspect.rb

@@ -1,110 +1,110 @@
-module Moshy
-	class Inspect
-		def cli(args)
-			opts = Slop::Options.new
-			opts.banner = "Usage: moshy -m inspect -i file.avi\nmoshy -m inspect --help for details"
-			opts.separator 'Required Parameters:'
-			opts.string '-i', '--input', 'Input file path - must be an .avi.'
-			opts.on '-h', '--help' do
-				puts opts
-				puts "\n"
-				puts \
-"Reads an .avi file and prints which video frames are keyframes (I-Frames)
-and which frames are delta frames (P-frames or B-frames). moshy can't
-tell the difference between a P-frame or a B-frame, so you will want
-to use avidemux or another program if you need to know.
-
-This is most useful for identifying where I-Frames exist without having
-to manually seek through them in a video player/editor. Works well with
-moshy's \"isplit\" mode because you can use the I-frames from inspect's
-output to decide what segment of clips you want to get by their I-frames.
-
-The output reads like this:
-
-0: keyframe
-1..359: deltaframe
-360: keyframe
-361..441: deltaframe
-
-Large video files will output a lot of text, so you may want to write the
-output to an external file like this:
-
-moshy -m inspect -i video.avi > inspect.txt"
-				exit
-			end
-
-			parser = Slop::Parser.new(opts)
-			@options = parser.parse(ARGV)
-
-			# Check mandatory params
-			mandatory = [:input]
-			missing = mandatory.select{ |param| @options[param].nil? }
-			unless missing.empty?
-				puts "Missing options: #{missing.join(', ')}"
-				puts @options
-				exit
-			end
-
-			puts "Opening file " + @options[:input] + "..."
-			a = AviGlitch.open @options[:input]       # Rewrite this line for your file.
-			puts "Opened!"
-
-			inspect(a)
-		end
-
-		def inspect(clip)
-			keyframe_counter = 0
-			video_frame_counter = 0
-			last_video_frame = 0
-			start_of_frame_segment = 0
-			last_type = nil
-			type = nil
-			# Harvest clip details
-			total_frame_count = clip.frames.count
-			clip.frames.each_with_index do |f, i|
-				if f.is_videoframe?
-					if f.is_keyframe?
-						type = "keyframe"
-					elsif f.is_deltaframe?
-						type = "deltaframe"
-					end
-
-					if video_frame_counter == 0
-						last_type = type
-					end
-
-					if type == last_type
-						last_video_frame = video_frame_counter
-					else
-						# Found a new type segment, print out what we've got
-						if start_of_frame_segment + 1 == last_video_frame
-							segment_string = start_of_frame_segment.to_s + ": " + last_type
-						else
-							segment_string = start_of_frame_segment.to_s + ".." + (last_video_frame - 1).to_s + ": " + last_type
-						end
-						# Let's not add this so we don't confuse the user by making
-						# them think they want to use isplit according to the keyframe count
-						# if last_type == "keyframe"
-						# 	segment_string += " " + keyframe_counter.to_s
-						# 	keyframe_counter += 1
-						# end
-						puts segment_string
-
-						# The new last type will be this type during the next frame segment
-						last_type = type
-						# Update start of the frame segment to this frame
-						start_of_frame_segment = video_frame_counter
-					end
-				end
-				video_frame_counter += 1
-				last_video_frame = video_frame_counter
-			end
-			if start_of_frame_segment + 1 == last_video_frame
-				puts start_of_frame_segment.to_s + ": " + last_type
-			else
-				puts start_of_frame_segment.to_s + ".." + (last_video_frame - 1).to_s + ": " + last_type
-			end
-			puts "All done!"
-		end
-	end
-end
+module Moshy
+	class Inspect
+		def cli(args)
+			opts = Slop::Options.new
+			opts.banner = "Usage: moshy -m inspect -i file.avi\nmoshy -m inspect --help for details"
+			opts.separator 'Required Parameters:'
+			opts.string '-i', '--input', 'Input file path - must be an .avi.'
+			opts.on '-h', '--help' do
+				puts opts
+				puts "\n"
+				puts \
+"Reads an .avi file and prints which video frames are keyframes (I-Frames)
+and which frames are delta frames (P-frames or B-frames). moshy can't
+tell the difference between a P-frame or a B-frame, so you will want
+to use avidemux or another program if you need to know.
+
+This is most useful for identifying where I-Frames exist without having
+to manually seek through them in a video player/editor. Works well with
+moshy's \"isplit\" mode because you can use the I-frames from inspect's
+output to decide what segment of clips you want to get by their I-frames.
+
+The output reads like this:
+
+0: keyframe
+1..359: deltaframe
+360: keyframe
+361..441: deltaframe
+
+Large video files will output a lot of text, so you may want to write the
+output to an external file like this:
+
+moshy -m inspect -i video.avi > inspect.txt"
+				exit
+			end
+
+			parser = Slop::Parser.new(opts)
+			@options = parser.parse(ARGV)
+
+			# Check mandatory params
+			mandatory = [:input]
+			missing = mandatory.select{ |param| @options[param].nil? }
+			unless missing.empty?
+				puts "Missing options: #{missing.join(', ')}"
+				puts @options
+				exit
+			end
+
+			puts "Opening file " + @options[:input] + "..."
+			a = AviGlitch.open @options[:input]       # Rewrite this line for your file.
+			puts "Opened!"
+
+			inspect(a)
+		end
+
+		def inspect(clip)
+			keyframe_counter = 0
+			video_frame_counter = 0
+			last_video_frame = 0
+			start_of_frame_segment = 0
+			last_type = nil
+			type = nil
+			# Harvest clip details
+			total_frame_count = clip.frames.count
+			clip.frames.each_with_index do |f, i|
+				if f.is_videoframe?
+					if f.is_keyframe?
+						type = "keyframe"
+					elsif f.is_deltaframe?
+						type = "deltaframe"
+					end
+
+					if video_frame_counter == 0
+						last_type = type
+					end
+
+					if type == last_type
+						last_video_frame = video_frame_counter
+					else
+						# Found a new type segment, print out what we've got
+						if start_of_frame_segment + 1 == last_video_frame
+							segment_string = start_of_frame_segment.to_s + ": " + last_type
+						else
+							segment_string = start_of_frame_segment.to_s + ".." + (last_video_frame - 1).to_s + ": " + last_type
+						end
+						# Let's not add this so we don't confuse the user by making
+						# them think they want to use isplit according to the keyframe count
+						# if last_type == "keyframe"
+						# 	segment_string += " " + keyframe_counter.to_s
+						# 	keyframe_counter += 1
+						# end
+						puts segment_string
+
+						# The new last type will be this type during the next frame segment
+						last_type = type
+						# Update start of the frame segment to this frame
+						start_of_frame_segment = video_frame_counter
+					end
+				end
+				video_frame_counter += 1
+				last_video_frame = video_frame_counter
+			end
+			if start_of_frame_segment + 1 == last_video_frame
+				puts start_of_frame_segment.to_s + ": " + last_type
+			else
+				puts start_of_frame_segment.to_s + ".." + (last_video_frame - 1).to_s + ": " + last_type
+			end
+			puts "All done!"
+		end
+	end
+end

data/lib/moshy/isplit.rb

@@ -1,129 +1,129 @@
-module Moshy
-	class ISplit
-		def cli(args)
-			opts = Slop::Options.new
-			opts.banner = "Usage: moshy -m isplit -i file.avi -o file_out\nmoshy -m isplit --help for details"
-			opts.separator 'Required Parameters:'
-			opts.string '-i', '--input', 'Input file path - must be an .avi.'
-			opts.string '-o', '--output', 'Output file path - will be appended with -#.avi for each clip.'
-			opts.separator 'Optional Parameters:'
-			opts.integer '-b', '--begin', 'Index of the I-frame at which to begin clipping (inclusive)'
-			opts.integer '-e', '--end', 'Index of the I-frame at which to stop clipping (inclusive)'
-			opts.integer '-v', '--verbose', 'Noisy output (default: false)'
-			opts.on '-h', '--help' do
-				puts opts
-				puts "\n"
-				puts \
-"Extracts individual clips from an AVI where each clip is separated
-by I-frames in the original AVI. Great for getting specific clips out
-of a larger video and later doing I-frame moshing.
-
-Note that since this creates multiple clips, you should NOT specify
-the .avi extension in your output (-o) parameter, as moshy will
-automatically append \"-#.avi\" to the output parameter you pass
-when it spits out individual clips.
-
-If you want to only cut clips from a certain section of a larger
-video file, you can set the in- and out-points of where to get clips
-from by using the -b (--begin) and -e (--end) options, where the
-values used in those parameters are the indexes of the I-Frames.
-For example, if a video file has 12 I-Frames and you want the clips
-between I-Frames 3 and 7, you would use the following command:
-
-moshy -m isplit -i file.avi -o file_out -b 3 -e 7"
-				exit
-			end
-
-			parser = Slop::Parser.new(opts)
-			@options = parser.parse(ARGV)
-			# puts @options.to_hash
-
-			# Check mandatory params
-			mandatory = [:input, :output]
-			missing = mandatory.select{ |param| @options[param].nil? }
-			unless missing.empty?
-				puts "Missing options: #{missing.join(', ')}"
-				puts @options
-				exit
-			end
-
-
-			puts "Opening file " + @options[:input] + "..."
-			a = AviGlitch.open @options[:input]       # Rewrite this line for your file.
-			puts "Opened!"
-
-			split(a, @options[:output], @options[:begin], @options[:end], @options[:verbose])
-		end
-
-		def clip(frames, out_path, start_index, frame_count)
-			puts "Clipping " + frame_count.to_s + " frames starting at frame " + start_index.to_s
-			clip = frames.slice(start_index, frame_count)
-			o = AviGlitch.open clip
-			puts "Outputting " + out_path
-			o.output out_path
-		end
-
-		def split(clip, output, begin_point, end_point, verbose)
-			clip_cuts = {}
-
-			clip_count = 0
-			current_iframe = 0
-			iframe_index = 0
-			last_iframe_index = 0
-			frames_in_clip = 0
-
-			# Harvest clip details
-			total_frame_count = clip.frames.count
-			clip.frames.each_with_index do |f, i|
-				if f.is_keyframe?
-					iframe_index = i
-					# Don't process frames that are before our beginning
-					if current_iframe and begin_point and current_iframe < begin_point
-						# puts "skipping " + current_iframe.to_s
-						frames_in_clip = 0
-						current_iframe = current_iframe + 1
-						last_iframe_index = iframe_index
-						# puts "last_iframe_index: " + last_iframe_index.to_s
-						next
-					end
-					break if end_point and current_iframe > end_point
-
-					if current_iframe != 0
-						if verbose
-							puts "Storing clip details: iframe_number=" + current_iframe.to_s + "; index=" + last_iframe_index.to_s + "; frame_count=" + frames_in_clip.to_s
-						end
-						clip_cuts[current_iframe] = {
-							:index => last_iframe_index,
-							:frame_count => frames_in_clip
-						}
-					end
-					frames_in_clip = 0
-					current_iframe = current_iframe + 1
-					last_iframe_index = iframe_index
-				else
-					frames_in_clip = frames_in_clip + 1
-					# clip last piece manually if we're at the end, because there's
-					# no last iframe to detect and trigger the final clip
-					if i == total_frame_count - 1
-						if verbose
-							puts "Storing clip details: iframe_number=" + current_iframe.to_s + "; index=" + last_iframe_index.to_s + "; frame_count=" + frames_in_clip.to_s
-						end
-						clip_cuts[current_iframe] = {
-							:index => last_iframe_index,
-							:frame_count => frames_in_clip
-						}
-					end
-				end
-			end
-
-			puts clip_cuts
-
-			clip_cuts.keys.each do |f|
-				out_path = output + '-' + f.to_s + '.avi'
-				clip(clip.frames, out_path, clip_cuts[f][:index], clip_cuts[f][:frame_count])
-			end
-
-			puts "All done!"
-		end
-	end
-end
+module Moshy
+	class ISplit
+		def cli(args)
+			opts = Slop::Options.new
+			opts.banner = "Usage: moshy -m isplit -i file.avi -o file_out\nmoshy -m isplit --help for details"
+			opts.separator 'Required Parameters:'
+			opts.string '-i', '--input', 'Input file path - must be an .avi.'
+			opts.string '-o', '--output', 'Output file path - will be appended with -#.avi for each clip.'
+			opts.separator 'Optional Parameters:'
+			opts.integer '-b', '--begin', 'Index of the I-frame at which to begin clipping (inclusive)'
+			opts.integer '-e', '--end', 'Index of the I-frame at which to stop clipping (inclusive)'
+			opts.integer '-v', '--verbose', 'Noisy output (default: false)'
+			opts.on '-h', '--help' do
+				puts opts
+				puts "\n"
+				puts \
+"Extracts individual clips from an AVI where each clip is separated
+by I-frames in the original AVI. Great for getting specific clips out
+of a larger video and later doing I-frame moshing.
+
+Note that since this creates multiple clips, you should NOT specify
+the .avi extension in your output (-o) parameter, as moshy will
+automatically append \"-#.avi\" to the output parameter you pass
+when it spits out individual clips.
+
+If you want to only cut clips from a certain section of a larger
+video file, you can set the in- and out-points of where to get clips
+from by using the -b (--begin) and -e (--end) options, where the
+values used in those parameters are the indexes of the I-Frames.
+For example, if a video file has 12 I-Frames and you want the clips
+between I-Frames 3 and 7, you would use the following command:
+
+moshy -m isplit -i file.avi -o file_out -b 3 -e 7"
+				exit
+			end
+
+			parser = Slop::Parser.new(opts)
+			@options = parser.parse(ARGV)
+			# puts @options.to_hash
+
+			# Check mandatory params
+			mandatory = [:input, :output]
+			missing = mandatory.select{ |param| @options[param].nil? }
+			unless missing.empty?
+				puts "Missing options: #{missing.join(', ')}"
+				puts @options
+				exit
+			end
+
+
+			puts "Opening file " + @options[:input] + "..."
+			a = AviGlitch.open @options[:input]       # Rewrite this line for your file.
+			puts "Opened!"
+
+			split(a, @options[:output], @options[:begin], @options[:end], @options[:verbose])
+		end
+
+		def clip(frames, out_path, start_index, frame_count)
+			puts "Clipping " + frame_count.to_s + " frames starting at frame " + start_index.to_s
+			clip = frames.slice(start_index, frame_count)
+			o = AviGlitch.open clip
+			puts "Outputting " + out_path
+			o.output out_path
+		end
+
+		def split(clip, output, begin_point, end_point, verbose)
+			clip_cuts = {}
+
+			clip_count = 0
+			current_iframe = 0
+			iframe_index = 0
+			last_iframe_index = 0
+			frames_in_clip = 0
+
+			# Harvest clip details
+			total_frame_count = clip.frames.count
+			clip.frames.each_with_index do |f, i|
+				if f.is_keyframe?
+					iframe_index = i
+					# Don't process frames that are before our beginning
+					if current_iframe and begin_point and current_iframe < begin_point
+						# puts "skipping " + current_iframe.to_s
+						frames_in_clip = 0
+						current_iframe = current_iframe + 1
+						last_iframe_index = iframe_index
+						# puts "last_iframe_index: " + last_iframe_index.to_s
+						next
+					end
+					break if end_point and current_iframe > end_point
+
+					if current_iframe != 0
+						if verbose
+							puts "Storing clip details: iframe_number=" + current_iframe.to_s + "; index=" + last_iframe_index.to_s + "; frame_count=" + frames_in_clip.to_s
+						end
+						clip_cuts[current_iframe] = {
+							:index => last_iframe_index,
+							:frame_count => frames_in_clip
+						}
+					end
+					frames_in_clip = 0
+					current_iframe = current_iframe + 1
+					last_iframe_index = iframe_index
+				else
+					frames_in_clip = frames_in_clip + 1
+					# clip last piece manually if we're at the end, because there's
+					# no last iframe to detect and trigger the final clip
+					if i == total_frame_count - 1
+						if verbose
+							puts "Storing clip details: iframe_number=" + current_iframe.to_s + "; index=" + last_iframe_index.to_s + "; frame_count=" + frames_in_clip.to_s
+						end
+						clip_cuts[current_iframe] = {
+							:index => last_iframe_index,
+							:frame_count => frames_in_clip
+						}
+					end
+				end
+			end
+
+			puts clip_cuts
+
+			clip_cuts.keys.each do |f|
+				out_path = output + '-' + f.to_s + '.avi'
+				clip(clip.frames, out_path, clip_cuts[f][:index], clip_cuts[f][:frame_count])
+			end
+
+			puts "All done!"
+		end
+	end
+end