Return live thumbnail URL from playback API

Author: mjh1

packages/api/src/controllers/clip.ts

@@ -130,7 +130,11 @@ app.post("/", validatePost("clip-payload"), async (req, res) => {
           "The provided session id does not belong to this stream"
         );
       }
-      ({ url, objectStoreId } = await buildRecordingUrl(session, req));
+      ({ url, objectStoreId } = await buildRecordingUrl(
+        session,
+        req.config.recordCatalystObjectStoreId,
+        req.config.secondaryRecordObjectStoreId
+      ));
     } else {
       ({ url, session, objectStoreId } = await getRunningRecording(
         content,

packages/api/src/controllers/playback.ts

@@ -40,7 +40,8 @@ function newPlaybackInfo(
   staticFilesPlaybackInfo?: StaticPlaybackInfo[],
   live?: PlaybackInfo["meta"]["live"],
   recordingUrl?: string,
-  withRecordings?: boolean
+  withRecordings?: boolean,
+  thumbUrl?: string
 ): PlaybackInfo {
   let playbackInfo: PlaybackInfo = {
     type,
@@ -89,6 +90,13 @@ function newPlaybackInfo(
       });
     }
   }
+  if (thumbUrl) {
+    playbackInfo.meta.source.push({
+      hrn: "Thumbnail",
+      type: "image/jpeg",
+      url: thumbUrl,
+    });
+  }
 
   return playbackInfo;
 }
@@ -226,10 +234,13 @@ async function getPlaybackInfo(
   }
 
   if (stream) {
+    const thumbsEnabled = await isExperimentSubject("live-thumbs", req.user.id);
     let url: string;
-    if (withRecordings) {
-      ({ url } = await getRunningRecording(stream, req));
+    let thumbUrl: string;
+    if (withRecordings || thumbsEnabled) {
+      ({ url, thumbUrl } = await getRunningRecording(stream, req));
     }
+
     return newPlaybackInfo(
       "live",
       getHLSPlaybackUrl(ingest, stream),
@@ -238,7 +249,8 @@ async function getPlaybackInfo(
       null,
       stream.isActive ? 1 : 0,
       url,
-      withRecordings
+      withRecordings,
+      thumbsEnabled && thumbUrl
     );
   }
 

packages/api/src/controllers/session.ts

@@ -158,7 +158,11 @@ app.get("/:id", authorizer({}), async (req, res) => {
   let originalRecordingUrl: string | null = null;
 
   if (req.query.sourceRecording === "true") {
-    const { url } = await buildRecordingUrl(session, req);
+    const { url } = await buildRecordingUrl(
+      session,
+      req.config.recordCatalystObjectStoreId,
+      req.config.secondaryRecordObjectStoreId
+    );
     originalRecordingUrl = url;
     session.sourceRecordingUrl = originalRecordingUrl;
   }
@@ -230,56 +234,58 @@ export async function getRunningRecording(content: DBStream, req: Request) {
     };
   }
 
-  return await buildRecordingUrl(session, req);
+  return await buildRecordingUrl(
+    session,
+    req.config.recordCatalystObjectStoreId,
+    req.config.secondaryRecordObjectStoreId
+  );
 }
 
-export async function buildRecordingUrl(session: DBSession, req: Request) {
-  let objectStoreId: string;
-  const os = await db.objectStore.get(req.config.recordCatalystObjectStoreId);
+export async function buildRecordingUrl(
+  session: DBSession,
+  recordCatalystObjectStoreId: string,
+  secondaryRecordObjectStoreId: string
+) {
+  const os = await db.objectStore.get(recordCatalystObjectStoreId);
 
-  let url = pathJoin(
-    os.publicUrl,
-    session.playbackId,
-    session.id,
-    "output.m3u8"
-  );
+  let urlPrefix = pathJoin(os.publicUrl, session.playbackId, session.id);
+  let manifestUrl = pathJoin(urlPrefix, "output.m3u8");
 
   let params = {
     method: "HEAD",
     timeout: 5 * 1000,
   };
-  let resp = await fetchWithTimeout(url, params);
+  let resp = await fetchWithTimeout(manifestUrl, params);
+  if (resp.status == 200) {
+    return {
+      url: manifestUrl,
+      session,
+      objectStoreId: recordCatalystObjectStoreId,
+      thumbUrl: pathJoin(urlPrefix, "source", "latest.jpg"),
+    };
+  }
 
-  if (resp.status != 200) {
-    const secondaryOs = req.config.secondaryRecordObjectStoreId
-      ? await db.objectStore.get(req.config.secondaryRecordObjectStoreId)
-      : undefined;
-    url = pathJoin(
-      secondaryOs.publicUrl,
-      session.playbackId,
-      session.id,
-      "output.m3u8"
-    );
+  const secondaryOs = await db.objectStore.get(secondaryRecordObjectStoreId);
+  urlPrefix = pathJoin(secondaryOs.publicUrl, session.playbackId, session.id);
+  manifestUrl = pathJoin(urlPrefix, "output.m3u8");
 
-    objectStoreId = req.config.secondaryRecordObjectStoreId;
+  const objectStoreId = secondaryRecordObjectStoreId;
 
-    resp = await fetchWithTimeout(url, params);
+  resp = await fetchWithTimeout(manifestUrl, params);
 
-    if (resp.status != 200) {
-      return {
-        url: null,
-        session,
-        objectStoreId,
-      };
-    }
-  } else {
-    objectStoreId = req.config.recordCatalystObjectStoreId;
+  if (resp.status != 200) {
+    return {
+      url: null,
+      session,
+      objectStoreId,
+    };
   }
 
   return {
-    url,
+    url: manifestUrl,
     session,
     objectStoreId,
+    thumbUrl: pathJoin(urlPrefix, "source", "latest.jpg"),
   };
 }
 export default app;

packages/api/src/schema/api-schema.yaml

@@ -2094,13 +2094,15 @@ components:
                       - HLS (TS)
                       - MP4
                       - WebRTC (H264)
+                      - Thumbnail
                   type:
                     type: string
                     example: html5/video/mp4
                     enum:
                       - html5/application/vnd.apple.mpegurl
                       - html5/video/mp4
                       - html5/video/h264
+                      - image/jpeg
                   url:
                     type: string
                     example: >-

packages/api/src/webhooks/cannon.ts

@@ -19,6 +19,7 @@ import { DBStream } from "../store/stream-table";
 import { USER_SESSION_TIMEOUT } from "../controllers/stream";
 import { BadRequestError, UnprocessableEntityError } from "../store/errors";
 import { db } from "../store";
+import { buildRecordingUrl } from "../controllers/session";
 
 const WEBHOOK_TIMEOUT = 5 * 1000;
 const MAX_BACKOFF = 60 * 60 * 1000;
@@ -562,35 +563,12 @@ export default class WebhookCannon {
         this.queue
       );
 
-      const os = await db.objectStore.get(this.recordCatalystObjectStoreId);
-      // we can't rate limit this task because it's not a user action
-      let url = pathJoin(
-        os.publicUrl,
-        session.playbackId,
-        session.id,
-        "output.m3u8"
+      const { url } = await buildRecordingUrl(
+        session,
+        this.recordCatalystObjectStoreId,
+        this.secondaryRecordObjectStoreId
       );
 
-      const secondaryOs = this.secondaryRecordObjectStoreId
-        ? await db.objectStore.get(this.secondaryRecordObjectStoreId)
-        : undefined;
-      if (secondaryOs) {
-        let params = {
-          method: "HEAD",
-          timeout: 5 * 1000,
-        };
-        const resp = await fetchWithTimeout(url, params);
-
-        if (resp.status != 200) {
-          url = pathJoin(
-            secondaryOs.publicUrl,
-            session.playbackId,
-            session.id,
-            "output.m3u8"
-          );
-        }
-      }
-
       await taskScheduler.createAndScheduleTask(
         "upload",
         {