multimedia_paradise 1.1.314

data/lib/multimedia_paradise/toplevel_methods/is_a_multimedia_file.rb

@@ -0,0 +1,27 @@
+#!/usr/bin/ruby -w
+# Encoding: UTF-8
+# frozen_string_literal: true
+# =========================================================================== #
+# require 'multimedia_paradise/toplevel_methods/is_a_multimedia_file.rb'
+# =========================================================================== #
+require 'multimedia_paradise/constants/misc.rb'
+
+module MultimediaParadise
+
+  # ========================================================================= #
+  # === MultimediaParadise.is_a_multimedia_file?
+  #
+  # Determine whether a given file is a multimedia file or whether
+  # it is not.
+  #
+  # Usage example:
+  #
+  #   MultimediaParadise.is_a_multimedia_file? 'foobar.avi'
+  #
+  # ========================================================================= #
+  def self.is_a_multimedia_file?(i)
+    i = File.extname(i).delete('.') if i
+    ARRAY_MULTIMEDIA_FILETYPES.include? i
+  end
+
+end

data/lib/multimedia_paradise/toplevel_methods/is_audio_file.rb

@@ -0,0 +1,27 @@
+#!/usr/bin/ruby -w
+# Encoding: UTF-8
+# frozen_string_literal: true
+# =========================================================================== #
+# require 'multimedia_paradise/toplevel_methods/is_audio_file.rb'
+# =========================================================================== #
+module MultimediaParadise
+
+  require 'multimedia_paradise/constants/misc.rb'
+
+  # ========================================================================= #
+  # === MultimediaParadise.is_audio_file?
+  #
+  # This method will return true or false depending on whether the
+  # input is assumed to be an audio file or whether it is not.
+  # ========================================================================= #
+  def self.is_audio_file?(i)
+    _ = false
+    extname = File.extname(i).delete('.') # Will be something such as "mp3".
+    case extname
+    when *AUDIO_FORMATS
+      _ = true
+    end
+    return _
+  end; self.instance_eval { alias is_an_audio_file? is_audio_file? } # === MultimediaParadise.is_an_audio_file?
+
+end

data/lib/multimedia_paradise/toplevel_methods/is_image_file.rb

@@ -0,0 +1,31 @@
+#!/usr/bin/ruby -w
+# Encoding: UTF-8
+# frozen_string_literal: true
+# =========================================================================== #
+# require 'multimedia_paradise/toplevel_methods/is_image_file.rb'
+# =========================================================================== #
+require 'multimedia_paradise/constants/misc.rb'
+
+module MultimediaParadise
+
+  # ========================================================================= #
+  # === MultimediaParadise.is_image_file?
+  #
+  # This method will return true or false depending on whether the
+  # input is assumed to be an image file or whether it is not.
+  # ========================================================================= #
+  def self.is_image_file?(i)
+    _ = false
+    extname = File.extname(i).delete('.') # Will be something such as "mp3".
+    case extname
+    when *IMAGE_FORMATS
+      _ = true
+    end
+    return _
+  end; self.instance_eval { alias is_an_image_file? is_image_file? } # === MultimediaParadise.is_an_image_file?
+
+end
+
+if __FILE__ == $PROGRAM_NAME
+  puts MultimediaParadise.is_image_file?('foobar.png')
+end

data/lib/multimedia_paradise/toplevel_methods/is_on_roebe.rb

@@ -0,0 +1,17 @@
+#!/usr/bin/ruby -w
+# Encoding: UTF-8
+# frozen_string_literal: true
+# =========================================================================== #
+# require 'multimedia_paradise/toplevel_methods/is_on_roebe.rb'
+# MultimediaParadise.is_on_roebe?
+# =========================================================================== #
+module MultimediaParadise
+
+  # ========================================================================= #
+  # === MultimediaParadise.is_on_roebe?
+  # ========================================================================= #
+  def self.is_on_roebe?
+    ENV['IS_ROEBE'] == '1'
+  end
+
+end

data/lib/multimedia_paradise/toplevel_methods/is_video_file.rb

@@ -0,0 +1,62 @@
+#!/usr/bin/ruby -w
+# Encoding: UTF-8
+# frozen_string_literal: true
+# =========================================================================== #
+# require 'multimedia_paradise/toplevel_methods/is_video_file.rb'
+# =========================================================================== #
+require 'multimedia_paradise/constants/video_filetypes.rb'
+
+module MultimediaParadise
+
+  # ========================================================================= #
+  # === MultimediaParadise.is_video_file?
+  #
+  # This method will return true or false depending on whether the
+  # input is assumed to be a video file or whether it is not.
+  # ========================================================================= #
+  def self.is_video_file?(i)
+    _ = false
+    extname = File.extname(i).delete('.')
+    case extname
+    when *ARRAY_VIDEO_FILETYPES
+      _ = true
+    end
+    return _
+  end; self.instance_eval { alias is_video?             is_video_file? } # === MultimediaParadise.is_video?
+       self.instance_eval { alias is_a_video_file?      is_video_file? } # === MultimediaParadise.is_a_video_file?
+       self.instance_eval { alias is_this_a_video_file? is_video_file? } # === MultimediaParadise.is_this_a_video_file?
+
+  # ========================================================================= #
+  # === MultimediaParadise.filter_for_video_files_from
+  #
+  # This method accepts as input an Array. That array will then
+  # be filtered to include ONLY video files.
+  # ========================================================================= #
+  def self.filter_for_video_files_from(
+      this_directory
+    )
+    if this_directory.is_a?(String) and File.directory?(this_directory)
+      this_directory = Dir["#{this_directory}/*"]
+    end
+    this_directory.select {|entry|
+      is_video_file? entry
+    }
+  end
+
+  # ========================================================================= #
+  # === MultimediaParadise.filter_for_video_files
+  #
+  # This filter will only return video files.
+  # ========================================================================= #
+  def self.filter_for_video_files(array)
+    array.select {|entry| is_video_file?(entry) }
+  end
+
+  # ========================================================================= #
+  # === filter_for_video_files
+  # ========================================================================= #
+  def filter_for_video_files(i)
+    MultimediaParadise.filter_for_video_files(i)
+  end
+
+end

data/lib/multimedia_paradise/toplevel_methods/merge_multimedia_file.rb

@@ -0,0 +1,327 @@
+#!/usr/bin/ruby -w
+# Encoding: UTF-8
+# frozen_string_literal: true
+# =========================================================================== #
+# require 'multimedia_paradise/toplevel_methods/merge_multimedia_file.rb'
+# =========================================================================== #
+# MultimediaParadise.merge_mp3(:default, '*mp3')
+# MultimediaParadise.merge_avi_files
+# =========================================================================== #
+module MultimediaParadise
+
+  require 'multimedia_paradise/colours/colours.rb'
+  require 'multimedia_paradise/toplevel_methods/e.rb'
+  require 'multimedia_paradise/toplevel_methods/merge_these_videos.rb'
+
+  # ========================================================================= #
+  # === MultimediaParadise.merge_multimedia_file                  (merge tag)
+  #
+  # This method combines several multimedia-related actions, into one
+  # bundled method.
+  #
+  # Do note that the input files come last in the various merge methods,
+  # but they do come first for the input to this method here.
+  #
+  # The reason is that we can pass a variable amount to a method in
+  # ruby via the * syntax.
+  #
+  # Usage example:
+  #
+  #   MultimediaParadise.merge_multimedia_file(ARGV)
+  #
+  # ========================================================================= #
+  def self.merge_multimedia_file(
+      input_files = nil, # This should be an Array.
+      output_file = nil, # This should be a String.
+      extname     = nil
+    )
+
+    require 'multimedia_paradise/conversions/conversions.rb'
+
+    if input_files.is_a?(String) and input_files.include? '*'
+      input_files = Dir[input_files]
+    end
+    input_files.flatten!
+    # ======================================================================= #
+    # Determine the extname to use next.
+    # ======================================================================= #
+    if extname.nil? and input_files.is_a?(Array) and !input_files.empty? 
+      extname = File.extname(input_files.first)
+    end
+
+    extname = extname.to_s.delete('.')
+
+    case extname # This will be a String, as determined above.
+    # ======================================================================= #
+    # === mp4
+    # ======================================================================= #
+    when 'mp4'
+      eimportant(
+        output_file = merge_mp4(output_file, input_files)
+      )
+    # ======================================================================= #
+    # === mp3
+    # ======================================================================= #
+    when 'mp3' # Act on mp3 files here.
+      eimportant(
+        output_file = merge_mp3(output_file, input_files)
+      )
+    # ======================================================================= #
+    # === ogg
+    # ======================================================================= #
+    when 'ogg'
+      eimportant(
+        output_file = merge_ogg(output_file, input_files)
+      )
+    # ======================================================================= #
+    # === flv
+    # ======================================================================= #
+    when 'flv'
+      eimportant(
+        output_file = merge_flv(output_file, input_files)
+      )
+    # ======================================================================= #
+    # === m4v
+    # ======================================================================= #
+    when 'm4v'
+      eimportant(
+        output_file = merge_m4v(output_file, input_files)
+      )
+    else
+      output_file = ::MultimediaParadise.merge_these_videos(input_files)
+    end
+    return output_file
+  end # ========================================================================= #
+      # === MultimediaParadise.merge()
+      #
+      # Add an alias.
+      # ========================================================================= #
+      self.instance_eval { alias merge merge_multimedia_file }
+
+  # ========================================================================= #
+  # === MultimediaParadise.merge_mov
+  #
+  # Use this to merge some .mov files. Hmm. For some reason mencoder
+  # makes this an .avi file.
+  # ========================================================================= #
+  def self.merge_mov(
+      output_file = 'output.mov', *input_files
+    )
+    output_file << '.mov' unless output_file.end_with? '.mov'
+    _  = 'mencoder -idx -forceidx -oac mp3lame -ovc xvid -xvidencopts fixed_quant=4'.dup
+    _ << ' -o "'+output_file+'"'
+    _ << ' '+input_files.join(' ')
+    run_sys_command _
+  end
+
+  # ========================================================================= #
+  # === MultimediaParadise.merge_avi_files
+  #
+  # This method can be specifically used to merge several .avi files
+  # together. The input to this method should come in the form of
+  # .avi files.
+  # ========================================================================= #
+  def self.merge_avi_files(
+      *these_avi_files
+    )
+    these_avi_files = [these_avi_files].flatten.compact
+    if these_avi_files.empty?
+      these_avi_files = Dir['*.avi'] # Try to find .avi files in this case.
+    end
+    cmd = 'ffmpeg -i "concat:'+
+           these_avi_files.join('|')+
+           '" -c copy output.avi'
+    e
+    e cmd
+    e
+    system cmd
+  end
+
+  # ========================================================================= #
+  # === MultimediaParadise.merge_m4v
+  # ========================================================================= #
+  def self.merge_m4v(
+      output_file = nil,
+      input_files = []
+    )
+    output_file = 'output.m4v' # The input is .m4v, so the output should also be .mp4.
+    we_created_these_temporary_video_files = ''
+    input_files.each_with_index {|input_file, index|
+      temporary_video_file = 'temp'+index.to_s+'.ts'
+      # ======================================================================= #
+      # Next get rid of prior-existing temporary video files, in the
+      # event that these exist.
+      # ======================================================================= #
+      File.delete(temporary_video_file) if File.exist? temporary_video_file
+      we_created_these_temporary_video_files << temporary_video_file+'|'
+      _ = 'ffmpeg -i '+input_file+' -c copy -bsf:v h264_mp4toannexb '+temporary_video_file
+      esystem _, :colourize_output
+    }
+    if we_created_these_temporary_video_files.end_with? '|'
+      we_created_these_temporary_video_files.chop!
+    end
+    _ = 'ffmpeg -i "concat:'+we_created_these_temporary_video_files+
+        '" -c copy -bsf:a aac_adtstoasc '+output_file.to_s
+    esystem _, :colourize_output
+    if File.exist? output_file
+      e 'Stored into the file '+sfile(output_file)+'.'
+    end
+  end
+
+  # ========================================================================= #
+  # === MultimediaParadise.merge_ogg                        (merge ogg files)
+  #
+  # Use this method if you wish to merge some .ogg files together.
+  #
+  # We presently use ffmpeg for this.
+  # ========================================================================= #
+  def self.merge_ogg(
+      output_file = 'output.ogg', *input_files
+    )
+    input_files.flatten! # Flatten them.
+    input_files = input_files.join('\|') if input_files.is_a? Array
+    _  = 'ffmpeg -i concat:'+input_files # input_files are always an Array.
+    _ << ' -acodec copy'
+    _ << ' '+output_file
+    run_sys_command _
+  end
+
+  # ========================================================================= #
+  # === MultimediaParadise.merge_mp4
+  #
+  # Merge mp4 files. This is currently done using ffmpeg's concat protocol.
+  #
+  # Unfortunately, concatenating .mp4 files is not trivial and may require
+  # an intermediate step such as remuxing them to ts (mpegts) before then
+  # putting them together into a .mp4 file.
+  #
+  # The concat protocol follows this rule:
+  #
+  #   ffmpeg -i "concat:input1.mpg|input2.mpg|input3.mpg" -c copy output.mpg
+  #
+  # ========================================================================= #
+  def self.merge_mp4(
+      output_file = 'output.mp4',
+      *input_files
+    )
+    input_files.flatten!
+    # ======================================================================= #
+    # Pad all input files next, to avoid "foo'bar.mp3" problems.
+    # ======================================================================= #
+    input_files.map! {|entry|
+      entry = '"'+entry+'"' unless entry.start_with?('"')
+      entry
+    }
+
+    MultimediaParadise.ensure_that_the_output_directory_exists # Our log-base directory must exist.
+    output_file = 'output.mp4' if output_file.nil?
+    output_file = 'output_'+output_file unless output_file.include? '.'
+    output_file << '.mp4' unless output_file.end_with? 'mp4'
+    output_file = '"'+output_file+'"' unless output_file.start_with?('"')
+    File.delete(output_file) if File.exist? output_file # Don't want any backups.
+    # ======================================================================= #
+    # Ok now, the first step is to produce intermediate .ts files. Since
+    # they are intermediate, we don't have to store them persistently.
+    # We do this by iterating over our input_files Array first.
+    # ======================================================================= #
+    input_files.each_with_index {|the_input_mp4_file, index|
+      index += 1
+      _ = "ffmpeg -i #{the_input_mp4_file} -c copy -bsf:v h264_mp4toannexb -f mpegts"
+      name_of_the_ts_file = MultimediaParadise.store_in_this_directory+'intermediate'+index.to_s+'.ts'
+      # ======================================================================= #
+      # We must kill old .ts files, just in case that they exist. This is 
+      # acceptable since it is a temporary directory anyway.
+      # ======================================================================= #
+      File.delete(name_of_the_ts_file) if File.exist? name_of_the_ts_file
+      _ << ' '+name_of_the_ts_file
+      e _
+      system _
+    }
+    # ======================================================================= #
+    # Ok, now we created the intermediate .ts files, so now we can apply
+    # the concat protocol.
+    # ======================================================================= #
+    input_files = input_files.flatten.map.with_index {|entry, index|
+      index += 1
+      entry = MultimediaParadise.store_in_this_directory+'intermediate'+index.to_s+'.ts'
+      entry
+    }
+    _  = 'ffmpeg -i "concat:'+input_files.join('|')+'" -c copy '
+    _ << '  -bsf:a aac_adtstoasc '
+    _ << output_file
+    _.strip!
+    esystem _
+    if File.exist? output_file
+      e "The file should now exist at `#{sfile(output_file)}`."
+    end
+  end
+
+  # ========================================================================= #
+  # === MultimediaParadise.merge_mp3
+  #
+  # This method will merge a variable number of .mp3 files.
+  #
+  # Could use an alternative too:
+  #   mp3wrap output.mp3 *mp3
+  #
+  # In "pure" ruby however, try this:
+  #
+  #   require 'multimedia_multimedia'
+  #
+  #   MultimediaParadise.merge_mp3(:default, '*mp3')
+  #
+  # ========================================================================= #
+  def self.merge_mp3(
+      output_file = 'output.mp3', *input_files
+    )
+    case output_file
+    # This entry point is for the default name.
+    when nil, :default
+      output_file = 'output.mp3'
+    end
+    output_file = 'output_'+output_file unless output_file.include? '.'
+    output_file << '.mp3' unless output_file.end_with? 'mp3'
+    input_files = Dir['*.mp3'] if input_files.first == '*mp3' # This is a shorthand notation for "get all mp3 files".
+    if input_files.any? {|entry| entry.include? ' ' }
+      input_files.map! {|entry| '"'+entry+'"'}
+    end
+    # ======================================================================= #
+    # We could use either mpgtx or ffmpeg.
+    # _  = 'mpgtx -j '
+    # _ << '-o '+output_file
+    # _ << ' '+input_files.join(' ')
+    # ======================================================================= #
+    _ = 'ffmpeg -i concat:'+input_files.join('\|')
+    _ << " -acodec copy #{output_file}"
+    run_sys_command _
+    return output_file # And return this output file here as well.
+  end
+
+  # ========================================================================= #
+  # === MultimediaParadise.vobmerge
+  #
+  # You must pass the vob files to merge to this method.
+  # ========================================================================= #
+  def self.vobmerge(*input_files)
+    _ = 'cat '.dup
+    input_files = input_files.flatten
+    input_files.each {|file| _ << "#{file} " }
+    _ << ' > merged_'+File.basename(input_files.first) #.gsub(/\.vob/,'')
+    run_sys_command _
+  end
+
+  # ========================================================================= #
+  # === MultimediaParadise.merge_flv
+  #
+  # Merge .flv files. Uses mencoder right now.
+  # ========================================================================= #
+  def self.merge_flv(
+      output_file = 'output.flv', *input_files
+    )
+    _  = 'mencoder -forceidx -oac mp3lame -ovc copy'.dup
+    _ << ' -o '+output_file
+    _ << ' '+input_files.join(' ')
+    run_sys_command _
+  end
+
+end

data/lib/multimedia_paradise/toplevel_methods/merge_these_videos.rb

@@ -0,0 +1,105 @@
+#!/usr/bin/ruby -w
+# Encoding: UTF-8
+# frozen_string_literal: true
+# =========================================================================== #
+# require 'multimedia_paradise/toplevel_methods/merge_these_videos.rb'
+# =========================================================================== #
+module MultimediaParadise
+
+  require 'multimedia_paradise/colours/colours.rb'
+  require 'multimedia_paradise/toplevel_methods/esystem.rb'
+  require 'multimedia_paradise/toplevel_methods/output_directory.rb'
+
+  # ========================================================================= #
+  # === MultimediaParadise.merge_these_videos
+  #
+  # This method can be used to merge multiple videos together. The
+  # "concat" option of ffmpeg will be used for this merge-action.
+  #
+  # Ideally the video-files that are given as input to this method
+  # should all use the same resolution and the  same frame rate.
+  #
+  # There are several ways how to go about this. A simple one is to
+  # simply create a text-file that can then tell ffmpeg which files
+  # are to be merged together. This is the strategy that this
+  # method will presently (2018) pursue.
+  #
+  # The ffmpeg-concact options are explained here:
+  #
+  #   https://trac.ffmpeg.org/wiki/Concatenate
+  #
+  # Invocation examples:
+  #
+  #   MultimediaParadise.merge_these_videos('foo.mp4','bar.mp4')
+  #   MultimediaParadise.merge('foo.mp4','bar.mp4')
+  #
+  # ========================================================================= #
+  def self.merge_these_videos(
+      *i
+    )
+    i = [i].flatten.map(&:strip)
+    e ::Colours.rev+
+      ::Colours.steelblue(i.size.to_s)+
+      ' video files will be merged next.'
+    new_file_extension = nil
+    # ======================================================================= #
+    # We will store into the following text-file:
+    # ======================================================================= #
+    text_file = "#{log_directory?}file_that_keeps_track_of_the_videos.md"
+    # ======================================================================= #
+    # Make sure that the base directory exists:
+    # ======================================================================= #
+    unless File.directory?(File.dirname(text_file))
+      mkdir(File.dirname(text_file))
+    end
+    File.delete(text_file) if File.exist? text_file
+    name_of_the_output_file = 'merged_files_'.dup
+    e 'The video files will be analyzed. A log file will be stored at:'
+    e
+    e "  #{sfile(text_file)}"
+    e
+    i.each {|this_video_file|
+      # ===================================================================== #
+      # We have to obtain the absolute file path:
+      # ===================================================================== #
+      this_video_file = File.absolute_path(this_video_file)
+      File.open(text_file, 'a+') { |file|
+        file.write("file #{this_video_file}\n")
+      }
+      raw_name = this_video_file.sub(/#{File.extname(this_video_file)}$/,'').dup
+      name_of_the_output_file << File.basename(raw_name).delete('/')
+      new_file_extension = File.extname(this_video_file).delete('.')
+    }
+    # ======================================================================= #
+    # Ensure that the file name is not too long, thus truncating.
+    # ======================================================================= #
+    if name_of_the_output_file.size > 200
+      name_of_the_output_file = name_of_the_output_file[0 .. 200]
+    end
+    name_of_the_output_file << '.'+new_file_extension
+    name_of_the_output_file = '"'+name_of_the_output_file.
+                              delete("'")+'"'
+    # ======================================================================= #
+    # Build up the string for ffmpeg next. The option -y is used to
+    # overwrite automatically.
+    # ======================================================================= #
+    _ = 'ffmpeg '\
+        '-y '\
+        '-safe 0 '\
+        '-f concat '\
+        '-i '+text_file+
+        ' -c copy '+name_of_the_output_file
+    esystem _
+    e
+    e 'Ouput stored at:'
+    e
+    e "  #{sfile(name_of_the_output_file)}"
+    e
+    return name_of_the_output_file # <- And also return it here.
+  end; self.instance_eval { alias merge merge_these_videos } # === MultimediaParadise.merge
+
+end
+
+if __FILE__ == $PROGRAM_NAME
+  MultimediaParadise.merge_these_videos(ARGV)
+end # merge_these_videos foo.mp4 bar.mp4