ehbrs_ruby_utils 0.40.0 → 0.41.1

data/lib/ehbrs_ruby_utils/videos2/unsupported/checks/codec_extra_unsupported.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'ehbrs_ruby_utils/videos2/unsupported/fixes/supported_codec'
+
+module EhbrsRubyUtils
+  module Videos2
+    module Unsupported
+      module Checks
+        class CodecExtraUnsupported
+          TYPE = :stream
+
+          common_constructor :codec, :extra
+
+          def check(track)
+            return nil unless track.codec_name == codec
+            return nil unless track.codec_tag_string.downcase.include?(extra.downcase)
+
+            "Unsupported extra \"#{extra}\" for codec \"#{codec}\" and track #{track}"
+          end
+
+          def fix
+            ::EhbrsRubyUtils::Videos2::Unsupported::Fixes::SupportedCodec.new
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ehbrs_ruby_utils/videos2/unsupported/checks/codec_unlisted.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module EhbrsRubyUtils
+  module Videos2
+    module Unsupported
+      module Checks
+        class CodecUnlisted
+          TYPE = :stream
+
+          common_constructor :listed_codecs
+
+          def check(track)
+            return nil if listed_codecs.include?(track.codec_name)
+
+            "Not listed codec \"#{track.codec_name}\" (Track: #{track}, listed: #{listed_codecs})"
+          end
+
+          def fix
+            nil
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ehbrs_ruby_utils/videos2/unsupported/checks/codec_unsupported.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'ehbrs_ruby_utils/videos2/unsupported/fixes/supported_codec'
+
+module EhbrsRubyUtils
+  module Videos2
+    module Unsupported
+      module Checks
+        class CodecUnsupported
+          TYPE = :stream
+
+          common_constructor :codec
+
+          def check(track)
+            return nil unless track.codec_name == codec
+
+            "Unsupported codec \"#{codec}\" for track #{track}"
+          end
+
+          def fix
+            ::EhbrsRubyUtils::Videos2::Unsupported::Fixes::SupportedCodec.new
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ehbrs_ruby_utils/videos2/unsupported/checks/invalid_extension.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'ehbrs_ruby_utils/videos2/unsupported/fixes/supported_container'
+
+module EhbrsRubyUtils
+  module Videos2
+    module Unsupported
+      module Checks
+        class InvalidExtension
+          TYPE = :container
+
+          common_constructor :extension
+
+          def check(video)
+            return nil unless ::File.extname(video.path) == extension
+
+            "File has invalid extension: #{extension}"
+          end
+
+          def fix
+            ::EhbrsRubyUtils::Videos2::Unsupported::Fixes::SupportedContainer.new
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ehbrs_ruby_utils/videos2/unsupported/checks.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+
+module EhbrsRubyUtils
+  module Videos2
+    module Unsupported
+      module Checks
+        require_sub __FILE__
+      end
+    end
+  end
+end

data/lib/ehbrs_ruby_utils/videos2/unsupported/file/fix.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require 'ehbrs_ruby_utils/videos/file'
+require 'ehbrs_ruby_utils/videos2/convert_job'
+require 'ehbrs_ruby_utils/videos2/unsupported/fix_profile'
+
+module EhbrsRubyUtils
+  module Videos2
+    module Unsupported
+      class File < ::EhbrsRubyUtils::Videos::File
+        module Fix
+          def check_fix
+            return unless options.fetch(:fix)
+
+            if fix_blocks.any?
+              infom '  * Cannot fix:'
+              fix_blocks.each do |fb|
+                infom "    * #{fb.check.check_name}"
+              end
+            else
+              infom '  * Fixing...'
+              infom "  * Fixed in: \"#{fix}\""
+            end
+          end
+
+          private
+
+          def all_fix_blocks_uncached
+            fix_blocks + tracks.flat_map(&:fix_blocks)
+          end
+
+          def fix_profile_uncached
+            ::EhbrsRubyUtils::Videos2::Unsupported::FixProfile.new(self)
+          end
+
+          def fix
+            job = ::EhbrsRubyUtils::Videos2::ConvertJob.new(path, fix_profile)
+            job.run
+            job.target
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ehbrs_ruby_utils/videos2/unsupported/file.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require 'ehbrs_ruby_utils/videos/file'
+require 'ehbrs_ruby_utils/videos2/unsupported/file/fix'
+require 'ehbrs_ruby_utils/videos2/unsupported/check_support'
+require 'ehbrs_ruby_utils/videos2/unsupported/track'
+
+module EhbrsRubyUtils
+  module Videos2
+    module Unsupported
+      class File < ::EhbrsRubyUtils::Videos::File
+        include ::EhbrsRubyUtils::Videos2::Unsupported::CheckSupport
+        include ::EhbrsRubyUtils::Videos2::Unsupported::File::Fix
+
+        attr_reader :options
+
+        def initialize(file, options)
+          super(file)
+          @options = options
+        end
+
+        def banner
+          infov 'File', path
+          pad_speaker do
+            aggressions_banner('Self')
+            tracks.each(&:banner)
+          end
+        end
+
+        def all_passed?
+          passed? && tracks.all?(&:passed?)
+        end
+
+        def all_fixes
+          fixes + tracks.flat_map(&:fixes)
+        end
+
+        def check_set_key
+          :file_check_set
+        end
+
+        private
+
+        # @return [Enumerable<EhbrsRubyUtils::Videos2::Unsupported::Track>]
+        def tracks_uncached
+          streams.reject.map { |t| ::EhbrsRubyUtils::Videos2::Unsupported::Track.new(self, t) }
+        end
+      end
+    end
+  end
+end

data/lib/ehbrs_ruby_utils/videos2/unsupported/fix_profile.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require 'ehbrs_ruby_utils/videos2/profiles/same_quality'
+require 'ehbrs_ruby_utils/videos2/unsupported/fixes/supported_container'
+
+module EhbrsRubyUtils
+  module Videos2
+    module Unsupported
+      class FixProfile
+        include ::EhbrsRubyUtils::Videos2::Profiles::SameQuality
+
+        common_constructor :video
+        set_callback :swap, :after do
+          video.all_fixes.each do |fix|
+            next unless fix.respond_to?(:after_swap)
+
+            fix.after_swap(self)
+          end
+        end
+
+        def name
+          "fix_for_#{::File.basename(video.file)}"
+        end
+
+        def ffmpeg_args
+          r = fix_args
+          r += container_fix_args unless r.include?('-f')
+          r + super
+        end
+
+        private
+
+        def fix_args
+          ['-c', 'copy'] + video.ffmpeg_fix_args +
+            video.tracks.flat_map(&:ffmpeg_fix_args)
+        end
+
+        def container_fix_args
+          ['-f', ::EhbrsRubyUtils::Videos2::Unsupported::Fixes::SupportedContainer::FIX_FORMAT]
+        end
+      end
+    end
+  end
+end

data/lib/ehbrs_ruby_utils/videos2/unsupported/fixes/supported_codec/ffmpeg_args.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module EhbrsRubyUtils
+  module Videos2
+    module Unsupported
+      module Fixes
+        class SupportedCodec
+          class FfmpegArgs
+            FORMATS = {
+              i: :index,
+              f: :target_codec,
+              t: :codec_type_letter
+            }.freeze
+
+            SOURCE_COMMON_ARGS = ['-%tcodec:%i', '%f'].freeze
+            SOURCE_AUDIO_ARGS = SOURCE_COMMON_ARGS
+            SOURCE_SUBTITLE_ARGS = SOURCE_COMMON_ARGS
+            SOURCE_VIDEO_ARGS = SOURCE_COMMON_ARGS + ['-crf', '17', '-filter:%t', 'format=yuv420p']
+
+            TARGET_CODECS = {
+              audio: 'aac',
+              video: 'libx264',
+              subtitle: 'ass'
+            }.freeze
+
+            acts_as_instance_method
+            common_constructor :owner, :track
+
+            # @return [Array<String>]
+            def result
+              source_args_by_codec_type.map { |arg| target_arg(arg) }
+            end
+
+            private
+
+            # @return [String]
+            def codec_type_letter
+              track.codec_type.to_s[0].downcase
+            end
+
+            # @return [String]
+            def index
+              track.index.to_s
+            end
+
+            # @return [Array<String>]
+            def source_args_by_codec_type
+              self.class.const_get("SOURCE_#{track.codec_type.to_s.underscore.upcase}_ARGS")
+            end
+
+            # @param arg [String]
+            # @return [String]
+            def target_arg(arg)
+              FORMATS.inject(arg) do |a, e|
+                a.gsub("%#{e.first}", send(e.last))
+              end
+            end
+
+            # @return [String]
+            def target_codec
+              TARGET_CODECS.fetch(track.codec_type.to_s.underscore.to_sym)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ehbrs_ruby_utils/videos2/unsupported/fixes/supported_codec.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+
+module EhbrsRubyUtils
+  module Videos2
+    module Unsupported
+      module Fixes
+        class SupportedCodec
+          require_sub __FILE__, require_mode: :kernel
+        end
+      end
+    end
+  end
+end

data/lib/ehbrs_ruby_utils/videos2/unsupported/fixes/supported_container.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module EhbrsRubyUtils
+  module Videos2
+    module Unsupported
+      module Fixes
+        class SupportedContainer
+          FIX_FORMAT = 'matroska'
+
+          def ffmpeg_args(_video)
+            ['-f', FIX_FORMAT]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ehbrs_ruby_utils/videos2/unsupported/profiles/aoc.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'ehbrs_ruby_utils/videos2/unsupported/profiles/base'
+
+module EhbrsRubyUtils
+  module Videos2
+    module Unsupported
+      module Profiles
+        class Aoc < ::EhbrsRubyUtils::Videos2::Unsupported::Profiles::Base
+          AUDIO_SUPPORTED_CODECS = %w[aac ac3 mp2 mp3].freeze
+          AUDIO_UNSUPPORTED_CODECS = %w[eac3 vorbis].freeze
+
+          VIDEO_SUPPORTED_CODECS = %w[h264 mpeg4].freeze
+          VIDEO_UNSUPPORTED_CODECS = %w[hevc].freeze
+
+          SUBTITLE_SUPPORTED_CODECS = %w[ass dvd_subtitle hdmv_pgs_subtitle subrip].freeze
+          SUBTITLE_UNSUPPORTED_CODECS = %w[mov_text].freeze
+
+          OTHER_SUPPORTED_CODECS = %w[].freeze
+
+          MPEG4_EXTRA_SUPPORTED = %w[xvid].freeze
+          MPEG4_EXTRA_UNSUPPORTED = %w[].freeze
+        end
+      end
+    end
+  end
+end

data/lib/ehbrs_ruby_utils/videos2/unsupported/profiles/base.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+module EhbrsRubyUtils
+  module Videos2
+    module Unsupported
+      module Profiles
+        class Base
+          enable_simple_cache
+          include ::Singleton
+
+          CONSTANT_PREFIXES = %w[video audio subtitle other].freeze
+
+          def added_checks
+            @added_checks ||= []
+          end
+
+          def add_check(name, *args)
+            check_path = "ehbrs_ruby_utils/videos2/unsupported/checks/#{name}"
+            added_checks << check_path.camelize.constantize.new(*args)
+          end
+
+          def base_checks
+            [unlisted_codec_check] + unsupported_codec_checks +
+              supported_codecs.flat_map { |codec| codec_extra_checks(codec) }
+          end
+
+          def checks
+            base_checks + added_checks
+          end
+
+          def file_checks
+            checks.select { |c| check_type(c) == :container }
+          end
+
+          def track_checks
+            checks.select { |c| check_type(c) == :stream }
+          end
+
+          def codec_extra_checks(codec)
+            codec_unlisted_extra_check(codec).if_present([]) { |v| [v] } +
+              codec_unsupported_extras(codec).map do |extra|
+                EhbrsRubyUtils::Videos2::Unsupported::Checks::CodecExtraUnsupported.new(codec,
+                                                                                        extra)
+              end
+          end
+
+          def codec_unlisted_extra_check(codec)
+            extras = codec_unsupported_extras(codec) + codec_supported_extras(codec)
+            return nil unless extras.any?
+
+            EhbrsRubyUtils::Videos2::Unsupported::Checks::CodecExtraUnlisted.new(
+              codec, extras.sort.uniq
+            )
+          end
+
+          def name
+            self.class.name.demodulize.underscore
+          end
+
+          def to_s
+            name
+          end
+
+          def unsupported_codec_checks
+            unsupported_codecs.map do |codec|
+              EhbrsRubyUtils::Videos2::Unsupported::Checks::CodecUnsupported.new(codec)
+            end
+          end
+
+          def unsupported_codecs_uncached
+            codecs_by_constant('unsupported')
+          end
+
+          def unlisted_codec_check
+            ::EhbrsRubyUtils::Videos2::Unsupported::Checks::CodecUnlisted.new(
+              (supported_codecs + unsupported_codecs).sort.uniq
+            )
+          end
+
+          def supported_codecs_uncached
+            codecs_by_constant('supported')
+          end
+
+          def codecs_by_constant(middle)
+            CONSTANT_PREFIXES.inject([]) { |a, e| a + codecs_by_prefix(e, middle) }
+          end
+
+          def codecs_by_prefix(prefix, middle)
+            self.class.const_get("#{prefix}_#{middle}_codecs".upcase)
+          rescue NameError
+            []
+          end
+
+          def codec_extras(codec, suffix)
+            self.class.const_get("#{codec}_extra_#{suffix}".upcase)
+          rescue NameError
+            []
+          end
+
+          def codec_unsupported_extras(codec)
+            codec_extras(codec, 'unsupported')
+          end
+
+          def codec_supported_extras(codec)
+            codec_extras(codec, 'supported')
+          end
+
+          private
+
+          def check_type(check)
+            check.class.const_get(:TYPE)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ehbrs_ruby_utils/videos2/unsupported/profiles/philco.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'ehbrs_ruby_utils/videos2/unsupported/profiles/base'
+
+module EhbrsRubyUtils
+  module Videos2
+    module Unsupported
+      module Profiles
+        class Philco < ::EhbrsRubyUtils::Videos2::Unsupported::Profiles::Base
+          AUDIO_SUPPORTED_CODECS = %w[aac ac3 eac3 mp3 vorbis wmav2].freeze
+          AUDIO_UNSUPPORTED_CODECS = %w[dts opus].freeze
+
+          VIDEO_SUPPORTED_CODECS = %w[h264 mpeg4].freeze
+          VIDEO_UNSUPPORTED_CODECS = %w[hevc msmpeg4v3].freeze
+
+          SUBTITLE_SUPPORTED_CODECS = %w[ass dvd dvd_subtitle hdmv_pgs_subtitle mov_text
+                                         subrip].freeze
+          SUBTITLE_UNSUPPORTED_CODECS = %w[mov].freeze
+
+          OTHER_SUPPORTED_CODECS = %w[png ttf].freeze
+
+          MPEG4_EXTRA_SUPPORTED = %w[xvid].freeze
+          MPEG4_EXTRA_UNSUPPORTED = %w[divx dx50].freeze
+        end
+      end
+    end
+  end
+end

data/lib/ehbrs_ruby_utils/videos2/unsupported/profiles/samsung.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require 'ehbrs_ruby_utils/videos2/unsupported/checks/invalid_extension'
+require 'ehbrs_ruby_utils/videos2/unsupported/profiles/base'
+
+module EhbrsRubyUtils
+  module Videos2
+    module Unsupported
+      module Profiles
+        class Samsung < ::EhbrsRubyUtils::Videos2::Unsupported::Profiles::Base
+          AUDIO_SUPPORTED_CODECS = %w[aac ac3 eac3 mp3 vorbis].freeze
+          AUDIO_UNSUPPORTED_CODECS = %w[dts].freeze
+
+          VIDEO_SUPPORTED_CODECS = %w[h264 mpeg4 hevc mjpeg].freeze
+          VIDEO_UNSUPPORTED_CODECS = %w[].freeze
+
+          SUBTITLE_SUPPORTED_CODECS = %w[ass dvd dvd_subtitle hdmv_pgs_subtitle subrip].freeze
+          SUBTITLE_UNSUPPORTED_CODECS = %w[mov mov_text].freeze
+
+          OTHER_SUPPORTED_CODECS = %w[png ttf].freeze
+
+          MPEG4_EXTRA_SUPPORTED = %w[].freeze
+          MPEG4_EXTRA_UNSUPPORTED = %w[dx50 xvid].freeze
+
+          def initialize
+            super()
+            add_check('invalid_extension', '.m4v')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ehbrs_ruby_utils/videos2/unsupported/profiles.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+
+module EhbrsRubyUtils
+  module Videos2
+    module Unsupported
+      module Profiles
+        require_sub __FILE__
+      end
+    end
+  end
+end

data/lib/ehbrs_ruby_utils/videos2/unsupported/search.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require 'eac_fs/traversable'
+require 'eac_ruby_utils/core_ext'
+require 'ehbrs_ruby_utils/videos2/unsupported/file'
+
+module EhbrsRubyUtils
+  module Videos2
+    module Unsupported
+      class Search
+        include ::EacFs::Traversable
+        enable_speaker
+        enable_simple_cache
+
+        VALID_EXTENSIONS = %w[.avi .mp4 .mkv .m4v].freeze
+
+        def initialize(root, file_options)
+          @root = root
+          @file_options = file_options
+          @files = 0
+          @videos = 0
+          @unsupported = 0
+          run
+        end
+
+        def traverser_recursive
+          true
+        end
+
+        def traverser_sort
+          true
+        end
+
+        private
+
+        def run
+          start_banner
+          traverser_check_path(@root)
+          end_banner
+        end
+
+        def traverser_check_file(file)
+          @files += 1
+          check_video(file) if video_file?(file)
+        end
+
+        def check_video(file)
+          @videos += 1
+          v = ::EhbrsRubyUtils::Videos2::Unsupported::File.new(file, @file_options)
+          return if v.all_passed?
+
+          @unsupported += 1
+          v.banner
+          v.check_fix
+        end
+
+        def start_banner
+          infom "Searching in: \"#{@root}\""
+        end
+
+        def end_banner
+          infom "Unsupported/Videos/Files: #{@unsupported}/#{@videos}/#{@files}"
+        end
+
+        def video_file?(path)
+          valid_extensions.include?(::File.extname(path))
+        end
+
+        def valid_extensions
+          self.class::VALID_EXTENSIONS
+        end
+      end
+    end
+  end
+end