Feature/mix audio video (#12)

* #8 add presets, #7 mix audio, WIP
* refactoring
* refactor menu
* implement #11
* added some unit testing
* improved menu output
* make it more tolerant to missing fields
* new demo

Author: synox

.gitignore

@@ -3,4 +3,7 @@ node_modules
 .vscode
 .DS_Store
 *.mp4
-*.part
+*.part
+*.m4a
+*.mkv
+*.ytdl

cli.js

@@ -3,25 +3,27 @@
 const meow = require('meow')
 const logSymbols = require('log-symbols')
 const shell = require('shelljs')
-const ytdlApi = require('./ytdl-api')
 const ora = require('ora')
 const updateNotifier = require('update-notifier')
+const chalk = require('chalk')
+const ytdlApi = require('./ytdl-api')
 const menu = require('./menu')
 const pkg = require('./package.json')
-const chalk = require('chalk')
 
-const cli = meow(`
+const cli = meow(
+	`
 		Usage: youtube-dl-interactive URL
 
 		Options:
-		  --help, -h  output usage information
+		  --help, -h       output usage information
 		  --version        output the version number
 		  --demo           use sample data, no remote calls
 
-		`, {
+		`,
+	{
 		flags: {
 			demo: {
-				type: 'boolean',
+				type: 'boolean'
 			}
 		}
 	}
@@ -34,17 +36,23 @@ async function init(args, flags) {
 		shell.exit(1)
 	}
 
-	updateNotifier({ pkg }).notify()
+	updateNotifier({pkg}).notify()
 
 	if (flags.demo) {
-		console.log(logSymbols.warning, chalk.bgYellowBright('Running demo with local data, not making remote calls'))
-		await run(null, true);
+		console.log(
+			logSymbols.warning,
+			chalk.bgYellowBright(
+				'Running demo with sample data, not actually calling youtube-dl.'
+			)
+		)
+		await run(null, true)
 	} else {
 		if (args.length !== 1) {
 			cli.showHelp(1)
 		}
+
 		const url = args[0]
-		await run(url, false);
+		await run(url, false)
 	}
 }
 
@@ -54,26 +62,33 @@ init(cli.input, cli.flags).catch(error => {
 })
 
 async function run(url, isDemo) {
-	let info = isDemo
+	const info = isDemo
 		? require('./test/samples/thankyousong.json')
 		: await fetchInfo(url)
 
 	if (!info) {
 		return
 	}
+
 	console.log(chalk.bold('Title:', chalk.blue(info.title)))
-	
-	const formats = info.formats
-	const { formatString, extension } = await menu.formatMenu(formats);
-	console.log(logSymbols.success, `OK, downloading format #${formatString}`);
-	let options = ` -f '${formatString}' `;
-	if (ytdlApi.supportsSubtitles(extension)) {
-		options += ' --all-subs --embed-subs ';
+
+	const {formats} = info
+	const {formatString, hasVideo, hasAudio} = await menu.formatMenu(formats)
+	let options = ` -f '${formatString}' `
+
+	if (!hasVideo && hasAudio) {
+		options += ' --extract-audio '
 	}
+
 	if (isDemo) {
-		console.log(logSymbols.warning, `End of demo. would now call: youtube-dl ${options} "${url}"`)
+		console.log(
+			logSymbols.warning,
+			`End of demo. would now call: youtube-dl ${options} <url>"`
+		)
 	} else {
-		shell.exec(`youtube-dl ${options} "${url}"`);
+		const command = `youtube-dl ${options} "${url}"`
+		console.log(logSymbols.success, `OK. Running: ${command}`)
+		shell.exec(command)
 	}
 }
 
@@ -84,12 +99,8 @@ async function fetchInfo(url) {
 		spinner.stop()
 		return info
 	} catch (error) {
-		spinner.fail('can not load formats')
+		spinner.fail('Error while loading metadata')
 		console.error(error)
 		return null
 	}
-
-
-
 }
-

docs/demo.gif

@@ -1,62 +1,206 @@
 const inquirer = require('inquirer')
 const byteSize = require('byte-size')
 
+exports.formatMenu = async function(formats) {
+	// Select video preset or resolution (it may include a audio track)
+	let {
+		finalFormatId,
+		videoFormatId,
+		audioFormatId,
+		height
+	} = await selectPresetOrResolution(formats)
 
-exports.formatMenu = async function (formats) {
-    let remainingFormats = formats
+	// FinalFormatId means no further selection is required
+	if (!finalFormatId) {
+		let videoFormat
+		// Specifiy which video with this height
+		if (height) {
+			videoFormat = await exports.selectOneVideo(
+				formats.filter(f => f.height === height)
+			)
+			videoFormatId = videoFormat.format_id
+		}
 
-    // By default, we ignore 'video only' files
-    remainingFormats = remainingFormats.filter(f => f.acodec !== 'none')
+		// Specify audio track
+		audioFormatId = await selectAudio(formats, videoFormat)
+	}
 
-    remainingFormats = await exports.filterByProperty(
-        'Select resolution:',
-        f => (f.resolution || 'audio only'),
-        remainingFormats
-    )
+	if (finalFormatId) {
+		return {formatString: finalFormatId, hasVideo: true, hasAudio: true}
+	}
 
-    // remainingFormats = await exports.filterByProperty(
-    // 	'Select extension:',
-    // 	f => f.extension,
-    // 	remainingFormats
-    // )
+	if (videoFormatId && audioFormatId) {
+		if (videoFormatId === audioFormatId) {
+			return {formatString: videoFormatId, hasVideo: true, hasAudio: true}
+		}
 
-    if (remainingFormats.length > 1) {
-        remainingFormats = [await exports.selectOne(remainingFormats)]
-    }
+		return {
+			formatString: `${videoFormatId}+${audioFormatId}`,
+			hasVideo: true,
+			hasAudio: true
+		}
+	}
 
-    const formatString = remainingFormats[0].format_id
-    return {formatString, extension: remainingFormats[0].ext}
-}
+	if (videoFormatId) {
+		// The special case 'video only' has no audio
+		return {formatString: videoFormatId, hasVideo: true, hasAudio: false}
+	}
 
+	// The special case 'audio only' has no video data
+	return {formatString: audioFormatId, hasVideo: false, hasAudio: true}
+}
 
-exports.filterByProperty = async function(message, displayFun, list) {
+async function selectPresetOrResolution(formats) {
 	const answers = await inquirer.prompt([
 		{
 			type: 'list',
 			name: 'q',
-			message,
-			choices: [...new Set(list.map(displayFun))]
+			message: 'What do you want?',
+			pageSize: 10,
+			choices: [
+				{
+					name: 'best video + best audio',
+					value: {finalFormatId: 'bestvideo+bestaudio/best'}
+				},
+				{
+					name: 'worst video + worst audio',
+					value: {finalFormatId: 'worstvideo+worstaudio/worst'}
+				},
+				{
+					name: '<480p mp4',
+					value: {
+						finalFormatId:
+							'bestvideo[height<=480][ext=mp4]+bestaudio[ext=m4a]/best[height<=480][ext=mp4]'
+					}
+				},
+				{name: 'audio only', value: {}},
+				new inquirer.Separator('--- specify resolution: ---'),
+				...getResolutions(formats).map(resolution => ({
+					name: resolution + 'p',
+					value: {height: resolution}
+				}))
+			]
 		}
 	])
-	return list.filter(f => displayFun(f) === answers.q)
+
+	return answers.q
 }
 
-exports.selectOne = async function(formats) {
+exports.selectOneVideo = async function(formats) {
 	const answers = await inquirer.prompt([
 		{
 			type: 'list',
 			name: 'q',
-			message: 'Several matches. Select an option:',
-			choices: formats.map(f => {
-				return {name: exports.createDescription(f), value: f}
-			})
+			message: 'Select a video file:',
+			choices: formats.map(f => ({
+				name: exports.createVideoDescription(f),
+				value: f
+			}))
 		}
 	])
 	return answers.q
 }
- 
 
-exports.createDescription = function(f) {
-	return `${f.ext} | ${f.format} (${byteSize(f.filesize, { units: 'iec' })})`;
+async function selectAudio(formats, selectedVideoFormat) {
+	const choices = []
+
+	if (selectedVideoFormat && selectedVideoFormat.acodec !== 'none') {
+		choices.push({
+			name: `Use audio included in the video: ${exports.createAudioShortDescription(
+				selectedVideoFormat
+			)}`,
+			value: selectedVideoFormat.format_id
+		})
+		choices.push(new inquirer.Separator())
+	}
+
+	choices.push({name: 'best audio', value: 'bestaudio'})
+	choices.push({name: 'worst audio', value: 'worstaudio'})
+	choices.push(new inquirer.Separator('--- specify: ---'))
+	choices.push(
+		...getAudioFormats(formats).map(f => ({
+			name: exports.createAudioDescription(f),
+			value: f.format_id
+		}))
+	)
+
+	const audioAnswers = await inquirer.prompt([
+		{
+			message: 'Select audio:',
+			type: 'list',
+			name: 'q',
+			pageSize: 10,
+			choices
+		}
+	])
+	return audioAnswers.q
+}
+
+function getResolutions(formats) {
+	const resolutions = formats.filter(f => Boolean(f.height)).map(f => f.height)
+
+	return [...new Set(resolutions)].sort(f => f.height).reverse()
+}
+
+function getAudioFormats(formats) {
+	return formats.filter(f => f.acodec && f.acodec !== 'none')
+}
+
+exports.createVideoDescription = function(f) {
+	return (
+		paddingRight(f.ext, 4) +
+		paddingRight(f.width ? f.width + 'x' + f.height : null, 9) +
+		paddingRight(f.format_note, 10) +
+		paddingRight(byteSize(f.filesize, {units: 'iec'}), 8) +
+		exports.createAudioShortDescription(f, 'audio: ') +
+		'(' +
+		f.format_id +
+		')'
+	)
+}
+
+const paddingRight = function(value, width) {
+	if (!value) {
+		value = ''
+	}
+
+	// Value might be an object. Wrap it so we can call padEnd on it.
+	value = String(value)
+	return value.padEnd(width) + ' '
+}
+
+const paddingLeft = function(value, width, suffix = '') {
+	if (value) {
+		value += suffix
+	} else {
+		value = ''
+	}
+
+	// Value might be an object. Wrap it so we can call padEnd on it.
+	value = String(value)
+	return value.padStart(width) + ' '
 }
 
+exports.createAudioDescription = function(f) {
+	return (
+		paddingRight(f.ext, 4) +
+		paddingRight(f.acodec, 9) +
+		'@ ' +
+		paddingLeft(f.abr, 3, 'k') +
+		paddingRight(f.format_note, 10) +
+		paddingLeft(byteSize(f.filesize, {units: 'iec'}), 7) +
+		'(' +
+		f.format_id +
+		')'
+	)
+}
+
+exports.createAudioShortDescription = function(f, prefix = '') {
+	if (f.acodec && f.acodec !== 'none') {
+		return (
+			prefix + paddingRight(f.acodec, 9) + '@ ' + paddingLeft(f.abr, 3, 'k')
+		)
+	}
+
+	return ''
+}

docs/demo.svg

@@ -14,6 +14,7 @@
   "license": "MIT",
   "dependencies": {
     "byte-size": "^5.0.1",
+    "chalk": "^2.4.2",
     "inquirer": "^6.3.1",
     "log-symbols": "^2.2.0",
     "meow": "^5.0.0",