.eslintrc.js

@@ -16,6 +16,7 @@ module.exports = {
     // require space on single line objects
     'object-curly-spacing': ['error', 'always'],
     // and arrays
-    'array-bracket-spacing': ['error', 'always']
+    'array-bracket-spacing': ['error', 'always'],
+    'computed-property-spacing': ['error', 'always']
   }
 }

.github/workflows/nodejs.yml

@@ -0,0 +1,30 @@
+# This workflow will do a clean install of node dependencies, build the source code and run tests across different versions of node
+# For more information see: https://help.github.com/actions/language-and-framework-guides/using-nodejs-with-github-actions
+
+name: Node.js CI
+
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+    branches: [ master ]
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+
+    strategy:
+      matrix:
+        node-version: [12.x, 14.x, 16.x]
+
+    steps:
+    - uses: actions/checkout@v2
+    - name: Use Node.js ${{ matrix.node-version }}
+      uses: actions/setup-node@v1
+      with:
+        node-version: ${{ matrix.node-version }}
+    - run: yarn install --frozen-lockfile
+    - run: yarn test
+      env:
+        CI: true

.travis.yml

@@ -2,8 +2,7 @@ language: node_js
 sudo: false
 
 node_js:
-- "6"
-- "7"
 - "8"
-- "9"
 - "10"
+- "11"
+- "12"

README.md

@@ -1,20 +1,26 @@
 # Media-split
 
+[![Actions Status](https://github.com/skiptirengu/media-split/workflows/Node.js%20CI/badge.svg)](https://github.com/skiptirengu/media-split/actions)
+
 Split audio (and video) files
 
 ## Install
 
 Make sure you have [ffmpeg](https://ffmpeg.org/) installed and added to your path then run:
 
 ```bash
-npm install [-g] mp3-split
+npm install [-g] media-split
 ```
 
-If you don't have ffmpeg installed, you can install [this package](https://www.npmjs.com/package/ffmpeg-binaries) which 
+If you don't have ffmpeg installed, you can install [this](https://www.npmjs.com/package/ffmpeg-static) or [this](https://www.npmjs.com/package/@ffmpeg-installer/ffmpeg) package which 
 comes with a bundled ffmpeg, and media-split will automatically detect and use it.
 
 ```bash
-npm install [-g] ffmpeg-binaries
+npm install [-g] ffmpeg-static
+```
+or
+```bash
+npm install [-g] @ffmpeg-installer/ffmpeg
 ```
 
 ## CLI
@@ -42,6 +48,11 @@ A template file usually looks like this:
 [15:37] wish you still felt this way [ sophie meiers x 90sFlav ]
 ```
 
+## Known issues
+
+Sometimes, when downloading videos from YouTube, media-split can fail with the error message "Too many redirects".
+This is caused by a third party library and is already being tracked [here](https://github.com/fent/node-ytdl-core/issues/212).
+
 ## Library
 
 You can also use media-split as a library.
@@ -72,6 +83,9 @@ split.parse().then((sections) => {
 | options.output | <code>string</code> | Output path |
 | options.format | <code>string</code> | Output format (mp3, m4a, flac, etc) |
 | options.audioonly | <code>boolean</code> | Force download only audio files when using a url as input |
+| options.quality | <code>string</code> | The download quality when downloading from YouTube (highest/lowest/highestaudio/lowestaudio/highestvideo/lowestvideo) |
+| options.inputParams | <code>Array.&lt;string&gt;</code> | Additional input parameters for FFMpeg
+| options.outputParams | <code>Array.&lt;string&gt;</code> | Additional output parameters for FFMpeg
 
 ### MediaSplit.parse() ⇒ <code>Promise.&lt;Array.&lt;object&gt;&gt;</code>
 Split the media

cli/Command.js

@@ -13,11 +13,16 @@ class Command {
     this.argv = argv
   }
 
+  getSections () {
+    return this.argv.sections || this.readTemplateFile()
+  }
+
   readTemplateFile () {
     try {
       const content = fs.readFileSync(this.argv.template, { enconding: 'utf-8' })
       return content.toString().trim().split('\n')
     } catch (e) {
+      log(red(`Unable to open template file ${this.argv.template}`))
       return null
     }
   }
@@ -53,9 +58,9 @@ class Command {
   }
 
   run () {
-    const sections = this.readTemplateFile()
-    if (sections === null) {
-      log(red(`Unable to open template file ${this.argv.template}`))
+    const sections = this.getSections()
+    if (!sections) {
+      log(red('No sections found. Unable to continue'))
       return
     }
 
@@ -72,7 +77,10 @@ class Command {
       metadata: metadata,
       output: this.argv.output || '.',
       format: this.argv.format,
-      audioonly: this.argv.audioonly
+      audioonly: this.argv.audioonly,
+      quality: this.argv.quality,
+      inputParams: this.argv.inputParam,
+      outputParams: this.argv.outputParam
     })
 
     let downloadBar

cli/index.js

@@ -7,27 +7,39 @@ const Command = require('./Command.js')
 
 const argv = yargs
   .usage('Usage: $0 <command> [options]')
-  .example('$0 -i myaudio.mp3 -t parse.txt -o /home/Music -m title=Test')
+  .example('$0 -i myvideo.avi -f mp4 -t parse.txt -o /home/Videos -m title=Test -p:o "\'-vf scale=320:-1\'"')
   .alias('a', 'audioonly')
   .alias('o', 'output')
   .alias('t', 'template')
   .alias('i', 'input')
   .alias('m', 'metadata')
   .alias('c', 'concurrency')
   .alias('f', 'format')
+  .alias('s', 'sections')
+  .alias('q', 'quality')
+  .alias('p:i', 'inputParam')
+  .alias('p:o', 'outputParam')
   .describe('o', 'Output path')
   .describe('t', 'Template text file')
   .describe('i', 'Input file or YouTube URL')
   .describe('m', 'Output file metadata with "key=value" format')
   .describe('c', 'Max concurrent tasks')
   .describe('f', 'Output format (mp3, m4a, flac, etc)')
   .describe('a', 'Force download only audio files when using a url as input')
+  .describe('s', 'Sections to split')
+  .describe('q', 'Download quality (highest/lowest/highestaudio/lowestaudio/highestvideo/lowestvideo)')
+  .describe('p:i', 'Additional FFMpeg input parameters')
+  .describe('p:o', 'Additional FFMpeg output parameters')
   .default('f', 'mp3')
   .default('t', 'templ.txt')
   .default('i', 'input.mp3')
   .default('a', false)
   .default('c', 3)
+  .default('q', 'highest')
   .array('m').default('m', [])
+  .array('p:i').default('p:i', [])
+  .array('p:o').default('p:o', [])
+  .array('s')
   .help('h').alias('h', 'help')
   .argv
 

lib/FFmpeg.js

@@ -11,24 +11,24 @@ function global (lib) {
 const libs = {
   // local installation
   '@ffmpeg-installer/ffmpeg': (lib) => require(lib).path,
-  'ffmpeg-binaries': (lib) => require(lib),
-  'ffmpeg': (lib) => {
-    let proc = spawnSync(lib)
+  'ffmpeg-static': (lib) => require(lib),
+  ffmpeg: (lib) => {
+    const proc = spawnSync(lib)
     if (proc.error instanceof Error) {
       throw proc.error
     } else {
       return lib
     }
   },
-  [global('@ffmpeg-installer/ffmpeg')]: (lib) => require(lib).path,
-  [global('ffmpeg-binaries')]: (lib) => require(lib)
+  [ global('@ffmpeg-installer/ffmpeg') ]: (lib) => require(lib).path,
+  [ global('ffmpeg-static') ]: (lib) => require(lib)
 }
 
 module.exports = null
 
 for (const libName of Object.keys(libs)) {
   try {
-    module.exports = libs[libName](libName)
+    module.exports = libs[ libName ](libName)
     break
   } catch (e) {
     // eslint-disable-line no-empty

lib/MediaSplit.js

@@ -27,6 +27,9 @@ class MediaSplit extends EventEmitter {
    * @param {string} options.output - Output path
    * @param {string} options.format - Output format (mp3, m4a, flac, etc)
    * @param {boolean} options.audioonly - Force download only audio files when using a url as input
+   * @param {string} options.quality - Download quality
+   * @param {string[]} options.inputParams - FFMpeg additional input parameters
+   * @param {string[]} options.outputParams - FFMpeg additional output parameters
    * @return MediaSplit
    */
   constructor (options = {}) {
@@ -41,10 +44,21 @@ class MediaSplit extends EventEmitter {
       sections: [],
       output: '.',
       format: 'mp3',
-      audioonly: false
+      audioonly: false,
+      quality: 'highest',
+      inputParams: [],
+      outputParams: []
     }
 
-    this._options = Object.assign(defaults, options)
+    this._options = Object.assign(
+      defaults,
+      options,
+      {
+        inputParams: this._sanitizeParams(options.inputParams),
+        outputParams: this._sanitizeParams(options.outputParams)
+      }
+    )
+
     this._inputFile = ''
     this._downloadOptions = {}
   }
@@ -71,7 +85,7 @@ class MediaSplit extends EventEmitter {
 
   _handleUrl () {
     return ytdl.getInfo(this._options.input).then((info) => {
-      this._downloadOptions = { quality: 'highestaudio', filter: this._options.audioonly ? 'audioonly' : undefined }
+      this._downloadOptions = { quality: this._options.quality, filter: this._options.audioonly ? 'audioonly' : undefined }
 
       const format = ytdl.chooseFormat(info.formats, this._downloadOptions)
 
@@ -82,7 +96,7 @@ class MediaSplit extends EventEmitter {
       }
 
       this._inputFile = path.join(
-        this._options.output, this._fileName(info.title, format.container)
+        this._options.output, this._fileName(info.videoDetails.title, format.container)
       )
 
       return Promise.all([
@@ -127,6 +141,7 @@ class MediaSplit extends EventEmitter {
       let downloadLen
       ytdl.downloadFromInfo(info, this._downloadOptions)
         .on('progress', (chunk, downloaded, total) => {
+          total = parseInt(total)
           if (!downloadLen) {
             this.emit('downloadLength', downloadLen = total)
           }
@@ -141,7 +156,7 @@ class MediaSplit extends EventEmitter {
   _checkCachedFileIsValid (stat, ytUrl) {
     return new Promise((resolve) => {
       const reqLib = this._getReqLib(ytUrl)
-      const parsed = url.parse(ytUrl)
+      const parsed = new url.URL(ytUrl)
       parsed.method = 'HEAD'
       const req = reqLib.request(parsed, (response) => {
         if (!this._isResponseSuccessful(response)) {
@@ -168,7 +183,7 @@ class MediaSplit extends EventEmitter {
       return Promise.resolve(true)
     }
 
-    const url = `https://img.youtube.com/vi/${info.video_id}/sddefault.jpg`
+    const url = `https://img.youtube.com/vi/${info.videoDetails.videoId}/sddefault.jpg`
     return new Promise((resolve) => {
       const outputFile = path.join(this._options.output, 'cover.jpg')
       request(url)
@@ -210,7 +225,7 @@ class MediaSplit extends EventEmitter {
     const sections = this._options.sections
     const parsed = []
 
-    for (let index in sections) {
+    for (const index in sections) {
       const curr = sections[ index ]
       const line = parseInt(index) + 1
       const time = this._extractTimeRangeFromLine(curr)
@@ -226,7 +241,7 @@ class MediaSplit extends EventEmitter {
       }
 
       if (line < sections.length && end === null) {
-        let time = this._extractTimeRangeFromLine(sections[ line ])
+        const time = this._extractTimeRangeFromLine(sections[ line ])
 
         if (time === null) {
           throw new Error(`Line ${line + 1} does not contain a valid time range`)
@@ -282,7 +297,7 @@ class MediaSplit extends EventEmitter {
   }
 
   _extractStartAndEndTime (period) {
-    let [ start, end ] = this._removeBrackets(period).split('-')
+    const [ start, end ] = this._removeBrackets(period).split('-')
     return {
       start: `[${start.trim()}]`.match(timeRe).pop(),
       end: `[${end.trim()}]`.match(timeRe).pop()
@@ -304,7 +319,7 @@ class MediaSplit extends EventEmitter {
 
     // Number of tasks in execution
     let concurrentTasks = 0
-    let maxTasks = this._options.concurrency
+    const maxTasks = this._options.concurrency
 
     this.emit('data', sections)
 
@@ -320,10 +335,11 @@ class MediaSplit extends EventEmitter {
           clearInterval(interval)
           concurrentTasks++
 
-          let args = [
+          const args = [
             '-hide_banner',
             '-loglevel', 'repeat+error',
             '-y',
+            ...this._options.inputParams,
             '-i', this._inputFile,
             '-ss', section.start
           ]
@@ -345,11 +361,14 @@ class MediaSplit extends EventEmitter {
           }
 
           // Add metadata info to the arguments
-          for (let meta of section.metadata) {
+          for (const meta of section.metadata) {
             const [ name, value ] = meta
             args.push('-metadata', `${name}=${value}`)
           }
 
+          // Additional ffmpeg output arguments
+          args.push(...this._options.outputParams)
+
           // And finally the output path
           args.push(path.join(this._options.output, section.name))
 
@@ -370,6 +389,15 @@ class MediaSplit extends EventEmitter {
     return Promise.all(promises)
   }
 
+  /**
+   * @param {string[]} params
+   */
+  _sanitizeParams (params) {
+    return (params || [])
+      .map((x) => x.replace(/^("|')/gim, '').replace(/("|')$/gim, ''))
+      .flatMap(x => x.split(' '))
+  }
+
   _checkAccess (dir, mode) {
     return new Promise((resolve, reject) => fs.access(dir, mode, (err) => err ? reject(err) : resolve(dir)))
   }

package.json

@@ -1,6 +1,6 @@
 {
   "name": "media-split",
-  "version": "5.0.0",
+  "version": "5.4.0",
   "description": "Split audio (and video) files",
   "main": "index.js",
   "author": {
@@ -23,18 +23,18 @@
   "repository": "https://github.com/skiptirengu/media-split",
   "license": "MIT",
   "dependencies": {
-    "chalk": "^2.4.1",
-    "cli-progress": "^2.1.0",
-    "eslint": "^5.3.0",
-    "global-modules": "^1.0.0",
-    "miniget": "^1.3.0",
-    "sanitize-filename": "^1.6.1",
-    "yargs": "^12.0.1",
-    "ytdl-core": "^0.24.0"
+    "chalk": "~4.1.2",
+    "cli-progress": "^3.9.1",
+    "eslint": "^8.6.0",
+    "global-modules": "^2.0.0",
+    "miniget": "^4.2.1",
+    "sanitize-filename": "^1.6.3",
+    "yargs": "~17.3.1",
+    "ytdl-core": "^4.9.2"
   },
   "peerDependencies": {
-    "ffmpeg-binaries": "^4.0.0",
-    "@ffmpeg-installer/ffmpeg": "^1.0.0"
+    "@ffmpeg-installer/ffmpeg": "^1.0.20",
+    "ffmpeg-static": "^4.3.0"
   },
   "bin": {
     "mp3-split": "cli/index.js",
@@ -51,19 +51,21 @@
     "lint"
   ],
   "devDependencies": {
-    "@ffmpeg-installer/ffmpeg": "^1.0.15",
-    "@types/chai": "^4.1.4",
-    "chai": "^4.1.2",
-    "eslint-config-standard": "^12.0.0-alpha.0",
-    "eslint-plugin-import": "^2.13.0",
-    "eslint-plugin-node": "^7.0.1",
-    "eslint-plugin-promise": "^3.8.0",
-    "eslint-plugin-standard": "^3.1.0",
-    "jsdoc-to-markdown": "^4.0.1",
-    "mocha": "^5.2.0",
-    "mock-require": "^3.0.2",
+    "@ffmpeg-installer/ffmpeg": "^1.1.0",
+    "@types/chai": "^4.3.0",
+    "chai": "^4.3.4",
+    "eslint-config-standard": "^16.0.3",
+    "eslint-plugin-import": "^2.25.4",
+    "eslint-plugin-node": "^11.1.0",
+    "eslint-plugin-promise": "^6.0.0",
+    "eslint-plugin-standard": "^5.0.0",
+    "mocha": "^9.1.3",
+    "mock-require": "^3.0.3",
     "mp3-duration": "^1.1.0",
-    "nyc": "^12.0.2",
+    "nyc": "^15.1.0",
     "pre-commit": "^1.2.2"
+  },
+  "optionalDependencies": {
+    "jsdoc-to-markdown": "^7.1.0"
   }
 }

spec/Command.spec.js

@@ -0,0 +1,13 @@
+'use strict'
+
+const expect = require('chai').expect
+const spawnSync = require('child_process').spawnSync
+const path = require('path')
+
+describe('Command', () => {
+  it('should return 0 code', () => {
+    const binPath = path.resolve('cli/index.js')
+    const proc = spawnSync('node', [ binPath, 'h' ])
+    expect(proc.status).to.be.equal(0)
+  })
+})

spec/FFmpeg.spec.js

@@ -26,17 +26,17 @@ describe('FFmpeg', function () {
     expect(require1).to.be.equals('foo')
   })
 
-  it('should fallback to ffmpeg-binaries', function () {
+  it('should fallback to ffmpeg-static', function () {
     mockRequire('@ffmpeg-installer/ffmpeg', errorModule)
-    mockRequire('ffmpeg-binaries', 1)
+    mockRequire('ffmpeg-static', 1)
     const require1 = require(moduleName)
     expect(require1).to.be.equals(1)
   })
 
   it('should fallback to ffmpeg on $PATH', function () {
     let called = false
     mockRequire('@ffmpeg-installer/ffmpeg', errorModule)
-    mockRequire('ffmpeg-binaries', errorModule)
+    mockRequire('ffmpeg-static', errorModule)
     childProcess.spawnSync = function (cmd) {
       called = true
       expect(cmd).to.be.equals('ffmpeg')
@@ -48,18 +48,18 @@ describe('FFmpeg', function () {
 
   it('should fallback to global @ffmpeg-installer', function () {
     mockRequire('@ffmpeg-installer/ffmpeg', errorModule)
-    mockRequire('ffmpeg-binaries', errorModule)
+    mockRequire('ffmpeg-static', errorModule)
     childProcess.spawnSync = errorSpawn
     mockRequire(path.join(global, '@ffmpeg-installer/ffmpeg'), { path: 'qux' })
     expect(require(moduleName)).to.be.equals('qux')
   })
 
-  it('should fallback to global ffmpeg-binaries', function () {
+  it('should fallback to global ffmpeg-static', function () {
     mockRequire('@ffmpeg-installer/ffmpeg', errorModule)
-    mockRequire('ffmpeg-binaries', errorModule)
+    mockRequire('ffmpeg-static', errorModule)
     childProcess.spawnSync = errorSpawn
     mockRequire(path.join(global, '@ffmpeg-installer/ffmpeg'), errorModule)
-    mockRequire(path.join(global, 'ffmpeg-binaries'), 2)
+    mockRequire(path.join(global, 'ffmpeg-static'), 2)
     expect(require(moduleName)).to.be.equals(2)
   })
 

spec/MediaSplit.spec.js

@@ -56,14 +56,14 @@ describe('MediaSplit', function () {
   })
 
   describe('_checkDownloadCache', function () {
-    let mockFile = path.join(outputPath, 'mock_file.mp4')
+    const mockFile = path.join(outputPath, 'mock_file.mp4')
 
     afterEach(() => {
       fs.unlinkSync(mockFile)
     })
 
-    it('should invalidate cache if sizes don\'t match', () => {
-      let info = { foo: 'bar' }
+    it('should invalidate cache if sizes don\'t match', async () => {
+      const info = { foo: 'bar' }
       let called = false
 
       fs.writeFileSync(mockFile, 'Foo bar')
@@ -81,18 +81,17 @@ describe('MediaSplit', function () {
       split._getReqLib = function () {
         return {
           request (url, cb) {
-            // eslint-disable-next-line standard/no-callback-literal
+            // eslint-disable-next-line node/no-callback-literal
             cb({ statusCode: 200, headers: { 'content-length': 123488 } })
             return { end: () => null, on: () => null }
           }
         }
       }
 
       split._inputFile = mockFile
-      return split._checkDownloadCache({ url: 'http://skiptirengu.com/video/' }, info).then(() => {
-        expect(called).to.be.true
-        expect(data).to.be.deep.equals(info)
-      })
+      await split._checkDownloadCache({ url: 'http://skiptirengu.com/video/' }, info)
+      expect(called).to.be.true
+      expect(data).to.be.deep.equals(info)
     })
   })
 
@@ -179,7 +178,7 @@ describe('MediaSplit', function () {
 
     function tearDown () {
       fs.readdirSync(outputPath).forEach((file) => {
-        if ([ '.mp3', '.m4a', '.jpg' ].indexOf(path.extname(file)) !== -1) {
+        if ([ '.mp3', '.m4a', '.jpg', '.mp4' ].indexOf(path.extname(file)) !== -1) {
           fs.unlinkSync(path.join(outputPath, file))
         }
       })
@@ -188,7 +187,9 @@ describe('MediaSplit', function () {
     beforeEach(tearDown)
     afterEach(tearDown)
 
-    it('should parse a url', function () {
+    it('should parse an url', async function () {
+      this.timeout(8000)
+
       let counter = 0
       let video
       let filename
@@ -213,7 +214,7 @@ describe('MediaSplit', function () {
         counter++
       })
       split.on('url', (file, info) => {
-        video = info.video_id
+        video = info.videoDetails.videoId
         filename = file
       })
       split.on('data', () => {
@@ -223,20 +224,19 @@ describe('MediaSplit', function () {
         progressEvt = total
       })
 
-      return split.parse().then((sections) => {
-        expect(video).to.be.equals('kN9SZtwP1ys')
-        expect(counter).to.be.equals(2)
-        expect(sections).to.length(2)
-        expect(dataEvt).to.be.true
-        expect(progressEvt).to.be.equals(161161)
-        expect(fs.existsSync(path.join(outputPath, 'Part 1.m4a'))).to.be.true
-        expect(fs.existsSync(path.join(outputPath, 'Part 2.m4a'))).to.be.true
-        expect(fs.existsSync(path.join(outputPath, 'cover.jpg'))).to.be.true
-        expect(fs.existsSync(filename)).to.be.true
-      })
+      const sections = await split.parse()
+      expect(video).to.be.equals('kN9SZtwP1ys')
+      expect(counter).to.be.equals(2)
+      expect(sections).to.length(2)
+      expect(dataEvt).to.be.true
+      expect(progressEvt).to.be.equals(161161)
+      expect(fs.existsSync(path.join(outputPath, 'Part 1.m4a'))).to.be.true
+      expect(fs.existsSync(path.join(outputPath, 'Part 2.m4a'))).to.be.true
+      expect(fs.existsSync(path.join(outputPath, 'cover.jpg'))).to.be.true
+      expect(fs.existsSync(filename)).to.be.true
     })
 
-    it('should parse a local file', function () {
+    it('should parse a local file', async function () {
       let counter = 0
       let dataEvt = false
 
@@ -265,21 +265,19 @@ describe('MediaSplit', function () {
         dataEvt = true
       })
 
-      return split.parse().then((sections) => {
-        expect(sections).to.length(3)
-        expect(counter).to.be.equals(3)
-        const values = [
-          duration(path.join(outputPath, 'First.mp3')),
-          duration(path.join(outputPath, 'Second.mp3')),
-          duration(path.join(outputPath, 'Third.mp3'))
-        ]
-        return Promise.all(values)
-      }).then(([ first, second, third ]) => {
-        expect(first.toString().slice(0, 3)).to.be.equals('2.5')
-        expect(second.toString().slice(0, 3)).to.be.equals('4.5')
-        expect(third.toString().slice(0, 3)).to.be.equals('1.4')
-        expect(dataEvt).to.be.true
-      })
+      const sections = await split.parse()
+      expect(sections).to.length(3)
+      expect(counter).to.be.equals(3)
+      const values = [
+        duration(path.join(outputPath, 'First.mp3')),
+        duration(path.join(outputPath, 'Second.mp3')),
+        duration(path.join(outputPath, 'Third.mp3'))
+      ]
+      const [ first, second, third ] = await Promise.all(values)
+      expect(first.toString().slice(0, 3)).to.be.equals('2.5')
+      expect(second.toString().slice(0, 3)).to.be.equals('4.5')
+      expect(third.toString().slice(0, 3)).to.be.equals('1.4')
+      expect(dataEvt).to.be.true
     })
   })
 })