Add extraction wizard (#4)

Author: hopskipnfall

angular.json

@@ -20,6 +20,7 @@
               "src/assets"
             ],
             "styles": [
+              "./node_modules/@angular/material/prebuilt-themes/deeppurple-amber.css",
               "src/styles.scss"
             ],
             "scripts": [],
@@ -170,4 +171,4 @@
   "cli": {
     "analytics": "08501833-8ed2-4495-9ec6-b2c0cd10afca"
   }
-}
+}

extraction/video.ts

@@ -6,6 +6,7 @@ import { BehaviorSubject, Observable } from 'rxjs';
 import { FfpathsConfig } from './ffpaths';
 import * as moment from 'moment';
 import * as os from 'os';
+import { cursorTo } from 'readline';
 
 type Statuses =
   | 'NOT_STARTED'
@@ -19,6 +20,7 @@ export interface ExtractionStatus {
   uri: string;
   phase: Statuses;
   percentage: number;
+  debug?: unknown;
 }
 
 export interface Interval {
@@ -42,7 +44,7 @@ export class Video {
 
   getInfo(): Promise<ffmpeg.FfprobeData> {
     return new Promise((resolve, reject) => {
-      ffmpeg.ffprobe(this.videoPath, (err, data) => {
+      ffmpeg.ffprobe(this.videoPath, ['-show_chapters'], (err, data) => {
         if (data) resolve(data);
         if (err) reject(err);
       });
@@ -56,7 +58,9 @@ export class Video {
       fs.mkdirSync(this.scratchPath, { recursive: true });
       // TODO: Is there a better way to find the "desktop" folder?
       const outputFolder = path.join(os.homedir(), 'Desktop', 'Dialog');
-      fs.mkdirSync(outputFolder);
+      if (!fs.existsSync(outputFolder)) {
+        fs.mkdirSync(outputFolder);
+      }
       // TODO: This somehow throws a user-visible error but does not stop execution.
       // Figure out how to catch this and prevent moving forward.
       this.stream = fs.createWriteStream(
@@ -68,6 +72,43 @@ export class Video {
       // Note: This doesn't throw an error when it fails (for example, with recursive: false)...
       fs.rmdirSync(this.scratchPath, { recursive: true });
 
+      this.extractionProgress.next({
+        uri: this.videoPath, phase: 'DONE',
+        percentage: 100,
+      });
+      console.log('Extraction complete.');
+    } catch (e) {
+      this.extractionProgress.next({
+        uri: this.videoPath, phase: 'ERROR',
+        percentage: 100,
+        debug: e,
+      });
+      throw e;
+    }
+  }
+
+  async extractDialogNew(config: any): Promise<void> {
+    try {
+      this.scratchPath = fs.mkdtempSync(path.join(os.tmpdir(), `${path.basename(this.videoPath, path.extname(this.videoPath))}-`));
+      console.log('Scratch path', this.scratchPath);
+      fs.mkdirSync(this.scratchPath, { recursive: true });
+      // TODO: Is there a better way to find the "desktop" folder?
+      const outputFolder = path.join(os.homedir(), 'Desktop', 'Dialog');
+      if (!fs.existsSync(outputFolder)) {
+        fs.mkdirSync(outputFolder);
+      }
+      // TODO: This somehow throws a user-visible error but does not stop execution.
+      // Figure out how to catch this and prevent moving forward.
+      this.stream = fs.createWriteStream(
+        `${path.join(outputFolder, path.basename(this.videoPath, path.extname(this.videoPath)))}.mp3`);
+      await this.extractSubtitles(config.subtitleStream);
+      const intervals = await this.getSubtitleIntervals();
+      let combined = this.combineIntervals(intervals);
+      combined = await this.subtractChapters(combined, config.ignoredChapters);
+      await this.extractAudio(combined, config.audioStream);
+      // Note: This doesn't throw an error when it fails (for example, with recursive: false)...
+      fs.rmdirSync(this.scratchPath, { recursive: true });
+
       this.extractionProgress.next({
         uri: this.videoPath, phase: 'DONE',
         percentage: 100,
@@ -82,6 +123,43 @@ export class Video {
     }
   }
 
+  private async subtractChapters(combined: Interval[], chapters: string[]): Promise<Interval[]> {
+    const info = await this.getInfo();
+
+    const chapterIntervals: Interval[] = [];
+    chapters.forEach(chap =>
+      info.chapters.filter(c => c['TAG:title'] === chap)
+        .forEach(c => chapterIntervals.push({
+          start: this.formalize(moment.duration(c.start_time, 'seconds')),
+          end: this.formalize(moment.duration(c.end_time, 'seconds')),
+        })));
+
+    let out: Interval[] = [...combined];
+
+    for (const chapter of chapterIntervals) {
+      const revision = [];
+      for (const ivl of out) {
+        const cur: Interval = {start: ivl.start, end: ivl.end};
+        if (cur.start > chapter.start && cur.start < chapter.end) {
+          cur.start = chapter.end;
+        }
+        if (cur.end > chapter.start && cur.end < chapter.end) {
+          cur.end = chapter.start;
+        }
+        if (cur.start < cur.end) {
+          revision.push(cur);
+        }
+      }
+      out = revision;
+    }
+
+    return out;
+  }
+
+  private formalize(duration: moment.Duration): string {
+    return `${`${duration.hours()}`.padStart(2, '0')}:${`${duration.minutes()}`.padStart(2, '0')}:${`${duration.seconds()}`.padStart(2, '0')}.${`${duration.milliseconds()}`.padStart(3, '0')}`
+  }
+
   private async toPromise(command: ffmpeg.FfmpegCommand, finish: (command: ffmpeg.FfmpegCommand) => void): Promise<any> {
     return new Promise((resolve, reject) => {
       finish(
@@ -97,12 +175,14 @@ export class Video {
   }
 
   /** Synchronously extracts segments. */
-  private async extractAudio(intervals: Interval[]) {
-    for (let i = 0, max = intervals.length; i < max; i++) {//intervals.length; i++) {
+  private async extractAudio(intervals: Interval[], stream?: ffmpeg.FfprobeStream) {
+    const track = stream ? stream.index : 2; // TODO: get rid of 2
+
+    for (let i = 0, max = intervals.length; i < max; i++) {
       const interval = intervals[i];
       const command = ffmpeg(this.videoPath)
         .noVideo()
-        .outputOption(`-ss`, `${interval.start}`, `-to`, `${interval.end}`)//, "-q:a", "0", "-map", "a")
+        .outputOption(`-ss`, `${interval.start}`, `-to`, `${interval.end}`, '-map', `0:${track}`)//, "-q:a", "0", "-map", "a")
         .audioBitrate('128k')
         .audioCodec('libmp3lame')
         .format('mp3')
@@ -116,9 +196,10 @@ export class Video {
     }
   }
 
-  private async extractSubtitles() {
+  private async extractSubtitles(stream?: ffmpeg.FfprobeStream) {
+    const track = stream ? stream.index : 2; // TODO: get rid of 2
     const command = ffmpeg(this.videoPath)
-      .outputOption('-map 0:2')
+      .outputOption(`-map 0:${track}`)
       .saveToFile(path.join(this.scratchPath, 'subs.srt'))
       .on('progress', progress => {
         this.extractionProgress.next({ uri: this.videoPath, phase: 'EXTRACTING_SUBTITLES', percentage: progress.percent });

main.ts

@@ -4,6 +4,7 @@ import { app, BrowserWindow, dialog, ipcMain, screen } from 'electron';
 import * as path from 'path';
 import * as url from 'url';
 import { Video } from './extraction/video';
+import { FfprobeData } from 'fluent-ffmpeg';
 
 let win: BrowserWindow = null;
 const args = process.argv.slice(1),
@@ -58,7 +59,7 @@ function createWindow(): BrowserWindow {
 const selectFiles = async (event: Electron.IpcMainEvent) => {
   const value = await dialog.showOpenDialog({
     properties: ['openFile', 'multiSelections'],
-    filters: [{ name: 'videosOnly', extensions: ['mkv'] }],
+    // filters: [{ name: 'videosOnly', extensions: ['mkv'] }],
   });
   if (value.canceled) {
     // User hit "cancel" on the file selector.
@@ -80,26 +81,30 @@ ipcMain.on('select-files', (event) => {
     });
 });
 
-const extractDialog = async (event: Electron.IpcMainEvent, vidPaths: string[]) => {
-  for (let i = 0; i < vidPaths.length; i++) {
-    const vidPath = vidPaths[i];
-    console.log('Extracting for file', vidPath);
-    const v = new Video(vidPath, path.join(__dirname, '.tmp/'), {
+const extractDialog = async (event: Electron.IpcMainEvent, vidConfigs: any[]) => {
+  console.log('VidConfigs!', vidConfigs);
+
+  for (let i = 0; i < vidConfigs.length; i++) {
+    const vidConfig = vidConfigs[i];
+
+    const myUri = vidConfig.video.ffprobeData.format.filename; //(vidConfig.video.ffprobeData.format as FfprobeData).format.filename;
+    console.log('Extracting for file', myUri);
+    const v = new Video(myUri, path.join(__dirname, '.tmp/'), {
       ffmpeg: ffmpeg.path.replace('app.asar', 'app.asar.unpacked'),
       ffprobe: ffprobe.path.replace('app.asar', 'app.asar.unpacked'),
     });
     const sub = v.getProgress().subscribe(status => {
       event.sender.send('progress-update', status);
     });
-    await v.extractDialog();
+    await v.extractDialogNew(vidConfig);
     sub.unsubscribe();
   }
 };
 
-ipcMain.on('extract-dialog', (event, vidPaths) => {
-  extractDialog(event, vidPaths)
+ipcMain.on('extract-dialog-new', (event, vidConfigs) => {
+  extractDialog(event, vidConfigs)
     .catch(reason => {
-      event.sender.send('error', `Error occurred while extracting dialog: ${JSON.stringify(reason)}`);
+      event.sender.send('error', `Error occurred while extracting dialog: ${reason as string}`);
     });
 });
 

package-lock.json

@@ -96,7 +96,11 @@
     "node": ">=10.13.0"
   },
   "dependencies": {
+    "@angular/animations": "^10.0.0 || ^11.0.0-0",
+    "@angular/cdk": "10.2.0",
+    "@angular/forms": "^10.0.0 || ^11.0.0-0",
     "@angular/localize": "10.0.14",
+    "@angular/material": "10.2.0",
     "@ffmpeg-installer/ffmpeg": "1.0.20",
     "@ffprobe-installer/ffprobe": "1.1.0",
     "@ng-bootstrap/ng-bootstrap": "7.0.0",

package.json

@@ -1,20 +1,24 @@
 import { NgModule } from '@angular/core';
-import { Routes, RouterModule } from '@angular/router';
-import { PageNotFoundComponent } from './shared/components';
-
-import { HomeRoutingModule } from './home/home-routing.module';
+import { RouterModule, Routes } from '@angular/router';
 import { DetailRoutingModule } from './detail/detail-routing.module';
+import { HomeRoutingModule } from './home/home-routing.module';
+import { PageNotFoundComponent } from './shared/components';
+import { WizardComponent } from './wizard/wizard.component';
 
 const routes: Routes = [
   {
     path: '',
     redirectTo: 'home',
-    pathMatch: 'full'
+    pathMatch: 'full',
+  },
+  {
+    path: 'wizard',
+    component: WizardComponent,
   },
   {
     path: '**',
-    component: PageNotFoundComponent
-  }
+    component: PageNotFoundComponent,
+  },
 ];
 
 @NgModule({

src/app/app-routing.module.ts

@@ -1,36 +1,47 @@
 import { HttpClient, HttpClientModule } from '@angular/common/http';
 import { NgModule } from '@angular/core';
-import { FormsModule } from '@angular/forms';
+import { FormsModule, ReactiveFormsModule } from '@angular/forms';
+import { MatStepperModule } from '@angular/material/stepper';
 import { BrowserModule } from '@angular/platform-browser';
 import { NgbModule } from '@ng-bootstrap/ng-bootstrap';
-// NG Translate
 import { TranslateLoader, TranslateModule } from '@ngx-translate/core';
 import { TranslateHttpLoader } from '@ngx-translate/http-loader';
 import 'reflect-metadata';
 import '../polyfills';
+import {MatFormFieldModule} from '@angular/material/form-field';
+import {MatInputModule} from '@angular/material/input';
 import { AppRoutingModule } from './app-routing.module';
 import { AppComponent } from './app.component';
+import { BrowserAnimationsModule } from '@angular/platform-browser/animations';
 import { CoreModule } from './core/core.module';
 import { DetailModule } from './detail/detail.module';
 import { HomeModule } from './home/home.module';
+import {MatIconModule} from '@angular/material/icon';
 import { SharedModule } from './shared/shared.module';
+import { WizardComponent } from './wizard/wizard.component';
 
 // AoT requires an exported function for factories
 export function HttpLoaderFactory(http: HttpClient): TranslateHttpLoader {
   return new TranslateHttpLoader(http, './assets/i18n/', '.json');
 }
 
 @NgModule({
-  declarations: [AppComponent],
+  declarations: [AppComponent, WizardComponent],
   imports: [
     AppRoutingModule,
+    BrowserAnimationsModule,
     BrowserModule,
     CoreModule,
     DetailModule,
     FormsModule,
     HomeModule,
     HttpClientModule,
+    MatFormFieldModule,
+    MatIconModule,
+    MatInputModule,
+    MatStepperModule,
     NgbModule,
+    ReactiveFormsModule,
     SharedModule,
     TranslateModule.forRoot({
       loader: {
@@ -43,4 +54,4 @@ export function HttpLoaderFactory(http: HttpClient): TranslateHttpLoader {
   providers: [],
   bootstrap: [AppComponent]
 })
-export class AppModule {}
+export class AppModule { }