From e4fe46c4a7ae4e0ee6cc65db2da3eee6e22f407c Mon Sep 17 00:00:00 2001
From: Luca Armaroli <lukaarma@gmail.com>
Date: Fri, 15 Oct 2021 22:33:53 +0200
Subject: [PATCH] SharePoint download video via DASH manifest

---
 src/ApiClient.ts    | 30 ++++++++++----
 src/Downloaders.ts  | 97 ++++++++++++++++++++++++++++++++++++++++++++-
 src/LoginModules.ts |  9 ++---
 src/Utils.ts        |  4 +-
 src/VideoUtils.ts   | 23 +++++++----
 5 files changed, 140 insertions(+), 23 deletions(-)

diff --git a/src/ApiClient.ts b/src/ApiClient.ts
index fb99856..1bd4af7 100644
--- a/src/ApiClient.ts
+++ b/src/ApiClient.ts
@@ -161,7 +161,7 @@ export class ShareApiClient {
     }
 
 
-    public async getVideoInfo(filePath: string, outDir: string): Promise<Video> {
+    public async getVideoInfo(filePath: string, outPath: string): Promise<Video> {
         let playbackUrl: string;
 
         // TODO: Ripped this straigth from chromium inspector. Don't know don't care what it is right now. Check later
@@ -193,27 +193,43 @@ export class ShareApiClient {
         }
 
         const direct = await this.canDirectDownload(filePath);
+        const b64VideoMetadata = JSON.parse(
+            info.ListData.Row[0].MediaServiceFastMetadata
+        ).video.altManifestMetadata;
+        const durationSeconds = Math.ceil(
+            (JSON.parse(
+                Buffer.from(b64VideoMetadata, 'base64').toString()
+            ).Duration100Nano) / 10 / 1000 / 1000
+        );
 
         if (direct) {
-            playbackUrl = this.axiosInstance.getUri({ url: filePath });
+            playbackUrl = this.axiosInstance.defaults.baseURL + filePath;
+            // logger.verbose(playbackUrl);
         }
         else {
-            playbackUrl = 'placeholder';
+            playbackUrl = info.ListSchema['.videoManifestUrl'];
+            playbackUrl = playbackUrl.replace('{.mediaBaseUrl}', info.ListSchema['.mediaBaseUrl']);
+            // the only filetype works I found
+            playbackUrl = playbackUrl.replace('{.fileType}', 'mp4');
+            playbackUrl = playbackUrl.replace('{.callerStack}', info.ListSchema['.callerStack']);
+            playbackUrl = playbackUrl.replace('{.spItemUrl}', info.ListData.Row[0]['.spItemUrl']);
+            playbackUrl = playbackUrl.replace('{.driveAccessToken}', info.ListSchema['.driveAccessToken']);
+            playbackUrl += '&part=index&format=dash';
         }
 
 
         return {
             direct,
             title: filePath.split('/').pop() ?? 'video.mp4',
-            duration: '',
+            duration: publishedTimeToString(durationSeconds),
             publishDate: publishedDateToString(info.ListData.Row[0]['Modified.']),
             publishTime: publishedTimeToString(info.ListData.Row[0]['Modified.']),
             author: info.ListData.Row[0]['Author.title'],
             authorEmail: info.ListData.Row[0]['Author.email'],
-            uniqueId: info.ListData.Row[0]['GUID'].substring(1, 9),
-            outPath: outDir,
+            uniqueId: info.ListData.Row[0].GUID.substring(1, 9),
+            outPath,
             playbackUrl,
-            totalChunks: 0
+            totalChunks: durationSeconds
         };
     }
 
diff --git a/src/Downloaders.ts b/src/Downloaders.ts
index 8a1edea..b4f612f 100644
--- a/src/Downloaders.ts
+++ b/src/Downloaders.ts
@@ -234,9 +234,102 @@ export async function downloadShareVideo(videoUrls: Array<VideoUrl>): Promise<vo
             }
         }
         else {
-            logger.error('TODO: manifest download');
+            // FIXME: just a copy-paste, should move to separate function
+            const pbar: cliProgress.SingleBar = new cliProgress.SingleBar({
+                barCompleteChar: '\u2588',
+                barIncompleteChar: '\u2591',
+                format: 'progress [{bar}] {percentage}% {speed} {eta_formatted}',
+                // process.stdout.columns may return undefined in some terminals (Cygwin/MSYS)
+                barsize: Math.floor((process.stdout.columns || 30) / 3),
+                stopOnComplete: true,
+                hideCursor: true,
+            });
 
-            continue;
+            logger.info(`\nDownloading Video: ${video.title} \n`);
+            logger.verbose('Extra video info \n' +
+                '\t Video m3u8 playlist URL: '.cyan + video.playbackUrl + '\n' +
+                '\t Video tumbnail URL: '.cyan + video.posterImageUrl + '\n' +
+                '\t Video subtitle URL (may not exist): '.cyan + video.captionsUrl + '\n' +
+                '\t Video total chunks: '.cyan + video.totalChunks + '\n');
+
+            logger.info('Spawning ffmpeg with access token and HLS URL. This may take a few seconds...\n\n');
+            if (!process.stdout.columns) {
+                logger.warn(
+                    'Unable to get number of columns from terminal.\n' +
+                    'This happens sometimes in Cygwin/MSYS.\n' +
+                    'No progress bar can be rendered, however the download process should not be affected.\n\n' +
+                    'Please use PowerShell or cmd.exe to run destreamer on Windows.'
+                );
+            }
+
+            const ffmpegInpt: any = new FFmpegInput(video.playbackUrl);
+            const ffmpegOutput: any = new FFmpegOutput(video.outPath, new Map([
+                argv.acodec === 'none' ? ['an', null] : ['c:a', argv.acodec],
+                argv.vcodec === 'none' ? ['vn', null] : ['c:v', argv.vcodec],
+                ['n', null]
+            ]));
+            const ffmpegCmd: any = new FFmpegCommand();
+
+            const cleanupFn: () => void = () => {
+                pbar.stop();
+
+                if (argv.noCleanup) {
+                    return;
+                }
+
+                try {
+                    fs.unlinkSync(video.outPath);
+                }
+                catch (e) {
+                    // Future handling of an error (maybe)
+                }
+            };
+
+            pbar.start(video.totalChunks, 0, {
+                speed: '0'
+            });
+
+            // prepare ffmpeg command line
+            ffmpegCmd.addInput(ffmpegInpt);
+            ffmpegCmd.addOutput(ffmpegOutput);
+
+            ffmpegCmd.on('update', async (data: any) => {
+                const currentChunks: number = ffmpegTimemarkToChunk(data.out_time);
+
+                pbar.update(currentChunks, {
+                    speed: data.bitrate
+                });
+
+                // Graceful fallback in case we can't get columns (Cygwin/MSYS)
+                if (!process.stdout.columns) {
+                    process.stdout.write(`--- Speed: ${data.bitrate}, Cursor: ${data.out_time}\r`);
+                }
+            });
+
+            process.on('SIGINT', cleanupFn);
+
+            // let the magic begin...
+            await new Promise((resolve: any) => {
+                ffmpegCmd.on('error', (error: any) => {
+                    cleanupFn();
+
+                    logger.error(`FFmpeg returned an error: ${error.message}`);
+                    process.exit(ERROR_CODE.UNK_FFMPEG_ERROR);
+                });
+
+                ffmpegCmd.on('success', () => {
+                    pbar.update(video.totalChunks); // set progress bar to 100%
+                    logger.info(`\nDownload finished: ${video.outPath} \n`);
+                    resolve();
+                });
+
+                ffmpegCmd.spawn();
+            });
+
+            process.removeListener('SIGINT', cleanupFn);
+            // logger.error('TODO: manifest download');
+
+            // continue;
         }
     }
 }
diff --git a/src/LoginModules.ts b/src/LoginModules.ts
index c327977..7d8a938 100644
--- a/src/LoginModules.ts
+++ b/src/LoginModules.ts
@@ -94,10 +94,8 @@ export async function doStreamLogin(url: string, tokenCache: TokenCache, usernam
 export async function doShareLogin(url: string, username?: string): Promise<ShareSession> {
     logger.info('Launching headless Chrome to perform the OpenID Connect dance...');
 
+    let session: ShareSession | null = null;
     const hostname = new URL(url).host;
-    logger.verbose(new URL(url).host);
-    logger.verbose(new URL(url).hostname);
-
 
     const browser: puppeteer.Browser = await puppeteer.launch({
         executablePath: getPuppeteerChromiumPath(),
@@ -142,7 +140,6 @@ export async function doShareLogin(url: string, username?: string): Promise<Shar
         await browser.waitForTarget((target: puppeteer.Target) => target.url().startsWith(`https://${hostname}`), { timeout: 150000 });
         logger.info('We are logged in.');
 
-        let session: ShareSession | null = null;
         let tries = 1;
         while (!session) {
             const cookieJar = (await page.cookies()).filter(
@@ -168,10 +165,12 @@ export async function doShareLogin(url: string, username?: string): Promise<Shar
         logger.info("At this point Chromium's job is done, shutting it down...\n");
 
         // await page.waitForTimeout(1000 * 60 * 60 * 60);
-        return session;
     }
     finally {
+        logger.verbose('Stream login browser closing...');
         await browser.close();
+        logger.verbose('Stream login browser closed');
     }
 
+    return session;
 }
diff --git a/src/Utils.ts b/src/Utils.ts
index 01db539..b2dfb32 100644
--- a/src/Utils.ts
+++ b/src/Utils.ts
@@ -228,12 +228,12 @@ export function checkRequirements(): void {
     }
 }
 
-
+// number of seconds
 export function ffmpegTimemarkToChunk(timemark: string): number {
     const timeVals: Array<string> = timemark.split(':');
     const hrs: number = parseInt(timeVals[0]);
     const mins: number = parseInt(timeVals[1]);
     const secs: number = parseInt(timeVals[2]);
 
-    return (hrs * 60) + mins + (secs / 60);
+    return (hrs * 60 * 60) + (mins * 60) + secs;
 }
diff --git a/src/VideoUtils.ts b/src/VideoUtils.ts
index d03aa70..60b2c3d 100644
--- a/src/VideoUtils.ts
+++ b/src/VideoUtils.ts
@@ -18,31 +18,40 @@ export function publishedDateToString(date: string): string {
     return `${dateJs.getFullYear()}-${month}-${day}`;
 }
 
+export function publishedTimeToString(seconds: number): string
+export function publishedTimeToString(date: string): string
+export function publishedTimeToString(date: string | number): string {
+    let dateJs: Date;
+
+    if (typeof (date) === 'number') {
+        dateJs = new Date(0, 0, 0, 0, 0, date);
+    }
+    else {
+        dateJs = new Date(date);
+    }
 
-export function publishedTimeToString(date: string): string {
-    const dateJs: Date = new Date(date);
     const hours: string = dateJs.getHours().toString();
     const minutes: string = dateJs.getMinutes().toString();
     const seconds: string = dateJs.getSeconds().toString();
 
-    return `${hours}.${minutes}.${seconds}`;
+    return `${hours}h ${minutes}m ${seconds}s`;
 }
 
 
-function isoDurationToString(time: string): string {
+export function isoDurationToString(time: string): string {
     const duration: Duration = parseDuration(time);
 
     return `${duration.hours ?? '00'}.${duration.minutes ?? '00'}.${duration.seconds?.toFixed(0) ?? '00'}`;
 }
 
-
-function durationToTotalChunks(duration: string): number {
+// it's the number of seconds in the video
+export function durationToTotalChunks(duration: string,): number {
     const durationObj: any = parseDuration(duration);
     const hrs: number = durationObj.hours ?? 0;
     const mins: number = durationObj.minutes ?? 0;
     const secs: number = Math.ceil(durationObj.seconds ?? 0);
 
-    return (hrs * 60) + mins + (secs / 60);
+    return (hrs * 60 * 60) + (mins * 60) + secs;
 }