moshy 0.1.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 10b05cab4000093c123ded361c51188a2a35294a
-  data.tar.gz: 05b77cee5a180f285e48c97627626ba6190e1229
+  metadata.gz: b0c17c458da7a8ea731db28eaf6a919469107b9d
+  data.tar.gz: fa5b4eea8ca1538790eaf989e77e40b058fcf01c
 SHA512:
-  metadata.gz: ae34d58ed8350a14a71422a49283d99917a8f08e7b1698c867f73f859f94644720169d1f115bc2b8cd4e459587381fed7cc59b7fa7c80ec30a43397b578909d1
-  data.tar.gz: ff48178601ce668c27770ba535c431528c036a0ed9e20c9dcd865acdb49ada0915847c96ed8791819dda485c3dfaf16ea7d45e400cd61ce006a0cecca06f8c98
+  metadata.gz: a2692be61ccc6e9088d6d3ab9ad75af55b2c7ce0d9fa8d67dc20562b6ec2f7731f36424ce430a7cb6ccf17bea958cb19fcf116e2267981853e81043b812f81fa
+  data.tar.gz: aa247fc3c2115fb4a5ebaaf6b69ee25c33735311ef7a0a10a8ab26993a4d62322b5b546f3c2ee3440fc639be7e7c935c59a148aab2c5f7c87dd485cab69f9ab2

data/.gitignore

@@ -0,0 +1,22 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in moshy.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Way Spurr-Chen <wayspurrchen@gmail.com> <http://wayspurrchen.com/>
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,71 @@
+# moshy
+
+moshy is a command line datamoshing utility kit for AVI files, based heavily on [aviglitch](https://github.com/ucnv/aviglitch).
+It's designed to make common datamoshing tasks easier without having to open avidemux or other GUI tools. It lets you do stuff like:
+
+- Convert video files into AVI video files with minimal I-Frames and no B-frames for ultimate moshability
+- Create P-Frame duplication effects quickly
+- Split a long video file into multiple clips based on its I-Frames
+- "Bake" your datamoshed video, encoding the corruption as actual video content for uploading to video services or moshing even further!
+- Identifying keyframe and deltaframe indexes in any AVI file
+- ...and more!
+
+If you don't know how to use the command line, this is a great opportunity to learn:
+
+- Mac OS X Tutorial: http://blog.teamtreehouse.com/introduction-to-the-mac-os-x-command-line
+- Windows Tutorial: http://lifehacker.com/5633909/who-needs-a-mouse-learn-to-use-the-command-line-for-almost-anything
+
+## Get it!
+
+You'll need to install [Ruby](https://www.ruby-lang.org/en/). If you're on Mac OS X, you probably already have a local version of Ruby installed. Once that's done, you will need Bundler, a Ruby dependency manager, which you can install with the following command:
+
+```
+gem install bundler
+```
+
+Then you can use Bundler to install moshy:
+
+```
+bundle install moshy
+```
+
+From there, you can use `moshy` from the command line.
+
+## What's it do?
+
+Moshy currently has six different modes:
+
+- `prep` - 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.
+- `isplit` - 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.
+- `inspect` - 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
+  cannot 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.
+- `pdupe` - 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.
+- `ppulse` - 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.
+- `bake` - "Bakes" your datamosh by creating a new video file from your
+  datamoshed .avi, causing the datamosh effects to be treated as the actual
+  content of the new video instead of an error. Requires ffmpeg to be
+  installed locally.
+
+You can access detailed info on how to use each of them from the command line with
+the command `moshy -m <mode> --help`.
+
+## Cool!
+
+If you think this is cool, you'll probably find my list of [glitch art resources](http://www.glitchet.com/resources)
+useful as well as the [Glitchet newsletter](http://www.glitchet.com/), a free weekly futuristic
+news and glitch aesthetic e-zine.

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/bin/moshy

@@ -0,0 +1,105 @@
+#!/usr/bin/env ruby
+
+require 'optparse'
+require 'slop'
+require 'moshy'
+
+module Moshy
+  def self.top_level_help
+    $options = {
+
+    }
+    opts = OptionParser.new do |opts|
+      opts.banner = "
+moshy, a Ruby utility for making it easier to datamosh AVI files. It has
+multiple modes that can be run with the -m or --mode option.
+
+  MODES DETAILS
+  -------------
+
+  \"prep\"
+  ------
+  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.
+
+  \"isplit\"
+  --------
+  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.
+
+  \"pdupe\"
+  -------
+  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.
+
+  \"ppulse\"
+  --------
+  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.
+
+  \"bake\"
+  ------
+  \"Bakes\" your datamosh by creating a new video file from your
+  datamoshed .avi, causing the datamosh effects to be treated as the actual
+  content of the new video instead of an error. Requires ffmpeg to be
+  installed locally.
+
+  \"inspect\"
+  ---------
+  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
+  cannot 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.
+
+Run moshy with mode -m <mode> --help to see options for individual modes.
+  "
+    end
+
+    begin
+      opts.parse
+    rescue OptionParser::InvalidOption, OptionParser::InvalidArgument
+    end
+
+    puts opts
+  end
+end
+
+# Because we have multiple modes, we do some initial basic arg checking
+# to see if they specified a mode. If not, we show the top-level help menu.
+result = Slop.parse suppress_errors: true do |o|
+  o.string '-m', '--mode'
+end
+
+mode_classes = {
+  "inspect" => Moshy::Inspect,
+  "isplit" => Moshy::ISplit,
+  "pdupe" => Moshy::PDupe,
+  "ppulse" => Moshy::PPulse,
+  "prep" => Moshy::Prep,
+  "bake" => Moshy::Bake
+}
+
+if mode_classes.has_key? result[:m]
+  # We need to strip out the "m" otherwise our other arg parsers
+  # will choke on the extra parameter
+  ARGV.each_with_index do |o, i|
+    if o == "-m" || o == "--m"
+      ARGV.delete_at(i + 1)
+      ARGV.delete_at(i)
+      break
+    end
+  end
+
+  mode_classes[result[:m]].new.cli ARGV
+else
+  Moshy.top_level_help
+end

data/lib/moshy.rb

@@ -0,0 +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

data/lib/moshy/bake.rb

@@ -0,0 +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

data/lib/moshy/inspect.rb

@@ -0,0 +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

data/lib/moshy/isplit.rb

@@ -0,0 +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

data/lib/moshy/pdupe.rb

@@ -0,0 +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

data/lib/moshy/ppulse.rb

@@ -0,0 +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

data/lib/moshy/prep.rb

@@ -0,0 +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

data/lib/moshy/version.rb

@@ -0,0 +1,3 @@
+module Moshy
+  VERSION = "1.0.0"
+end

data/moshy.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'moshy/version'
+
+Gem::Specification.new do |spec|
+  spec.name        = "moshy"
+  spec.version     = Moshy::VERSION
+  spec.summary     = "datamoshing utility kit for common tasks with AVI files"
+  spec.description = spec.summary
+  spec.authors     = ["wayspurrchen"]
+  spec.email       = 'wayspurrchen@gmail.com'
+  spec.homepage    = 'https://github.com/wayspurrchen/moshy'
+  spec.license     = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_runtime_dependency "slop"
+  spec.add_runtime_dependency "aviglitch"
+  spec.add_runtime_dependency "av"
+
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rake"
+end

metadata

@@ -1,34 +1,107 @@
 --- !ruby/object:Gem::Specification
 name: moshy
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 1.0.0
 platform: ruby
 authors:
-- Way Spurr-Chen
+- wayspurrchen
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2010-09-12 00:00:00.000000000 Z
-dependencies: []
-description: |-
-  moshy is a datamoshing utility kit for AVI files, based heavily on [aviglitch](https://github.com/ucnv/aviglitch).
-  It's designed to make common datamoshing tasks easier from a command line interface
-  without having to open avidemux or other GUI tools. It lets you do stuff like:
-
-  - Convert video files into AVI video files with minimal I-Frames and no B-frames for ultimate moshability
-  - Create P-Frame duplication effects quickly
-  - Split a long video file into multiple clips based on its I-Frames
-  - "Bake" your datamoshed video, encoding the corruption as actual video content for uploading to video services or moshing even further!
-  - Identifying keyframe and deltaframe indexes in any AVI file
-  - ...and more!
-
-  See https://github.com/wayspurrchen/moshy for detailed documentation.
+date: 2015-09-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: slop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: aviglitch
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: av
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: datamoshing utility kit for common tasks with AVI files
 email: wayspurrchen@gmail.com
-executables: []
+executables:
+- moshy
 extensions: []
 extra_rdoc_files: []
 files:
-- moshy.rb
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/moshy
+- lib/moshy.rb
+- lib/moshy/bake.rb
+- lib/moshy/inspect.rb
+- lib/moshy/isplit.rb
+- lib/moshy/pdupe.rb
+- lib/moshy/ppulse.rb
+- lib/moshy/prep.rb
+- lib/moshy/version.rb
+- moshy.gemspec
 homepage: https://github.com/wayspurrchen/moshy
 licenses:
 - MIT
@@ -39,12 +112,12 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []

data/moshy.rb

@@ -1,110 +0,0 @@
-require_relative 'lib/inspect'
-require_relative 'lib/isplit'
-require_relative 'lib/pdupe'
-require_relative 'lib/bake'
-require_relative 'lib/prep'
-require_relative 'lib/ppulse'
-require 'aviglitch'
-require 'optparse'
-require 'slop'
-require 'av'
-
-module Moshy
-	def self.top_level_help
-		$options = {
-
-		}
-		opts = OptionParser.new do |opts|
-			opts.banner = "
-moshy, a Ruby utility for making it easier to datamosh AVI files. It has
-multiple modes that can be run with the -m or --mode option.
-
-	MODES DETAILS
-	-------------
-
-	\"prep\"
-	------
-	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.
-
-	\"isplit\"
-	--------
-	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.
-
-	\"pdupe\"
-	-------
-	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.
-
-	\"ppulse\"
-	--------
-	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.
-
-	\"bake\"
-	------
-	\"Bakes\" your datamosh by creating a new video file from your
-	datamoshed .avi, causing the datamosh effects to be treated as the actual
-	content of the new video instead of an error. Requires ffmpeg to be
-	installed locally.
-
-	\"inspect\"
-	---------
-	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
-	cannot 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.
-
-Run moshy with mode -m <mode> --help to see options for individual modes.
-	"
-		end
-
-		begin
-			opts.parse
-		rescue OptionParser::InvalidOption, OptionParser::InvalidArgument
-		end
-
-		puts opts
-	end
-end
-
-# Because we have multiple modes, we do some initial basic arg checking
-# to see if they specified a mode. If not, we show the top-level help menu.
-result = Slop.parse suppress_errors: true do |o|
-  o.string '-m', '--mode'
-end
-
-mode_classes = {
-	"inspect" => Moshy::Inspect,
-	"isplit" => Moshy::ISplit,
-	"pdupe" => Moshy::PDupe,
-	"ppulse" => Moshy::PPulse,
-	"prep" => Moshy::Prep,
-	"bake" => Moshy::Bake
-}
-
-if mode_classes.has_key? result[:m]
-	# We need to strip out the "m" otherwise our other arg parsers
-	# will choke on the extra parameter
-	ARGV.each_with_index do |o, i|
-		if o == "-m" || o == "--m"
-			ARGV.delete_at(i + 1)
-			ARGV.delete_at(i)
-			break
-		end
-	end
-
-	mode_classes[result[:m]].new ARGV
-else
-	Moshy.top_level_help
-end