convert-video.rb

#!/usr/bin/env ruby
#
# convert-video.rb
#
# Copyright (c) 2025 Lisa Melton
#

require 'English'
require 'json'
require 'optparse'

module Converting

  class UsageError < RuntimeError
  end

  class Command
    def about
      <<-HERE
convert-video.rb 2025.01.28
Copyright (c) 2025 Lisa Melton
      HERE
    end

    def usage
      <<-HERE
Convert media file from Matroska to MP4 format or other media to MKV
without transcoding.

Usage: #{File.basename($PROGRAM_NAME)} [OPTION]... [FILE]...

All video, audio and subtitle tracks are copied during conversion.
But incompatible subtitles are ignored when converting to MP4 format.

Options:
    --debug           increase diagnostic information
-n, --dry-run         don't transcode, just show `ffmpeg` command
-h, --help            display this help and exit
    --version         output version information and exit

Requires `ffmpeg` and `ffprobe`.
      HERE
    end

    def initialize
      @debug = false
      @dry_run = false
    end

    def run
      begin
        OptionParser.new do |opts|
          define_options opts

          opts.on '-h', '--help' do
            puts usage
            exit
          end

          opts.on '--version' do
            puts about
            exit
          end
        end.parse!
      rescue OptionParser::ParseError => e
        raise UsageError, e
      end

      fail UsageError, 'missing argument' if ARGV.empty?

      ARGV.each { |arg| process_input arg }
      exit
    rescue UsageError => e
      Kernel.warn "#{$PROGRAM_NAME}: #{e}"
      Kernel.warn "Try `#{File.basename($PROGRAM_NAME)} --help` for more information."
      exit false
    rescue StandardError => e
      Kernel.warn "#{$PROGRAM_NAME}: #{e}"
      exit(-1)
    rescue SignalException
      puts
      exit(-1)
    end

    def define_options(opts)
      opts.on '--debug' do
        @debug = true
      end

      opts.on '-n', '--dry-run' do
        @dry_run = true
      end
    end

    def process_input(path)
      seconds = Time.now.tv_sec
      media_info = scan_media(path)
      options = ['-c:v', 'copy', '-c:a', 'copy']

      if media_info['format']['format_name'] =~ /matroska/
        extension = '.mp4'
        index = 0

        media_info['streams'].each do |stream|
          map_stream = false
          codec_name = nil

          case stream['codec_type']
          when 'video', 'audio'
            map_stream = true
          when 'subtitle'
            case stream['codec_name']
            when 'dvd_subtitle'
              map_stream = true
              codec_name = 'copy'
            when 'subrip'
              map_stream = true
              codec_name = 'mov_text'
            else
              Kernel.warn "Ignoring subtitle track \##{index + 1}"
            end

            index += 1
          end

          options += ['-map', "0:#{stream['index']}"] if map_stream
          options += ["-c:s:#{index - 1}", codec_name] unless codec_name.nil?
        end

        options += ['-movflags', 'disable_chpl']
      else
        extension = '.mkv'
        options += ['-c:s', 'copy']
      end

      output = File.basename(path, '.*') + extension

      ffmpeg_command = [
        'ffmpeg',
        '-loglevel', (@debug ? 'verbose' : 'error'),
        '-stats',
        '-i', path,
        *options,
        output
      ]

      command_line = escape_command(ffmpeg_command)
      Kernel.warn 'Command line:'

      if @dry_run
        puts command_line
        return
      end

      Kernel.warn command_line
      fail "output file already exists: #{output}" if File.exist? output

      Kernel.warn 'Converting...'
      system(*ffmpeg_command, exception: true)
      Kernel.warn "\nElapsed time: #{seconds_to_time(Time.now.tv_sec - seconds)}\n\n"
    end

    def scan_media(path)
      Kernel.warn 'Scanning media...'
      media_info = ''

      IO.popen([
        'ffprobe',
        '-loglevel', 'quiet',
        '-show_streams',
        '-show_format',
        '-print_format', 'json',
        path
      ]) do |io|
        media_info = io.read
      end

      fail "scanning media failed: #{path}" unless $CHILD_STATUS.exitstatus == 0

      begin
        media_info = JSON.parse(media_info)
      rescue JSON::JSONError
        fail "media information not found: #{path}"
      end

      Kernel.warn media_info.inspect if @debug
      media_info
    end

    def escape_command(command)
      command_line = ''
      command.each {|item| command_line += "#{escape_string(item)} " }
      command_line.sub!(/ $/, '')
      command_line
    end

def escape_string(str)
      # See: https://github.com/larskanis/shellwords
      return '""' if str.empty?

      str = str.dup

      if RUBY_PLATFORM =~ /mingw/
        str.gsub!(/((?:\\)*)"/) { "\\" * ($1.length * 2) + "\\\"" }

        if str =~ /\s/
          str.gsub!(/(\\+)\z/) { "\\" * ($1.length * 2 ) }
          str = "\"#{str}\""
        end
      else
        str.gsub!(/([^A-Za-z0-9_\-.,:\/@\n])/, "\\\\\\1")
        str.gsub!(/\n/, "'\n'")
      end

      str
    end

    def seconds_to_time(seconds)
      sprintf("%02d:%02d:%02d", seconds / (60 * 60), (seconds / 60) % 60, seconds % 60)
    end
  end
end

Converting::Command.new.run