moshy 1.0.1 → 2.0.1

data/lib/moshy/pdupe.rb

@@ -1,85 +1,85 @@
-module Moshy
-	class PDupe
-		def cli(args)
-			opts = Slop::Options.new
-			opts.banner = "Usage: moshy -m pdupe -i file.avi -o file_out.avi -f <integer>\nmoshy -m pdupe --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, should be an .avi.'
-			opts.integer '-f', '--frame', 'Index of the frame that should be duplicated'
-			opts.separator 'Optional Parameters:'
-			opts.integer '-d', '--dupes', 'Number of times to multiply the frame (default: 30)'
-			opts.on '-h', '--help' do
-				puts opts
-				puts "\n"
-				puts \
-"Duplicates a P-frame at a given frame a certain amount. To find
-out which frames are P-frames, use software like avidemux to look at the
-frame type. WARNING: This mode is a little glitchy. You may need to set
-the interval 1 or 2 above or below the frame number you actually want to
-duplicate. I'm not sure why this happens, but try it with a small
-duplication amount first. NOTE: This can mode take a while to process
-over 60-90 frame dupes.
-
-You can specify the number of duplicates that you want with the -d parameter."
-				exit
-			end
-
-			default = {
-				:dupes => 30
-			}
-
-			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
-			}
-
-			# Check mandatory params
-			mandatory = [:input, :output, :frame]
-			missing = mandatory.select{ |param| @options[param].nil? }
-			unless missing.empty?
-				puts "Missing options: #{missing.join(', ')}"
-				puts slop_options
-				exit
-			end
-
-			puts "Opening file " + @options[:input] + "..."
-			a = AviGlitch.open @options[:input]       # Rewrite this line for your file.
-			puts "Opened!"
-
-			pdupe(a, @options[:output], @options[:frame], @options[:dupes])
-		end
-
-		def pdupe(clip, output, frame, duplicate_amount)
-
-			puts "Size: " + clip.frames.size_of('videoframe').to_s
-
-			frames = nil
-			video_frame_counter = 0
-
-			clip.frames.each_with_index do |f, i|
-				if f.is_videoframe?
-					video_frame_counter += 1
-					if video_frame_counter == frame
-						puts "On frame " + frame.to_s + ", duping " + duplicate_amount.to_s + " times"
-						clipped = clip.frames[0..(i + 5)]
-						dupe_clip = clip.frames[(i + 4), 1] * duplicate_amount
-						frames = clipped + dupe_clip
-						puts "Added dupe, grabbing rest..."
-						frames = frames + clip.frames[i..-1]
-						puts "Done. Output frame count: " + frames.size.to_s
-						break
-					end
-				end
-			end
-
-			o = AviGlitch.open frames
-			o.output output
-		end
-	end
-end
+module Moshy
+	class PDupe
+		def cli(args)
+			opts = Slop::Options.new
+			opts.banner = "Usage: moshy -m pdupe -i file.avi -o file_out.avi -f <integer>\nmoshy -m pdupe --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, should be an .avi.'
+			opts.integer '-f', '--frame', 'Index of the frame that should be duplicated'
+			opts.separator 'Optional Parameters:'
+			opts.integer '-d', '--dupes', 'Number of times to multiply the frame (default: 30)'
+			opts.on '-h', '--help' do
+				puts opts
+				puts "\n"
+				puts \
+"Duplicates a P-frame at a given frame a certain amount. To find
+out which frames are P-frames, use software like avidemux to look at the
+frame type. WARNING: This mode is a little glitchy. You may need to set
+the interval 1 or 2 above or below the frame number you actually want to
+duplicate. I'm not sure why this happens, but try it with a small
+duplication amount first. NOTE: This can mode take a while to process
+over 60-90 frame dupes.
+
+You can specify the number of duplicates that you want with the -d parameter."
+				exit
+			end
+
+			default = {
+				:dupes => 30
+			}
+
+			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
+			}
+
+			# Check mandatory params
+			mandatory = [:input, :output, :frame]
+			missing = mandatory.select{ |param| @options[param].nil? }
+			unless missing.empty?
+				puts "Missing options: #{missing.join(', ')}"
+				puts slop_options
+				exit
+			end
+
+			puts "Opening file " + @options[:input] + "..."
+			a = AviGlitch.open @options[:input]       # Rewrite this line for your file.
+			puts "Opened!"
+
+			pdupe(a, @options[:output], @options[:frame], @options[:dupes])
+		end
+
+		def pdupe(clip, output, frame, duplicate_amount)
+
+			puts "Size: " + clip.frames.size_of('videoframe').to_s
+
+			frames = nil
+			video_frame_counter = 0
+
+			clip.frames.each_with_index do |f, i|
+				if f.is_videoframe?
+					video_frame_counter += 1
+					if video_frame_counter == frame
+						puts "On frame " + frame.to_s + ", duping " + duplicate_amount.to_s + " times"
+						clipped = clip.frames[0..(i + 5)]
+						dupe_clip = clip.frames[(i + 4), 1] * duplicate_amount
+						frames = clipped + dupe_clip
+						puts "Added dupe, grabbing rest..."
+						frames = frames + clip.frames[i..-1]
+						puts "Done. Output frame count: " + frames.size.to_s
+						break
+					end
+				end
+			end
+
+			o = AviGlitch.open frames
+			o.output output
+		end
+	end
+end

data/lib/moshy/ppulse.rb

@@ -1,153 +1,153 @@
-module Moshy
-	class PPulse
-		def cli(args)
-			opts = Slop::Options.new
-			opts.banner = "Usage: moshy -m ppulse -i file.avi -o file_out.avi [options]\nmoshy -m inspect --help for details"
-			opts.separator 'Required Parameters:'
-			opts.string '-i', '--input', 'Input file path - must be an .avi. Clip to split in split mode, first clip in stitch mode'
-			opts.string '-o', '--output', 'Output file path - will be appended with -#.avi for each frame in split mode'
-			opts.separator 'Optional Parameters:'
-			opts.string '-k', '--keep', 'Whether or not to keep standard frames. (default: true)', default: "true"
-			opts.integer '-c', '--count', 'How many frames to grab forward from each interval. (default: 1)', default: 1
-			opts.integer '-d', '--dupes', 'Number of times to multiply the frame (default: 30)', default: 30
-			opts.integer '-n', '--interval', 'Which nth frames should be duplicated (default: 30)', default: 30
-			opts.on '-h', '--help' do
-				puts opts
-				puts "\n"
-				puts \
-"Takes c number of frames and every n frames and duplicates them a
-given amount, resulting in a consistent P-duplication datamosh that's
-good for creating rhythmic effects. This was originally created to
-create mosh effects in sync with a beat for a music video.
-
-You can specify what interval to get frames at with -n (--interval).
-You can specify how many frames to get from the current interval with
--c (--count). You can specify how many times to duplicate a given
-frame with -d (--dupes). You can then specify whether or not to keep
-the original video's frames between the end of the duplication and
-where the next interval occurs with -k (--keep). Keeping original
-frames causes the original motion to continue after the P-frame dupe
-effect, whereas dropping original frames causes the video to snap
-into the motion of the frames at each interval. This is a more complex
-effect so I recommend experimenting with it!"
-				exit
-			end
-
-			default = {
-				:dupes => 30,
-				:interval => 30,
-				:count => 1,
-				:keep => true
-			}
-
-			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[:keep] == "false"
-				@options[:keep] = false
-			else
-				@options[:keep] = 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
-
-			puts "Opening file " + @options[:input] + "..."
-			a = AviGlitch.open @options[:input]       # Rewrite this line for your file.
-			puts "Opened!"
-
-			ppulse(a, @options[:output], @options[:interval], @options[:count], @options[:dupes], @options[:keep])
-		end
-
-		# Loops through a video file and grabs every `interval` frames then duplicates them
-		# `duplicate_amount` times
-		# 
-		# `leave_originals` will copy standard frames and only p-frame the last one every `interval`
-		def ppulse(clip, output, interval = 30, count = 1, duplicate_amount = 30, leave_originals = true)
-
-			puts "Size: " + clip.frames.size_of('videoframe').to_s
-
-			frames = nil
-
-			video_frame_counter = 0
-
-			have_iframe = false
-
-			if leave_originals
-				first_index = 0
-				second_index = 0
-				clip.frames.each_with_index do |f, i|
-					if f.is_videoframe?
-						video_frame_counter += 1
-						if video_frame_counter % interval == 0
-							second_index = i
-							puts "first index: " + first_index.to_s
-							puts "second index: " + second_index.to_s
-
-							clipped = clip.frames[first_index..(i + 5)]
-							dupe_clip = clip.frames[i, count] * duplicate_amount
-							if frames.nil?
-								frames = clipped + dupe_clip
-							else
-								frames = frames + clipped + dupe_clip
-							end
-							puts "Current expected output frame count: " + frames.size.to_s
-
-							first_index = i + 5
-						end
-					end
-				end
-			else
-				# Harvest clip details
-				clip.frames.each_with_index do |f, i|
-					if f.is_videoframe?
-						if !have_iframe && f.is_keyframe?
-							puts "Added first iframe (necessary to avoid total corruption)"
-							# no idea why i need to get 5
-							frames = clip.frames[i, 1]
-							have_iframe = true
-						end
-
-						# +1 to offset the first iframe
-						if video_frame_counter % interval == 0 && f.is_deltaframe?
-							puts "Processing frame " + video_frame_counter.to_s + " at index " + i.to_s
-							# You might ask why we need to check if frames are nil when we already check
-							# whether or not we have an i frame and if the above is a keyframe - that's
-							# because datamoshers are crazy and might pass use clip with no leading iframe :)
-							if frames.nil?
-								puts "First frame, setting"
-								clipped = clip.frames[i, count]
-								frames = frames.concat( clipped * duplicate_amount )
-								puts "Frame size"
-								puts frames.size_of('videoframe')
-							else
-								puts "Current i: " + i.to_s
-								puts "Duping frame " + i.to_s + " " + duplicate_amount.to_s + " times"
-								frames = frames.concat( clip.frames[i, count] * duplicate_amount )
-								puts "Next frame, size: " + frames.size.to_s
-							end
-						end
-						video_frame_counter += 1
-					end
-				end
-			end
-
-			o = AviGlitch.open frames
-			o.output output
-			puts "Done! File processed to: " + output
-		end
-	end
-end
+module Moshy
+	class PPulse
+		def cli(args)
+			opts = Slop::Options.new
+			opts.banner = "Usage: moshy -m ppulse -i file.avi -o file_out.avi [options]\nmoshy -m inspect --help for details"
+			opts.separator 'Required Parameters:'
+			opts.string '-i', '--input', 'Input file path - must be an .avi. Clip to split in split mode, first clip in stitch mode'
+			opts.string '-o', '--output', 'Output file path - will be appended with -#.avi for each frame in split mode'
+			opts.separator 'Optional Parameters:'
+			opts.string '-k', '--keep', 'Whether or not to keep standard frames. (default: true)', default: "true"
+			opts.integer '-c', '--count', 'How many frames to grab forward from each interval. (default: 1)', default: 1
+			opts.integer '-d', '--dupes', 'Number of times to multiply the frame (default: 30)', default: 30
+			opts.integer '-n', '--interval', 'Which nth frames should be duplicated (default: 30)', default: 30
+			opts.on '-h', '--help' do
+				puts opts
+				puts "\n"
+				puts \
+"Takes c number of frames and every n frames and duplicates them a
+given amount, resulting in a consistent P-duplication datamosh that's
+good for creating rhythmic effects. This was originally created to
+create mosh effects in sync with a beat for a music video.
+
+You can specify what interval to get frames at with -n (--interval).
+You can specify how many frames to get from the current interval with
+-c (--count). You can specify how many times to duplicate a given
+frame with -d (--dupes). You can then specify whether or not to keep
+the original video's frames between the end of the duplication and
+where the next interval occurs with -k (--keep). Keeping original
+frames causes the original motion to continue after the P-frame dupe
+effect, whereas dropping original frames causes the video to snap
+into the motion of the frames at each interval. This is a more complex
+effect so I recommend experimenting with it!"
+				exit
+			end
+
+			default = {
+				:dupes => 30,
+				:interval => 30,
+				:count => 1,
+				:keep => true
+			}
+
+			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[:keep] == "false"
+				@options[:keep] = false
+			else
+				@options[:keep] = 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
+
+			puts "Opening file " + @options[:input] + "..."
+			a = AviGlitch.open @options[:input]       # Rewrite this line for your file.
+			puts "Opened!"
+
+			ppulse(a, @options[:output], @options[:interval], @options[:count], @options[:dupes], @options[:keep])
+		end
+
+		# Loops through a video file and grabs every `interval` frames then duplicates them
+		# `duplicate_amount` times
+		# 
+		# `leave_originals` will copy standard frames and only p-frame the last one every `interval`
+		def ppulse(clip, output, interval = 30, count = 1, duplicate_amount = 30, leave_originals = true)
+
+			puts "Size: " + clip.frames.size_of('videoframe').to_s
+
+			frames = nil
+
+			video_frame_counter = 0
+
+			have_iframe = false
+
+			if leave_originals
+				first_index = 0
+				second_index = 0
+				clip.frames.each_with_index do |f, i|
+					if f.is_videoframe?
+						video_frame_counter += 1
+						if video_frame_counter % interval == 0
+							second_index = i
+							puts "first index: " + first_index.to_s
+							puts "second index: " + second_index.to_s
+
+							clipped = clip.frames[first_index..(i + 5)]
+							dupe_clip = clip.frames[i, count] * duplicate_amount
+							if frames.nil?
+								frames = clipped + dupe_clip
+							else
+								frames = frames + clipped + dupe_clip
+							end
+							puts "Current expected output frame count: " + frames.size.to_s
+
+							first_index = i + 5
+						end
+					end
+				end
+			else
+				# Harvest clip details
+				clip.frames.each_with_index do |f, i|
+					if f.is_videoframe?
+						if !have_iframe && f.is_keyframe?
+							puts "Added first iframe (necessary to avoid total corruption)"
+							# no idea why i need to get 5
+							frames = clip.frames[i, 1]
+							have_iframe = true
+						end
+
+						# +1 to offset the first iframe
+						if video_frame_counter % interval == 0 && f.is_deltaframe?
+							puts "Processing frame " + video_frame_counter.to_s + " at index " + i.to_s
+							# You might ask why we need to check if frames are nil when we already check
+							# whether or not we have an i frame and if the above is a keyframe - that's
+							# because datamoshers are crazy and might pass use clip with no leading iframe :)
+							if frames.nil?
+								puts "First frame, setting"
+								clipped = clip.frames[i, count]
+								frames = frames.concat( clipped * duplicate_amount )
+								puts "Frame size"
+								puts frames.size_of('videoframe')
+							else
+								puts "Current i: " + i.to_s
+								puts "Duping frame " + i.to_s + " " + duplicate_amount.to_s + " times"
+								frames = frames.concat( clip.frames[i, count] * duplicate_amount )
+								puts "Next frame, size: " + frames.size.to_s
+							end
+						end
+						video_frame_counter += 1
+					end
+				end
+			end
+
+			o = AviGlitch.open frames
+			o.output output
+			puts "Done! File processed to: " + output
+		end
+	end
+end

data/lib/moshy/prep.rb

@@ -1,78 +1,78 @@
-module Moshy
-	class Prep
-		def cli(args)
-			opts = Slop::Options.new
-			opts.banner = "Usage: moshy.rb -m prep -i <file> -o <output> [options]\n"
-			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.on '-h', '--help' do
-				puts opts
-				puts "\n"
-				puts \
-"Preps a video file for datamoshing with moshy by converting it into an
-AVI with no B-Frames (they're not good for moshing), and placing as
-few I-Frames as possible. Requires ffmpeg be installed locally. Check
-the repository's README.md for more information on how to install ffmpeg.
-
-This command is meant to be a simple one-liner that makes your datamoshing
-workflow faster. Under the covers, it runs the following ffmpeg command:
-
-ffmpeg -i <moshy input> -bf 0 -g 600 -b:v <moshy bitrate> -o <moshy output>
-
-This takes in an input file (it should theoretically work with any video
-file type that ffmpeg supports), makes sure that no B-Frames are rendered,
-and sets the ideal I-frame interval to 600 (ffmpeg's max). This seems to
-mean that an I-frame will only show up every 30 to 25 seconds
-(600f / 30fps = 20s or 600f / 24fps = 25s), but I-Frames must be deposited
-wherever there is a hard cut or transition in a video where a P-frame would
-not be able to properly predict the motion of pixels."
-				exit
-			end
-
-			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
-			}
-
-			# 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[:bitrate]
-		end
-
-		def prep(input, output, bitrate)
-			ffmpeg = Av::Commands::Ffmpeg.new
-			ffmpeg.add_source input
-			ffmpeg.add_destination output
-
-			# Ensures all frames come out as P-frames, B-frames don't
-			# dupe or mosh properly
-			ffmpeg.add_output_param ['bf', 0]
-			# Keyframe interval, sets as few I-frames as possible.
-			# ffmpeg will complain about anything over 600 and cap it.
-			ffmpeg.add_output_param ['g', 600]
-			# Bitrate
-			ffmpeg.add_output_param ['b:v', bitrate.to_s + 'k']
-
-			ffmpeg.run
-		end
-	end
-end
+module Moshy
+	class Prep
+		def cli(args)
+			opts = Slop::Options.new
+			opts.banner = "Usage: moshy.rb -m prep -i <file> -o <output> [options]\n"
+			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.on '-h', '--help' do
+				puts opts
+				puts "\n"
+				puts \
+"Preps a video file for datamoshing with moshy by converting it into an
+AVI with no B-Frames (they're not good for moshing), and placing as
+few I-Frames as possible. Requires ffmpeg be installed locally. Check
+the repository's README.md for more information on how to install ffmpeg.
+
+This command is meant to be a simple one-liner that makes your datamoshing
+workflow faster. Under the covers, it runs the following ffmpeg command:
+
+ffmpeg -i <moshy input> -bf 0 -g 600 -b:v <moshy bitrate> -o <moshy output>
+
+This takes in an input file (it should theoretically work with any video
+file type that ffmpeg supports), makes sure that no B-Frames are rendered,
+and sets the ideal I-frame interval to 600 (ffmpeg's max). This seems to
+mean that an I-frame will only show up every 30 to 25 seconds
+(600f / 30fps = 20s or 600f / 24fps = 25s), but I-Frames must be deposited
+wherever there is a hard cut or transition in a video where a P-frame would
+not be able to properly predict the motion of pixels."
+				exit
+			end
+
+			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
+			}
+
+			# 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[:bitrate]
+		end
+
+		def prep(input, output, bitrate)
+			ffmpeg = Av::Commands::Ffmpeg.new
+			ffmpeg.add_source input
+			ffmpeg.add_destination output
+
+			# Ensures all frames come out as P-frames, B-frames don't
+			# dupe or mosh properly
+			ffmpeg.add_output_param ['bf', 0]
+			# Keyframe interval, sets as few I-frames as possible.
+			# ffmpeg will complain about anything over 600 and cap it.
+			ffmpeg.add_output_param ['g', 600]
+			# Bitrate
+			ffmpeg.add_output_param ['b:v', bitrate.to_s + 'k']
+
+			ffmpeg.run
+		end
+	end
+end

data/lib/moshy/version.rb

@@ -1,3 +1,3 @@
-module Moshy
-  VERSION = "1.0.1"
-end
+module Moshy
+  VERSION = "2.0.1"
+end

data/lib/moshy.rb

@@ -1,13 +1,13 @@
-require "aviglitch"
-require "av"
-require_relative "moshy/version"
-require_relative "moshy/inspect"
-require_relative "moshy/isplit"
-require_relative "moshy/pdupe"
-require_relative "moshy/bake"
-require_relative "moshy/prep"
-require_relative "moshy/ppulse"
-
-module Moshy
-	# Empty skeleton - just used to include the others
-end
+require "aviglitch"
+require "av"
+require_relative "moshy/version"
+require_relative "moshy/inspect"
+require_relative "moshy/isplit"
+require_relative "moshy/pdupe"
+require_relative "moshy/bake"
+require_relative "moshy/prep"
+require_relative "moshy/ppulse"
+
+module Moshy
+	# Empty skeleton - just used to include the others
+end