[SoundCloud] Refactor Soundcloud audio stream extraction code to separate building Hls and Progressive streams

Add HlsAudioStream to facilitate refreshing expired Hls playlists

Author: absurdlylongusername

extractor/src/main/java/org/schabi/newpipe/extractor/services/soundcloud/extractors/SoundcloudStreamExtractor.java

@@ -11,12 +11,9 @@
 
 import com.grack.nanojson.JsonArray;
 import com.grack.nanojson.JsonObject;
-import com.grack.nanojson.JsonParser;
-import com.grack.nanojson.JsonParserException;
 
 import org.schabi.newpipe.extractor.Image;
 import org.schabi.newpipe.extractor.MediaFormat;
-import org.schabi.newpipe.extractor.NewPipe;
 import org.schabi.newpipe.extractor.StreamingService;
 import org.schabi.newpipe.extractor.downloader.Downloader;
 import org.schabi.newpipe.extractor.exceptions.ContentNotAvailableException;
@@ -30,6 +27,8 @@
 import org.schabi.newpipe.extractor.stream.AudioStream;
 import org.schabi.newpipe.extractor.stream.DeliveryMethod;
 import org.schabi.newpipe.extractor.stream.Description;
+import org.schabi.newpipe.extractor.stream.HlsAudioStream;
+import org.schabi.newpipe.extractor.stream.SoundcloudHlsUtils;
 import org.schabi.newpipe.extractor.stream.Stream;
 import org.schabi.newpipe.extractor.stream.StreamExtractor;
 import org.schabi.newpipe.extractor.stream.StreamInfoItemsCollector;
@@ -189,25 +188,106 @@ public List<AudioStream> getAudioStreams() throws ExtractionException {
         return audioStreams;
     }
 
-    @Nonnull
-    private String getTranscodingUrl(final String endpointUrl)
-            throws IOException, ExtractionException {
-        String apiStreamUrl = endpointUrl + "?client_id=" + clientId();
+    // TODO: put this somewhere better
+    /**
+     * Constructs the API endpoint url for this track that will be called to get the url
+     * for retrieving the actual byte data for playback
+     * (e.g. the actual url could be an m3u8 playlist)
+     * @param baseUrl The baseUrl needed to construct the full url
+     * @return The full API endpoint url to call to get the actual playback url
+     * @throws IOException If there is a problem getting clientId
+     * @throws ExtractionException For the same reason
+     */
+    private String getApiStreamUrl(final String baseUrl) throws ExtractionException, IOException {
+        String apiStreamUrl = baseUrl + "?client_id=" + clientId();
 
         final String trackAuthorization = track.getString("track_authorization");
         if (!isNullOrEmpty(trackAuthorization)) {
             apiStreamUrl += "&track_authorization=" + trackAuthorization;
         }
+        return apiStreamUrl;
+    }
 
-        final String response = NewPipe.getDownloader().get(apiStreamUrl).responseBody();
-        final JsonObject urlObject;
-        try {
-            urlObject = JsonParser.object().from(response);
-        } catch (final JsonParserException e) {
-            throw new ParsingException("Could not parse streamable URL", e);
+    public static final class StreamBuildResult {
+        public final String contentUrl;
+        public final MediaFormat mediaFormat;
+
+        public StreamBuildResult(final String contentUrl, final MediaFormat mediaFormat) {
+            this.contentUrl = contentUrl;
+            this.mediaFormat = mediaFormat;
+        }
+
+        @Override
+        public String toString() {
+            return "StreamBuildResult{"
+                   + "contentUrl='" + contentUrl + '\''
+                   + ", mediaFormat=" + mediaFormat
+                   + '}';
+        }
+    }
+
+    /**
+     * Builds the common audio stream components for all SoundCloud audio streams<p>
+     * Returns the stream content url if we support this type of transcoding, {@code null} otherwise
+     * @param transcoding The SoundCloud JSON transcoding object for this stream
+     * @param builder AudioStream builder to set the common values
+     * @return the stream content url if this transcoding is supported and common values were built
+     * {@code null} otherwise
+     */
+    @Nullable
+    private StreamBuildResult buildBaseAudioStream(final JsonObject transcoding,
+                                                   final AudioStream.Builder builder)
+        throws ExtractionException, IOException {
+        ExtractorLogger.d(TAG,  getName() + " Building base audio stream info");
+        final var preset = transcoding.getString("preset", ID_UNKNOWN);
+        final MediaFormat mediaFormat;
+        if (preset.contains("mp3")) {
+            mediaFormat = MediaFormat.MP3;
+            builder.setAverageBitrate(128);
+        } else if (preset.contains("opus")) {
+            mediaFormat = MediaFormat.OPUS;
+            builder.setAverageBitrate(64);
+            builder.setDeliveryMethod(DeliveryMethod.HLS);
+        } else if (preset.contains("aac_160k")) {
+            mediaFormat = MediaFormat.M4A;
+            builder.setAverageBitrate(160);
+        } else {
+            // Unknown format, return null to skip to the next audio stream
+            return null;
         }
 
-        return urlObject.getString("url");
+        builder.setMediaFormat(mediaFormat);
+
+        builder.setId(preset);
+        final var url = transcoding.getString("url");
+        final var hlsPlaylistUrl = SoundcloudHlsUtils.getStreamContentUrl(getApiStreamUrl(url));
+        builder.setContent(hlsPlaylistUrl, true);
+        return new StreamBuildResult(hlsPlaylistUrl, mediaFormat);
+    }
+
+    private HlsAudioStream buildHlsAudioStream(final JsonObject transcoding)
+            throws ExtractionException, IOException {
+        ExtractorLogger.d(TAG, getName() + "Extracting hls audio stream");
+        final var builder = new HlsAudioStream.Builder();
+        final StreamBuildResult buildResult = buildBaseAudioStream(transcoding, builder);
+        if (buildResult == null) {
+            return null;
+        }
+
+        builder.setApiStreamUrl(getApiStreamUrl(transcoding.getString("url")));
+        builder.setPlaylistId(SoundcloudHlsUtils.extractHlsPlaylistId(buildResult.contentUrl,
+                                                            buildResult.mediaFormat));
+
+        return builder.build();
+    }
+
+    private AudioStream buildProgressiveAudioStream(final JsonObject transcoding)
+            throws ExtractionException, IOException {
+        ExtractorLogger.d(TAG, getName() + "Extracting progressive audio stream");
+        final var builder = new AudioStream.Builder();
+        final StreamBuildResult buildResult = buildBaseAudioStream(transcoding, builder);
+        return buildResult == null ? null : builder.build();
+        // TODO: anything else?
     }
 
     private void extractAudioStreams(@Nonnull final JsonArray transcodings,
@@ -221,47 +301,35 @@ private void extractAudioStreams(@Nonnull final JsonArray transcodings,
                         return;
                     }
 
-                    try {
-                        final String preset = transcoding.getString("preset", ID_UNKNOWN);
-                        final String protocol = transcoding.getObject("format")
-                                .getString("protocol");
-
-                        if (protocol.contains("encrypted")) {
-                            // Skip DRM-protected streams, which have encrypted in their protocol
-                            // name
-                            return;
-                        }
-
-                        final AudioStream.Builder builder = new AudioStream.Builder()
-                                .setId(preset);
+                    final String protocol = transcoding.getObject("format")
+                            .getString("protocol");
 
-                        if (protocol.equals("hls")) {
-                            builder.setDeliveryMethod(DeliveryMethod.HLS);
-                        }
-
-                        builder.setContent(getTranscodingUrl(url), true);
-
-                        if (preset.contains("mp3")) {
-                            builder.setMediaFormat(MediaFormat.MP3);
-                            builder.setAverageBitrate(128);
-                        } else if (preset.contains("opus")) {
-                            builder.setMediaFormat(MediaFormat.OPUS);
-                            builder.setAverageBitrate(64);
-                        } else if (preset.contains("aac_160k")) {
-                            builder.setMediaFormat(MediaFormat.M4A);
-                            builder.setAverageBitrate(160);
-                        } else {
-                            // Unknown format, skip to the next audio stream
-                            return;
-                        }
+                    if (protocol.contains("encrypted")) {
+                        // Skip DRM-protected streams, which have encrypted in their protocol
+                        // name
+                        return;
+                    }
 
-                        final AudioStream audioStream = builder.build();
-                        if (!Stream.containSimilarStream(audioStream, audioStreams)) {
+                    final AudioStream audioStream;
+                    try {
+                        // SoundCloud only has one progressive stream, the rest are HLS
+                        audioStream = protocol.equals("hls")
+                                ? buildHlsAudioStream(transcoding)
+                                : buildProgressiveAudioStream(transcoding);
+                        if (audioStream != null
+                            && !Stream.containSimilarStream(audioStream, audioStreams)) {
+                            ExtractorLogger.d(TAG, audioStream.getFormat().getName() + " "
+                                                + getName() + " " + audioStream.getContent());
                             audioStreams.add(audioStream);
                         }
-                    } catch (final ExtractionException | IOException ignored) {
+                    } catch (final ExtractionException | IOException e) {
                         // Something went wrong when trying to get and add this audio stream,
                         // skip to the next one
+                        final var preset = transcoding.getString("preset", "unknown");
+                        ExtractorLogger.e(TAG,
+                                     getName() + " Failed to extract audio stream for transcoding "
+                                          + '[' + protocol + '/' + preset + "] " + url,
+                                          e);
                     }
                 });
     }

extractor/src/main/java/org/schabi/newpipe/extractor/stream/AudioStream.java

@@ -28,7 +28,7 @@
 import java.util.Locale;
 import java.util.Objects;
 
-public final class AudioStream extends Stream {
+public class AudioStream extends Stream {
     public static final int UNKNOWN_BITRATE = -1;
 
     private final int averageBitrate;
@@ -60,7 +60,7 @@ public final class AudioStream extends Stream {
      * Class to build {@link AudioStream} objects.
      */
     @SuppressWarnings("checkstyle:hiddenField")
-    public static final class Builder {
+    public static class Builder {
         private String id;
         private String content;
         private boolean isUrl;

extractor/src/main/java/org/schabi/newpipe/extractor/stream/HlsAudioStream.java

@@ -0,0 +1,60 @@
+package org.schabi.newpipe.extractor.stream;
+
+import org.schabi.newpipe.extractor.exceptions.ExtractionException;
+
+import java.io.IOException;
+
+import javax.annotation.Nonnull;
+
+public class HlsAudioStream extends AudioStream implements RefreshableStream {
+    private final String apiStreamUrl;
+    private final String playlistId;
+
+    HlsAudioStream(final Builder builder) {
+        super(builder);
+        apiStreamUrl = builder.apiStreamUrl;
+        playlistId = builder.playlistId;
+    }
+
+    @Nonnull
+    public String fetchLatestUrl() throws IOException, ExtractionException {
+        return SoundcloudHlsUtils.getStreamContentUrl(apiStreamUrl);
+    }
+
+    @Nonnull
+    public String initialUrl() {
+        return getContent();
+    }
+
+    @Override
+    public String playlistId() {
+        return playlistId;
+    }
+
+    @SuppressWarnings({"checkstyle:HiddenField", "UnusedReturnValue"})
+    public static class Builder extends AudioStream.Builder {
+        private String apiStreamUrl;
+        private String playlistId;
+
+        public Builder() {
+            setDeliveryMethod(DeliveryMethod.HLS);
+        }
+
+        @Override
+        @Nonnull
+        public HlsAudioStream build() {
+            validateBuild();
+            return new HlsAudioStream(this);
+        }
+
+        public Builder setApiStreamUrl(@Nonnull final String apiStreamUrl) {
+            this.apiStreamUrl = apiStreamUrl;
+            return this;
+        }
+
+        public Builder setPlaylistId(@Nonnull final String playlistId) {
+            this.playlistId = playlistId;
+            return this;
+        }
+    }
+}

extractor/src/main/java/org/schabi/newpipe/extractor/stream/RefreshableStream.java

@@ -0,0 +1,15 @@
+package org.schabi.newpipe.extractor.stream;
+
+import org.schabi.newpipe.extractor.exceptions.ExtractionException;
+
+import javax.annotation.Nonnull;
+import java.io.IOException;
+
+@SuppressWarnings("checkstyle:LeftCurly")
+public interface RefreshableStream  {
+    @Nonnull
+    String fetchLatestUrl() throws IOException, ExtractionException;
+    String initialUrl();
+
+    String playlistId();
+}

extractor/src/main/java/org/schabi/newpipe/extractor/stream/SoundcloudHlsUtils.java

@@ -0,0 +1,90 @@
+package org.schabi.newpipe.extractor.stream;
+
+import com.grack.nanojson.JsonObject;
+import com.grack.nanojson.JsonParser;
+import com.grack.nanojson.JsonParserException;
+
+import org.schabi.newpipe.extractor.MediaFormat;
+import org.schabi.newpipe.extractor.NewPipe;
+import org.schabi.newpipe.extractor.exceptions.ExtractionException;
+import org.schabi.newpipe.extractor.exceptions.ParsingException;
+import org.schabi.newpipe.extractor.utils.ExtractorLogger;
+import org.schabi.newpipe.extractor.utils.Parser;
+
+import java.io.IOException;
+import java.util.regex.Pattern;
+
+import javax.annotation.Nonnull;
+
+public final class SoundcloudHlsUtils {
+    private static final String TAG = HlsAudioStream.class.getSimpleName();
+    private static final Pattern MP3_HLS_PATTERN =
+            Pattern.compile("https://cf-hls-media\\.sndcdn.com/playlist/"
+                            + "([a-zA-Z0-9]+)\\.128\\.mp3/playlist\\.m3u8");
+    private static final Pattern AAC_HLS_PATTERN =
+            Pattern.compile("https://playback\\.media-streaming\\.soundcloud\\.cloud/"
+                            + "([a-zA-Z0-9]+)/aac_160k/[a-f0-9\\-]+/playlist\\.m3u8");
+    private static final Pattern OPUS_HLS_PATTERN =
+            Pattern.compile("https://cf-hls-opus-media\\.sndcdn\\.com/"
+                            + "playlist/([a-zA-Z0-9]+)\\.64\\.opus/playlist\\.m3u8");
+
+    private SoundcloudHlsUtils() { }
+
+    /**
+     * Calls the API endpoint url for this stream to get the url for retrieving the
+     * actual byte data for playback (returns the m3u8 playlist url for HLS streams,
+     * and the url to get the full binary track for progressives streams)<p>
+     *
+     * NOTE: this returns a different url every time! (for SoundCloud)
+     * @param apiStreamUrl The url to call to get the actual stream data url
+     * @return The url for playing the audio (e.g. playlist.m3u8)
+     * @throws IOException If there's a problem calling the endpoint
+     * @throws ExtractionException for the same reason
+     */
+    public static String getStreamContentUrl(final String apiStreamUrl)
+            throws IOException, ExtractionException {
+        ExtractorLogger.d(TAG, "Fetching content url for " + apiStreamUrl);
+        final String response = NewPipe.getDownloader()
+                                       .get(apiStreamUrl)
+                                       .validateResponseCode()
+                                       .responseBody();
+        final JsonObject urlObject;
+        try {
+            urlObject = JsonParser.object().from(response);
+        } catch (final JsonParserException e) {
+            // TODO: Improve error message.
+            throw new ParsingException("Could not parse stream content from URL ("
+                                       + response + ")", e);
+        }
+
+        return urlObject.getString("url");
+    }
+
+    @Nonnull
+    public static String extractHlsPlaylistId(final String hlsPlaylistUrl,
+                                              final MediaFormat mediaFormat)
+            throws ExtractionException {
+        switch (mediaFormat) {
+            case MP3: return extractHlsMp3PlaylistId(hlsPlaylistUrl);
+            case M4A: return extractHlsAacPlaylistId(hlsPlaylistUrl);
+            case OPUS: return extractHlsOpusPlaylistId(hlsPlaylistUrl);
+            default:
+                    throw new IllegalArgumentException("Unsupported media format: " + mediaFormat);
+        }
+    }
+
+    private static String extractHlsMp3PlaylistId(final String hlsPlaylistUrl)
+            throws ExtractionException {
+        return Parser.matchGroup1(MP3_HLS_PATTERN, hlsPlaylistUrl);
+    }
+
+    private static String extractHlsAacPlaylistId(final String hlsPlaylistUrl)
+            throws ExtractionException {
+        return Parser.matchGroup1(AAC_HLS_PATTERN, hlsPlaylistUrl);
+    }
+
+    private static String extractHlsOpusPlaylistId(final String hlsPlaylistUrl)
+            throws ExtractionException {
+        return Parser.matchGroup1(OPUS_HLS_PATTERN, hlsPlaylistUrl);
+    }
+}