Fix TranscoderOption accessing data source without initialization

Author: natario1

lib/src/main/java/com/otaliastudios/transcoder/ThumbnailerOptions.kt

@@ -0,0 +1,15 @@
+package com.otaliastudios.transcoder
+
+import com.otaliastudios.transcoder.source.DataSource
+
+class ThumbnailerOptions {
+
+    class Builder {
+
+        private val dataSources = mutableListOf<DataSource>()
+
+        fun addDataSource()
+
+        fun build() = ThumbnailerOptions()
+    }
+}

lib/src/main/java/com/otaliastudios/transcoder/TranscoderOptions.java

@@ -334,42 +334,6 @@ public Builder setAudioResampler(@NonNull AudioResampler audioResampler) {
             return this;
         }
 
-        /**
-         * Generates muted audio data sources if needed
-         * @return The list of audio data sources including the muted sources
-         */
-        private List<DataSource> buildAudioDataSources()
-        {
-            // Check if we have a mix of empty and non-empty data sources
-            // This would cause an error in Engine::computeTrackStatus
-            boolean hasMissingAudioDataSources = false;
-            boolean hasAudioDataSources = false;
-            boolean hasValidAudioDataSources = true;
-            for (DataSource dataSource : audioDataSources) {
-                if (dataSource.getTrackFormat(TrackType.AUDIO) == null) {
-                    hasMissingAudioDataSources = true;
-                } else {
-                    hasAudioDataSources = true;
-                }
-                if (hasAudioDataSources && hasMissingAudioDataSources) {
-                    hasValidAudioDataSources = false;
-                    break;
-                }
-            }
-            if (hasValidAudioDataSources) {
-                return audioDataSources;
-            }
-            // Fix the audioDataSources by replacing the empty data source by muted data source
-            List<DataSource> result = new ArrayList<>();
-            for (DataSource dataSource : audioDataSources) {
-                if (dataSource.getTrackFormat(TrackType.AUDIO) != null) {
-                    result.add(dataSource);
-                } else {
-                    result.add(new BlankAudioDataSource(dataSource.getDurationUs()));
-                }
-            }
-            return result;
-        }
 
         @NonNull
         public TranscoderOptions build() {
@@ -407,7 +371,7 @@ public TranscoderOptions build() {
             }
             TranscoderOptions options = new TranscoderOptions();
             options.listener = listener;
-            options.audioDataSources = buildAudioDataSources();
+            options.audioDataSources = audioDataSources;
             options.videoDataSources = videoDataSources;
             options.dataSink = dataSink;
             options.listenerHandler = listenerHandler;

lib/src/main/java/com/otaliastudios/transcoder/internal/DataSources.kt

@@ -5,18 +5,51 @@ import com.otaliastudios.transcoder.common.TrackType
 import com.otaliastudios.transcoder.internal.utils.Logger
 import com.otaliastudios.transcoder.internal.utils.TrackMap
 import com.otaliastudios.transcoder.internal.utils.trackMapOf
+import com.otaliastudios.transcoder.source.BlankAudioDataSource
 import com.otaliastudios.transcoder.source.DataSource
 
 internal class DataSources private constructor(
-        private val videoSources: List<DataSource>,
-        private val audioSources: List<DataSource>,
+        videoSources: List<DataSource>,
+        audioSources: List<DataSource>,
 ) : TrackMap<List<DataSource>> {
 
     constructor(options: TranscoderOptions) : this(options.videoDataSources, options.audioDataSources)
 
     private val log = Logger("DataSources")
 
-    fun all() = (audio + video).distinct()
+    private fun DataSource.init() = if (!isInitialized) initialize() else Unit
+    private fun DataSource.deinit() = if (isInitialized) deinitialize() else Unit
+    private fun List<DataSource>.init() = forEach { it.init() }
+    private fun List<DataSource>.deinit() = forEach { it.deinit() }
+
+    init {
+        videoSources.init()
+        audioSources.init()
+    }
+
+    private val videoSources: List<DataSource> = run {
+        val valid = videoSources.count { it.getTrackFormat(TrackType.VIDEO) != null }
+        when (valid) {
+            0 -> listOf<DataSource>().also { videoSources.deinit() }
+            videoSources.size -> videoSources
+            else -> videoSources // Tracks will crash
+        }
+    }
+
+    private val audioSources: List<DataSource> = run {
+        val valid = audioSources.count { it.getTrackFormat(TrackType.AUDIO) != null }
+        when (valid) {
+            0 -> listOf<DataSource>().also { audioSources.deinit() }
+            audioSources.size -> audioSources
+            else -> {
+                // Some tracks do not have audio, while some do. Replace with BlankAudio.
+                audioSources.map { source ->
+                    if (source.getTrackFormat(TrackType.AUDIO) != null) source
+                    else BlankAudioDataSource(source.durationUs).also { source.deinit() }
+                }
+            }
+        }
+    }
 
     override fun get(type: TrackType) = when (type) {
         TrackType.AUDIO -> audioSources
@@ -25,25 +58,12 @@ internal class DataSources private constructor(
 
     override fun has(type: TrackType) = this[type].isNotEmpty()
 
-    init {
-        log.i("Initializing...")
-        all().forEach {
-            log.v("Initializing source $it...")
-            if (!it.isInitialized) {
-                it.initialize()
-            }
-        }
-        log.i("Initialized.")
-    }
+    fun all() = (audio + video).distinct()
 
     fun release() {
         log.i("release(): releasing...")
-        all().forEach {
-            log.i("release(): releasing source $it...")
-            if (it.isInitialized) {
-                it.deinitialize()
-            }
-        }
+        video.forEach { it.deinit() }
+        audio.forEach { it.deinit() }
         log.i("release(): released.")
     }
 }

lib/src/main/java/com/otaliastudios/transcoder/internal/Tracks.kt

@@ -50,27 +50,26 @@ internal class Tracks(
             strategy: TrackStrategy,
             sources: List<DataSource>? // null or not-empty
     ): Pair<MediaFormat, TrackStatus> {
-        return if (sources == null) {
-            MediaFormat() to TrackStatus.ABSENT
-        } else {
-            var status = TrackStatus.ABSENT
-            val outputFormat = MediaFormat()
-            val provider = MediaFormatProvider()
-            val inputFormats = sources.mapNotNull {
-                val format = it.getTrackFormat(type)
-                format?.run { it to this }
-            }.map { (source, format) ->
-                provider.provideMediaFormat(source, type, format)
-            }
-            if (inputFormats.size == sources.size) {
-                status = strategy.createOutputFormat(inputFormats, outputFormat)
-            } else {
-                require(inputFormats.isEmpty()) {
-                    "getTrackFormat returned null for ${sources.size - inputFormats.size}" +
-                            "/${sources.size} sources of type $type"
-                }
+        if (sources == null) {
+            return MediaFormat() to TrackStatus.ABSENT
+        }
+
+        val provider = MediaFormatProvider()
+        val inputs = sources.mapNotNull {
+            val format = it.getTrackFormat(type) ?: return@mapNotNull null
+            provider.provideMediaFormat(it, type, format)
+        }
+
+        // The DataSources class already tries to address this for audio, by inserting
+        // a BlankAudioDataSource. However we still don't have a solution for video.
+        return when (inputs.size) {
+            0 -> MediaFormat() to TrackStatus.ABSENT
+            sources.size -> {
+                val output = MediaFormat()
+                val status = strategy.createOutputFormat(inputs, output)
+                output to status
             }
-            outputFormat to status
+            else -> error("Of all $type sources, some have a $type track, some don't.")
         }
     }
 }