Remove forced audio tracks & minor refactoring

Fix setting of default audio track on files with no default subtitle track

pom.xml

@@ -6,7 +6,7 @@
 
     <groupId>at.pcgamingfreaks</groupId>
     <artifactId>MKVAudioSubtitleChanger</artifactId>
-    <version>3.0</version>
+    <version>3.0.2</version>
 
     <build>
         <defaultGoal>clean package</defaultGoal>

src/main/java/at/pcgamingfreaks/mkvaudiosubtitlechanger/config/ConfigLoader.java

@@ -93,7 +93,7 @@ public class ConfigLoader {
     }
 
     private static void exitIfHelp(CommandLine cmd, Options options, HelpFormatter formatter) {
-        if (cmd.hasOption("help")) {
+        if (cmd.hasOption(HELP.prop())) {
             formatter.printHelp(130, "java -jar MKVAudioSubtitlesChanger.jar -l <path_to_library>",
                     "\nParameters:", options,
                     "\nFeature requests and bug reports: https://github.com/RatzzFatzz/MKVAudioSubtitleChanger/issues");

src/main/java/at/pcgamingfreaks/mkvaudiosubtitlechanger/impl/MkvFileProcessor.java

@@ -30,6 +30,7 @@ public class MkvFileProcessor implements FileProcessor {
 
     private static final String DISABLE_DEFAULT_TRACK = "--edit track:%s --set flag-default=0 ";
     private static final String ENABLE_DEFAULT_TRACK = "--edit track:%s --set flag-default=1 ";
+    private static final String DISABLE_FORCED_TRACK = "--edit track:%s --set flag-forced=0 ";
     private static final String ENABLE_FORCED_TRACK = "--edit track:%s --set flag-forced=1 ";
 
     @SuppressWarnings("unchecked")
@@ -69,8 +70,8 @@ public class MkvFileProcessor implements FileProcessor {
 
             log.debug(fileAttributes.toString());
         } catch (IOException e) {
-            e.printStackTrace();
+            log.error("File could not be found or loaded: ", e);
-            log.error("File could not be found or loaded!");
+            System.out.println("File could not be found or loaded: " + file.getAbsolutePath());
         }
         return fileAttributes;
     }
@@ -80,21 +81,17 @@ public class MkvFileProcessor implements FileProcessor {
      */
     @Override
     public void detectDefaultTracks(FileInfoDto info, List<FileAttribute> attributes, List<FileAttribute> nonForcedTracks) {
-        Set<FileAttribute> detectedForcedSubtitleLanes = new HashSet<>();
         for (FileAttribute attribute : attributes) {
-            if (attribute.isDefaultTrack() && AUDIO.equals(attribute.getType()))
+            if (AUDIO.equals(attribute.getType())) {
-                info.getDefaultAudioLanes().add(attribute);
+                if (attribute.isDefaultTrack()) info.getExistingDefaultAudioLanes().add(attribute);
-            if (attribute.isDefaultTrack() && SUBTITLES.equals(attribute.getType()))
+                if (attribute.isForcedTrack()) info.getExistingForcedAudioLanes().add(attribute);
-                info.getDefaultSubtitleLanes().add(attribute);
+            } else if (SUBTITLES.equals(attribute.getType())) {
-            if (attribute.isForcedTrack() && SUBTITLES.equals(attribute.getType()))
+                if (attribute.isDefaultTrack()) info.getExistingDefaultSubtitleLanes().add(attribute);
-                detectedForcedSubtitleLanes.add(attribute);
-        }
 
-        info.setDesiredForcedSubtitleLanes(attributes.stream()
+                if (attribute.isForcedTrack()) info.getExistingForcedSubtitleLanes().add(attribute);
-                .filter(e -> !nonForcedTracks.contains(e))
+                else if (!nonForcedTracks.contains(attribute)) info.getDesiredForcedSubtitleLanes().add(attribute);
-                .filter(e -> !detectedForcedSubtitleLanes.contains(e))
+            }
-                .collect(Collectors.toSet())
+        }
-        );
     }
 
     /**
@@ -113,8 +110,8 @@ public class MkvFileProcessor implements FileProcessor {
 
             if (desiredAudio.isPresent() && ("OFF".equals(config.getSubtitleLanguage()) || desiredSubtitle.isPresent())) {
                 info.setMatchedConfig(config);
-                info.setDesiredAudioLane(desiredAudio.get());
+                info.setDesiredDefaultAudioLane(desiredAudio.get());
-                info.setDesiredSubtitleLane(desiredSubtitle.orElse(null));
+                info.setDesiredDefaultSubtitleLane(desiredSubtitle.orElse(null));
                 break;
             }
         }
@@ -156,22 +153,28 @@ public class MkvFileProcessor implements FileProcessor {
         sb.append(format("\"%s\" ", file.getAbsolutePath()));
 
         if (fileInfo.isAudioDifferent()) {
-            if (fileInfo.getDefaultAudioLanes() != null && !fileInfo.getDefaultSubtitleLanes().isEmpty()) {
+            if (fileInfo.getExistingDefaultAudioLanes() != null && !fileInfo.getExistingDefaultAudioLanes().isEmpty()) {
-                for (FileAttribute track: fileInfo.getDefaultAudioLanes()) {
+                for (FileAttribute track: fileInfo.getExistingDefaultAudioLanes()) {
                     sb.append(format(DISABLE_DEFAULT_TRACK, track.getId()));
                 }
             }
-            sb.append(format(ENABLE_DEFAULT_TRACK, fileInfo.getDesiredAudioLane().getId()));
+            sb.append(format(ENABLE_DEFAULT_TRACK, fileInfo.getDesiredDefaultAudioLane().getId()));
+        }
+
+        if (!fileInfo.getExistingForcedAudioLanes().isEmpty()) {
+            for (FileAttribute track: fileInfo.getExistingForcedAudioLanes()) {
+                sb.append(format(DISABLE_FORCED_TRACK, track.getId()));
+            }
         }
 
         if (fileInfo.isSubtitleDifferent()) {
-            if (fileInfo.getDefaultSubtitleLanes() != null && !fileInfo.getDefaultSubtitleLanes().isEmpty()) {
+            if (fileInfo.getExistingDefaultSubtitleLanes() != null && !fileInfo.getExistingDefaultSubtitleLanes().isEmpty()) {
-                for (FileAttribute track: fileInfo.getDefaultSubtitleLanes()) {
+                for (FileAttribute track: fileInfo.getExistingDefaultSubtitleLanes()) {
                     sb.append(format(DISABLE_DEFAULT_TRACK, track.getId()));
                 }
             }
-            if (fileInfo.getDesiredSubtitleLane() != null) {
+            if (fileInfo.getDesiredDefaultSubtitleLane() != null) {
-                sb.append(format(ENABLE_DEFAULT_TRACK, fileInfo.getDesiredSubtitleLane().getId()));
+                sb.append(format(ENABLE_DEFAULT_TRACK, fileInfo.getDesiredDefaultSubtitleLane().getId()));
             }
         }
 

src/main/java/at/pcgamingfreaks/mkvaudiosubtitlechanger/impl/kernel/CoherentAttributeUpdaterKernel.java

@@ -11,9 +11,7 @@ import me.tongfei.progressbar.ProgressBarBuilder;
 import org.apache.commons.lang3.StringUtils;
 
 import java.io.File;
-import java.util.HashMap;
 import java.util.List;
-import java.util.Map;
 import java.util.stream.Collectors;
 
 @Slf4j
@@ -85,16 +83,16 @@ public class CoherentAttributeUpdaterKernel extends AttributeUpdaterKernel {
                 processor.detectDesiredTracks(fileInfo, nonForcedTracks, nonCommentaryTracks, config);
             }
 
-            if (fileInfos.stream().allMatch(elem -> ("OFF".equals(config.getSubtitleLanguage()) || elem.getDesiredSubtitleLane() != null)
+            if (fileInfos.stream().allMatch(elem -> ("OFF".equals(config.getSubtitleLanguage()) || elem.getDesiredDefaultSubtitleLane() != null)
-                    && elem.getDesiredAudioLane() != null)) {
+                    && elem.getDesiredDefaultAudioLane() != null)) {
                 log.info("Found {}/{} match for {}", config.getAudioLanguage(), config.getSubtitleLanguage(), file.getAbsolutePath());
                 fileInfos.forEach(this::updateFile);
                 return; // match found, end process here
             }
 
             fileInfos.forEach(f -> {
-                f.setDesiredAudioLane(null);
+                f.setDesiredDefaultAudioLane(null);
-                f.setDesiredSubtitleLane(null);
+                f.setDesiredDefaultSubtitleLane(null);
             });
         }
 

src/main/java/at/pcgamingfreaks/mkvaudiosubtitlechanger/model/FileInfoDto.java

@@ -13,16 +13,21 @@ import java.util.Set;
 @RequiredArgsConstructor
 public class FileInfoDto {
     private final File file;
-    private Set<FileAttribute> defaultAudioLanes = new HashSet<>();
+
-    private Set<FileAttribute> defaultSubtitleLanes = new HashSet<>();
+    private Set<FileAttribute> existingDefaultAudioLanes = new HashSet<>();
-    private Set<FileAttribute> desiredForcedSubtitleLanes;
+    private Set<FileAttribute> existingForcedAudioLanes = new HashSet<>();
-    private FileAttribute desiredAudioLane;
+
-    private FileAttribute desiredSubtitleLane;
+    private Set<FileAttribute> existingDefaultSubtitleLanes = new HashSet<>();
+    private Set<FileAttribute> existingForcedSubtitleLanes = new HashSet<>();
+
+    private Set<FileAttribute> desiredForcedSubtitleLanes = new HashSet<>();
+    private FileAttribute desiredDefaultAudioLane;
+    private FileAttribute desiredDefaultSubtitleLane;
     private AttributeConfig matchedConfig;
 
     public boolean isAudioDifferent() {
-        return desiredAudioLane != null &&
+        return desiredDefaultAudioLane != null &&
-                (defaultAudioLanes == null || !defaultAudioLanes.contains(desiredAudioLane) || defaultAudioLanes.size() > 1);
+                (existingDefaultAudioLanes == null || !existingDefaultAudioLanes.contains(desiredDefaultAudioLane) || existingDefaultAudioLanes.size() > 1);
     }
 
     public boolean isSubtitleDifferent() {
@@ -30,17 +35,17 @@ public class FileInfoDto {
     }
 
     private boolean isSubtitleMatchDifferent() {
-        return desiredSubtitleLane != null
+        return desiredDefaultSubtitleLane != null
-                && (defaultSubtitleLanes == null || !defaultSubtitleLanes.contains(desiredSubtitleLane) || defaultAudioLanes.size() > 1);
+                && (existingDefaultSubtitleLanes == null || !existingDefaultSubtitleLanes.contains(desiredDefaultSubtitleLane) || existingDefaultSubtitleLanes.size() > 1);
     }
 
     private boolean isSubtitleOFF() {
-        return desiredSubtitleLane == null && "OFF".equals(matchedConfig.getSubtitleLanguage()) &&
+        return desiredDefaultSubtitleLane == null && "OFF".equals(matchedConfig.getSubtitleLanguage()) &&
-                (defaultAudioLanes != null || !defaultAudioLanes.isEmpty());
+                (existingDefaultSubtitleLanes != null && !existingDefaultSubtitleLanes.isEmpty());
     }
 
     public boolean areForcedTracksDifferent() {
-        return desiredForcedSubtitleLanes.size() > 0;
+        return !desiredForcedSubtitleLanes.isEmpty();
     }
 
     public FileStatus getStatus() {
@@ -51,24 +56,24 @@ public class FileInfoDto {
     }
 
     private boolean isUnableToApplyConfig() {
-        return desiredAudioLane == null && desiredSubtitleLane == null;
+        return desiredDefaultAudioLane == null && desiredDefaultSubtitleLane == null;
     }
 
     private boolean isAlreadySuitable() {
-        return defaultAudioLanes.contains(desiredAudioLane) && defaultSubtitleLanes.contains(desiredSubtitleLane);
+        return existingDefaultAudioLanes.contains(desiredDefaultAudioLane) && existingDefaultSubtitleLanes.contains(desiredDefaultSubtitleLane);
     }
 
     private boolean isChangeNecessary() {
-        return isAudioDifferent() || isSubtitleDifferent() || areForcedTracksDifferent();
+        return isAudioDifferent() || isSubtitleDifferent() || areForcedTracksDifferent() || !existingForcedAudioLanes.isEmpty();
     }
 
     @Override
     public String toString() {
-        return "[" + "defaultAudioLanes=" + defaultAudioLanes +
+        return "[" + "defaultAudioLanes=" + existingDefaultAudioLanes +
-                ", defaultSubtitleLanes=" + defaultSubtitleLanes +
+                ", defaultSubtitleLanes=" + existingDefaultSubtitleLanes +
                 ", desiredForcedSubtitleLanes=" + desiredForcedSubtitleLanes +
-                ", desiredAudioLane=" + desiredAudioLane +
+                ", desiredAudioLane=" + desiredDefaultAudioLane +
-                ", desiredSubtitleLane=" + desiredSubtitleLane +
+                ", desiredSubtitleLane=" + desiredDefaultSubtitleLane +
                 ']';
     }
 }

src/test/java/at/pcgamingfreaks/mkvaudiosubtitlechanger/config/ConfigLoaderTest.java

@@ -0,0 +1,44 @@
+package at.pcgamingfreaks.mkvaudiosubtitlechanger.config;
+
+import at.pcgamingfreaks.mkvaudiosubtitlechanger.model.AttributeConfig;
+import org.junit.jupiter.api.Test;
+
+import java.util.List;
+
+import static at.pcgamingfreaks.mkvaudiosubtitlechanger.util.PathUtils.TEST_FILE;
+import static org.junit.jupiter.api.Assertions.*;
+
+class ConfigLoaderTest {
+
+    @Test
+    void initConfig() {
+        String[] sut = new String[]{"-a", "ger:ger", "-l", TEST_FILE,
+                "-s", "-cf", "-n",
+                "-c", "2",
+                "-t", "4",
+                "-i", ".*[abc].*",
+                "-fk", "testForced",
+                "-ck", "testCommentary",
+                "-ps", "testPreferred"
+        };
+        ConfigLoader.initConfig(sut);
+
+        assertTrue(Config.getInstance().getLibraryPath().exists());
+        assertEquals(List.of(new AttributeConfig("ger", "ger")), Config.getInstance().getAttributeConfig());
+
+        assertTrue(Config.getInstance().isSafeMode());
+        assertTrue(Config.getInstance().isForceCoherent());
+        assertTrue(Config.getInstance().isOnlyNewFiles());
+        assertNotNull(Config.getInstance().getFilterDate());
+
+        assertEquals(2, Config.getInstance().getCoherent());
+        assertEquals(4, Config.getInstance().getThreads());
+        assertEquals(".*[abc].*", Config.getInstance().getIncludePattern().pattern());
+        assertTrue(Config.getInstance().getForcedKeywords().contains("testForced"));
+        assertTrue(Config.getInstance().getCommentaryKeywords().contains("testCommentary"));
+        assertTrue(Config.getInstance().getPreferredSubtitles().contains("testPreferred"));
+
+        assertNull(Config.getInstance().getConfigPath());
+
+    }
+}

src/test/java/at/pcgamingfreaks/mkvaudiosubtitlechanger/config/validator/PathValidatorTest.java

@@ -20,13 +20,12 @@ import static at.pcgamingfreaks.mkvaudiosubtitlechanger.config.ValidationResult.
 import static at.pcgamingfreaks.mkvaudiosubtitlechanger.config.ValidationResult.INVALID;
 import static at.pcgamingfreaks.mkvaudiosubtitlechanger.model.ConfigProperty.LIBRARY;
 import static at.pcgamingfreaks.mkvaudiosubtitlechanger.util.CommandLineOptionsUtil.optionOf;
+import static at.pcgamingfreaks.mkvaudiosubtitlechanger.util.PathUtils.TEST_DIR;
+import static at.pcgamingfreaks.mkvaudiosubtitlechanger.util.PathUtils.TEST_FILE;
 import static at.pcgamingfreaks.mkvaudiosubtitlechanger.util.TestUtil.argumentsOf;
 import static org.junit.jupiter.api.Assertions.*;
 
 class PathValidatorTest {
-    private static final String TEST_DIR = "src/test/resources/test-dir";
-    private static final String TEST_FILE = "src/test/resources/test-dir/test-file.mkv";
-
     private static CommandLineParser parser;
     private static Options options;
 

src/test/java/at/pcgamingfreaks/mkvaudiosubtitlechanger/model/FileInfoDtoTest.java

@@ -0,0 +1,59 @@
+package at.pcgamingfreaks.mkvaudiosubtitlechanger.model;
+
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+
+import java.util.Set;
+import java.util.stream.Stream;
+
+import static at.pcgamingfreaks.mkvaudiosubtitlechanger.util.TestUtil.createFileInfo;
+import static org.junit.jupiter.api.Assertions.*;
+
+class FileInfoDtoTest {
+    private static final FileAttribute AUDIO_GER_DEFAULT = new FileAttribute(0, "ger", "", true, false, LaneType.AUDIO);
+    private static final FileAttribute AUDIO_GER = new FileAttribute(0, "ger", "", false, false, LaneType.AUDIO);
+    private static final FileAttribute AUDIO_ENG_DEFAULT = new FileAttribute(1, "eng", "", true, false, LaneType.AUDIO);
+    private static final FileAttribute AUDIO_ENG = new FileAttribute(1, "eng", "", false, false, LaneType.AUDIO);
+
+    private static final FileAttribute SUB_GER_DEFAULT = new FileAttribute(0, "ger", "", true, false, LaneType.SUBTITLES);
+    private static final FileAttribute SUB_GER = new FileAttribute(0, "ger", "", false, false, LaneType.SUBTITLES);
+    private static final FileAttribute SUB_ENG_DEFAULT = new FileAttribute(1, "eng", "", true, false, LaneType.SUBTITLES);
+    private static final FileAttribute SUB_ENG = new FileAttribute(1, "eng", "", false, false, LaneType.SUBTITLES);
+
+
+    private static Stream<Arguments> isAudioDifferent() {
+        return Stream.of(
+                Arguments.of(createFileInfo(Set.of(AUDIO_GER_DEFAULT), AUDIO_GER_DEFAULT), false),
+                Arguments.of(createFileInfo(Set.of(AUDIO_GER_DEFAULT), AUDIO_ENG), true),
+                Arguments.of(createFileInfo(Set.of(AUDIO_GER_DEFAULT, AUDIO_ENG_DEFAULT), AUDIO_GER_DEFAULT), true),
+                Arguments.of(createFileInfo(Set.of(), AUDIO_GER), true),
+                Arguments.of(createFileInfo(null, AUDIO_GER), true)
+        );
+    }
+
+    @ParameterizedTest
+    @MethodSource
+    void isAudioDifferent(FileInfoDto underTest, boolean expected) {
+        assertEquals(expected, underTest.isAudioDifferent());
+    }
+
+    private static Stream<Arguments> isSubtitleDifferent() {
+        return Stream.of(
+                Arguments.of(createFileInfo(Set.of(SUB_GER_DEFAULT), SUB_GER_DEFAULT, new AttributeConfig("", "ger")), false),
+                Arguments.of(createFileInfo(Set.of(SUB_GER_DEFAULT), SUB_ENG, new AttributeConfig("", "eng")), true),
+                Arguments.of(createFileInfo(Set.of(SUB_GER_DEFAULT, SUB_ENG_DEFAULT), SUB_ENG, new AttributeConfig("", "eng")), true),
+                Arguments.of(createFileInfo(Set.of(), SUB_ENG, new AttributeConfig("", "ger")), true),
+                Arguments.of(createFileInfo(null, SUB_GER, new AttributeConfig("", "ger")), true),
+                Arguments.of(createFileInfo(null, null, new AttributeConfig("", "OFF")), false),
+                Arguments.of(createFileInfo(Set.of(), null, new AttributeConfig("", "OFF")), false),
+                Arguments.of(createFileInfo(Set.of(SUB_GER_DEFAULT), null, new AttributeConfig("", "OFF")), true)
+            );
+    }
+
+    @ParameterizedTest
+    @MethodSource
+    void isSubtitleDifferent(FileInfoDto underTest, boolean expected) {
+        assertEquals(expected, underTest.isSubtitleDifferent());
+    }
+}

src/test/java/at/pcgamingfreaks/mkvaudiosubtitlechanger/util/DateUtilsTest.java

@@ -0,0 +1,21 @@
+package at.pcgamingfreaks.mkvaudiosubtitlechanger.util;
+
+import org.junit.jupiter.api.Test;
+
+import java.util.Date;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class DateUtilsTest {
+
+    @Test
+    void convert() {
+        Date expectedDate = new Date(0);
+        String expectedString = "01.01.1970-01:00:00";
+
+        assertEquals(expectedDate, DateUtils.convert(0));
+        assertEquals(expectedDate, DateUtils.convert(expectedString, expectedDate));
+        assertEquals(expectedDate, DateUtils.convert("1234;15", expectedDate));
+        assertEquals(expectedString, DateUtils.convert(expectedDate));
+    }
+}

src/test/java/at/pcgamingfreaks/mkvaudiosubtitlechanger/util/PathUtils.java

@@ -0,0 +1,6 @@
+package at.pcgamingfreaks.mkvaudiosubtitlechanger.util;
+
+public class PathUtils {
+    public static final String TEST_DIR = "src/test/resources/test-dir";
+    public static final String TEST_FILE = "src/test/resources/test-dir/test-file.mkv";
+}

src/test/java/at/pcgamingfreaks/mkvaudiosubtitlechanger/util/SetUtilsTest.java

@@ -0,0 +1,20 @@
+package at.pcgamingfreaks.mkvaudiosubtitlechanger.util;
+
+import org.junit.jupiter.api.Test;
+
+import java.util.List;
+import java.util.Set;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class SetUtilsTest {
+
+    @Test
+    void retainOf() {
+        List<Integer> list1 = List.of(1, 2, 3, 4, 5);
+        List<Integer> list2 = List.of(2, 4, 6, 8, 10);
+        Set<Integer> expected = Set.of(2, 4);
+
+        assertEquals(expected, SetUtils.retainOf(list1, list2));
+    }
+}

src/test/java/at/pcgamingfreaks/mkvaudiosubtitlechanger/util/TestUtil.java

@@ -1,10 +1,14 @@
 package at.pcgamingfreaks.mkvaudiosubtitlechanger.util;
 
 import at.pcgamingfreaks.mkvaudiosubtitlechanger.config.ValidationResult;
+import at.pcgamingfreaks.mkvaudiosubtitlechanger.model.AttributeConfig;
 import at.pcgamingfreaks.mkvaudiosubtitlechanger.model.ConfigProperty;
+import at.pcgamingfreaks.mkvaudiosubtitlechanger.model.FileAttribute;
+import at.pcgamingfreaks.mkvaudiosubtitlechanger.model.FileInfoDto;
 import org.junit.jupiter.params.provider.Arguments;
 
 import java.util.Arrays;
+import java.util.Set;
 
 import static java.util.stream.Collectors.joining;
 
@@ -25,4 +29,18 @@ public class TestUtil {
         return Arguments.of(property, required, append, yaml, cmd, result, expectedSize);
     }
 
+    public static FileInfoDto createFileInfo(Set<FileAttribute> defaultAudio, FileAttribute desiredAudio) {
+        FileInfoDto fileInfoDto = new FileInfoDto(null);
+        fileInfoDto.setExistingDefaultAudioLanes(defaultAudio);
+        fileInfoDto.setDesiredDefaultAudioLane(desiredAudio);
+        return fileInfoDto;
+    }
+
+    public static FileInfoDto createFileInfo(Set<FileAttribute> defaultSubtitle, FileAttribute desiredSubtitle, AttributeConfig config) {
+        FileInfoDto fileInfoDto = new FileInfoDto(null);
+        fileInfoDto.setExistingDefaultSubtitleLanes(defaultSubtitle);
+        fileInfoDto.setDesiredDefaultSubtitleLane(desiredSubtitle);
+        fileInfoDto.setMatchedConfig(config);
+        return fileInfoDto;
+    }
 }