├── .npmignore
├── .gitignore
├── bin
    ├── tubitv-downloader.js
    └── tubitv-downloader
    │   ├── help.js
    │   └── process_argv.js
├── package.json
├── tests
    ├── run.sh
    └── run.bat
├── lib
    ├── fallback.js
    └── process_cli.js
├── README.md
└── LICENSE.txt


/.npmignore:
--------------------------------------------------------------------------------
1 | node_modules/
2 | 
3 | tests/
4 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | node_modules/
2 | 
3 | tests/workspace/
4 | 


--------------------------------------------------------------------------------
/bin/tubitv-downloader.js:
--------------------------------------------------------------------------------
 1 | #! /usr/bin/env node
 2 | 
 3 | const argv_vals    = require('./tubitv-downloader/process_argv')
 4 | const {downloadTV} = require('../lib/process_cli')
 5 | 
 6 | downloadTV(argv_vals)
 7 | .catch(err => {
 8 |   console.log(err)
 9 | })
10 | .then(() => {
11 |   process.exit(0)
12 | })
13 | 


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "@warren-bank/node-hls-downloader-tubitv",
 3 |   "version": "2.0.0",
 4 |   "main": "lib/process_cli.js",
 5 |   "description": "Command-line utility for downloading an offline copy of TubiTV HLS video streams.",
 6 |   "license": "GPL-2.0",
 7 |   "bin": {
 8 |     "tubidl": "bin/tubitv-downloader.js"
 9 |   },
10 |   "dependencies": {
11 |     "@warren-bank/mkdir-sync": "^1.0.2",
12 |     "@warren-bank/node-hls-downloader": "^4.0.8",
13 |     "@warren-bank/node-process-argv": "^1.2.2"
14 |   },
15 |   "author": {
16 |     "name": "Warren R. Bank",
17 |     "email": "warren.r.bank@gmail.com",
18 |     "url": "https://github.com/warren-bank"
19 |   },
20 |   "repository": {
21 |     "type": "git",
22 |     "url": "https://github.com/warren-bank/node-hls-downloader-tubitv"
23 |   }
24 | }
25 | 


--------------------------------------------------------------------------------
/bin/tubitv-downloader/help.js:
--------------------------------------------------------------------------------
 1 | const help = `
 2 | tubidl <options>
 3 | 
 4 | options:
 5 | ========
 6 | "-h"
 7 | "--help"
 8 |     Print a help message describing all command-line options.
 9 | 
10 | "-v"
11 | "--version"
12 |     Display the version.
13 | 
14 | "-q"
15 | "--quiet"
16 |     Do not print a verbose log of operations.
17 | 
18 | "-ll" <integer>
19 | "--log-level" <integer>
20 |     Specify the log verbosity level.
21 |       0 = no output (same as --quiet)
22 |       1 = include only episode TubiTV URLs
23 |       2 = include only episode ffmpeg commands
24 |       3 = include all operational metadata (default)
25 | 
26 | "-dr"
27 | "--dry-run"
28 |     Do not write to the file system.
29 | 
30 | "-nm"
31 | "--no-mp4"
32 |     Do not use "ffmpeg" to bundle the downloaded video stream into an .mp4 file container.
33 | 
34 | "-mf" <integer>
35 | "--mp4-filename" <integer>
36 |     Specify the numeric mode used to configure the filename of the .mp4 file container.
37 |       0 = "video.mp4" (default)
38 |       1 = "\${movie-or-episode-title}.mp4"
39 |       2 = "\${movie-title}.mp4" or "\${series-title} - \${episode-title}.mp4"
40 | 
41 | "-mc" <integer>
42 | "--max-concurrency" <integer>
43 | "--threads" <integer>
44 |     Specify the maximum number of URLs to download in parallel.
45 |     The default is 1, which processes the download queue sequentially.
46 | 
47 | "-P" <dirpath>
48 | "--directory-prefix" <dirpath>
49 |     Specifies the directory where the resulting file structure will be saved to.
50 |     The default is "." (the current directory).
51 | 
52 | "-u" <URL>
53 | "--url" <URL>
54 |     Specify a TubiTV URL. (movie, episode, or series)
55 | 
56 | "-i <filepath>"
57 | "--input-file <filepath>"
58 |     Read TubiTV URLs from a local text file. Format is one URL per line.
59 | `
60 | 
61 | module.exports = help
62 | 


--------------------------------------------------------------------------------
/tests/run.sh:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env bash
 2 | 
 3 | DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
 4 | workspace="${DIR}/workspace"
 5 | 
 6 | [ -d "$workspace" ] && rm -rf "$workspace"
 7 | mkdir "$workspace"
 8 | cd "$workspace"
 9 | 
10 | npm init -y
11 | npm install --save "${DIR}/.."
12 | clear
13 | 
14 | PATH="${workspace}/node_modules/.bin:${PATH}"
15 | 
16 | # ------------------------------------------------------------------------------
17 | 
18 | # =================================
19 | # download a movie
20 | # =================================
21 | 
22 | tubidl -q -mc 5 -u 'https://tubitv.com/movies/300443/1984'
23 | 
24 | # ------------------------------------------------------------------------------
25 | 
26 | # =================================
27 | # download an episode
28 | # =================================
29 | 
30 | tubidl -q -mc 5 -u 'https://tubitv.com/tv-shows/200255733/s01-e01-where-is-everybody'
31 | 
32 | # ------------------------------------------------------------------------------
33 | 
34 | # =================================
35 | # download a series
36 | # =================================
37 | 
38 | tubidl -mc 5 -u 'https://tubitv.com/series/300017350/the-twilight-zone'
39 | 
40 | # ------------------------------------------------------------------------------
41 | 
42 | # =================================
43 | # print a trace of the operations
44 | # that would occur IF a series
45 | # were to be downloaded
46 | # =================================
47 | 
48 | tubidl -dr -ll 1 -u 'https://tubitv.com/series/300017350/the-twilight-zone'
49 | tubidl -dr -ll 2 -u 'https://tubitv.com/series/300017350/the-twilight-zone'
50 | tubidl -dr -ll 3 -u 'https://tubitv.com/series/300017350/the-twilight-zone'
51 | 
52 | # ------------------------------------------------------------------------------
53 | 
54 | # =================================
55 | # download a series (advanced)
56 | # =================================
57 | 
58 | tubidl -dr -ll 1 -u 'https://tubitv.com/series/300017350/the-twilight-zone' >'episode_urls.txt'
59 | tubidl -dr -ll 2 -u 'https://tubitv.com/series/300017350/the-twilight-zone' >'convert_mp4s.sh'
60 | 
61 | tubidl -nm -mc 5 -i 'episode_urls.txt' >'log.txt' 2>&1
62 | 
63 | ./convert_mp4s.sh
64 | 
65 | # ------------------------------------------------------------------------------
66 | 


--------------------------------------------------------------------------------
/tests/run.bat:
--------------------------------------------------------------------------------
 1 | @echo off
 2 | 
 3 | set DIR=%~dp0.
 4 | set workspace=%DIR%\workspace
 5 | 
 6 | if exist "%workspace%" rmdir /Q /S "%workspace%"
 7 | mkdir "%workspace%"
 8 | cd "%workspace%"
 9 | 
10 | call npm init -y
11 | call npm install --save "%DIR%\.."
12 | cls
13 | 
14 | set PATH=%workspace%\node_modules\.bin;%PATH%
15 | 
16 | rem :: -------------------------------------------------------------------------
17 | 
18 | rem :: =================================
19 | rem :: download a movie
20 | rem :: =================================
21 | 
22 | call tubidl -q -mc 5 -u "https://tubitv.com/movies/300443/1984"
23 | 
24 | rem :: -------------------------------------------------------------------------
25 | 
26 | rem :: =================================
27 | rem :: download an episode
28 | rem :: =================================
29 | 
30 | call tubidl -q -mc 5 -u "https://tubitv.com/tv-shows/200255733/s01-e01-where-is-everybody"
31 | 
32 | rem :: -------------------------------------------------------------------------
33 | 
34 | rem :: =================================
35 | rem :: download a series
36 | rem :: =================================
37 | 
38 | call tubidl -mc 5 -u "https://tubitv.com/series/300017350/the-twilight-zone"
39 | 
40 | rem :: -------------------------------------------------------------------------
41 | 
42 | rem :: =================================
43 | rem :: print a trace of the operations
44 | rem :: that would occur IF a series
45 | rem :: were to be downloaded
46 | rem :: =================================
47 | 
48 | call tubidl -dr -ll 1 -u "https://tubitv.com/series/300017350/the-twilight-zone"
49 | call tubidl -dr -ll 2 -u "https://tubitv.com/series/300017350/the-twilight-zone"
50 | call tubidl -dr -ll 3 -u "https://tubitv.com/series/300017350/the-twilight-zone"
51 | 
52 | rem :: -------------------------------------------------------------------------
53 | 
54 | rem :: =================================
55 | rem :: download a series (advanced)
56 | rem :: =================================
57 | 
58 | call tubidl -dr -ll 1 -u "https://tubitv.com/series/300017350/the-twilight-zone" >"episode_urls.txt"
59 | call tubidl -dr -ll 2 -u "https://tubitv.com/series/300017350/the-twilight-zone" >"convert_mp4s.bat"
60 | 
61 | call tubidl -nm -mc 5 -i "episode_urls.txt" >"log.txt" 2>&1
62 | 
63 | call "convert_mp4s.bat"
64 | 
65 | rem :: -------------------------------------------------------------------------
66 | 
67 | echo.
68 | pause
69 | 


--------------------------------------------------------------------------------
/bin/tubitv-downloader/process_argv.js:
--------------------------------------------------------------------------------
  1 | const process_argv = require('@warren-bank/node-process-argv')
  2 | 
  3 | const path = require('path')
  4 | const fs   = require('fs')
  5 | 
  6 | const argv_flags = {
  7 |   "--help":                   {bool:  true},
  8 |   "--version":                {bool:  true},
  9 |   "--quiet":                  {bool:  true},
 10 |   "--dry-run":                {bool:  true},
 11 |   "--no-mp4":                 {bool:  true},
 12 |   "--log-level":              {num:   "int"},
 13 |   "--mp4-filename":           {num:   "int"},
 14 |   "--max-concurrency":        {num:   "int"},
 15 |   "--directory-prefix":       {},
 16 |   "--url":                    {},
 17 |   "--input-file":             {file: "lines"}
 18 | }
 19 | 
 20 | const argv_flag_aliases = {
 21 |   "--help":                   ["-h"],
 22 |   "--version":                ["-v"],
 23 |   "--quiet":                  ["-q"],
 24 |   "--dry-run":                ["-dr"],
 25 |   "--no-mp4":                 ["-nm"],
 26 |   "--log-level":              ["-ll"],
 27 |   "--mp4-filename":           ["-mf"],
 28 |   "--max-concurrency":        ["-mc", "--threads"],
 29 |   "--directory-prefix":       ["-P"],
 30 |   "--url":                    ["-u"],
 31 |   "--input-file":             ["-i"]
 32 | }
 33 | 
 34 | let argv_vals = {}
 35 | 
 36 | try {
 37 |   argv_vals = process_argv(argv_flags, argv_flag_aliases)
 38 | }
 39 | catch(e) {
 40 |   console.log('ERROR: ' + e.message)
 41 |   process.exit(1)
 42 | }
 43 | 
 44 | if (argv_vals["--help"]) {
 45 |   const help = require('./help')
 46 |   console.log(help)
 47 |   process.exit(0)
 48 | }
 49 | 
 50 | if (argv_vals["--version"]) {
 51 |   const data = require('../../package.json')
 52 |   console.log(data.version)
 53 |   process.exit(0)
 54 | }
 55 | 
 56 | if (typeof argv_vals["--log-level"] !== 'number') {
 57 |   argv_vals["--log-level"] = 3
 58 | }
 59 | if (argv_vals["--log-level"] <= 0) {
 60 |   argv_vals["--log-level"] = 0
 61 |   argv_vals["--quiet"] = true
 62 | }
 63 | if (argv_vals["--log-level"] > 3) {
 64 |   argv_vals["--log-level"] = 3
 65 | }
 66 | 
 67 | if (typeof argv_vals["--max-concurrency"] === 'number') {
 68 |   if (argv_vals["--max-concurrency"] < 1) {
 69 |     argv_vals["--max-concurrency"] = 1
 70 |   }
 71 | }
 72 | 
 73 | if (!argv_vals["--directory-prefix"]) {
 74 |   argv_vals["--directory-prefix"] = process.cwd()
 75 | }
 76 | 
 77 | if (argv_vals["--directory-prefix"]) {
 78 |   argv_vals["--directory-prefix"] = path.resolve(argv_vals["--directory-prefix"])
 79 | 
 80 |   if (! fs.existsSync(argv_vals["--directory-prefix"])) {
 81 |     console.log('ERROR: Output directory does not exist')
 82 |     process.exit(0)
 83 |   }
 84 | }
 85 | 
 86 | if (argv_vals["--input-file"] && argv_vals["--input-file"].length) {
 87 |   if (argv_vals["--url"]) {
 88 |     argv_vals["--input-file"].unshift(argv_vals["--url"])
 89 |     delete argv_vals["--url"]
 90 |   }
 91 | }
 92 | else if (!argv_vals["--url"]) {
 93 |   console.log('ERROR: TubiTV URL is required')
 94 |   process.exit(0)
 95 | }
 96 | 
 97 | if (argv_vals["--dry-run"] && argv_vals["--quiet"]) {
 98 |   console.log('WARNING: Nothing to do')
 99 |   process.exit(0)
100 | }
101 | 
102 | module.exports = argv_vals
103 | 


--------------------------------------------------------------------------------
/lib/fallback.js:
--------------------------------------------------------------------------------
  1 | const path  = require('path')
  2 | const fs    = require('fs')
  3 | const spawn = require('child_process').exec
  4 | 
  5 | const catch_ffmpeg_conversion_error = function(error) {
  6 |   // rethrow error if it didn't come from ffmpeg
  7 |   if (!error.cmd || (error.cmd.indexOf('ffmpeg') !== 0))
  8 |     throw error
  9 | }
 10 | 
 11 | const run_fallback_ffmpeg_video_conversion = function(configHLS, results){
 12 |   return new Promise((resolve, reject) => {
 13 |     if (!configHLS["--mp4"]) {
 14 |       resolve(results)
 15 |       return
 16 |     }
 17 | 
 18 |     if (fs.existsSync(configHLS["--mp4"])) {
 19 |       resolve(results)
 20 |       return
 21 |     }
 22 | 
 23 |     const media = {
 24 |       video: {
 25 |         path:  null,
 26 |         found: false
 27 |       },
 28 |       audio: {
 29 |         paths:   [],
 30 |         names:   [],
 31 |         default: 0,
 32 |         found:   false
 33 |       }
 34 |     }
 35 | 
 36 |     try {
 37 |       find_media_video(configHLS, media.video)
 38 |       find_media_audio(configHLS, media.audio)
 39 |     }
 40 |     catch(error) {
 41 |       reject(error)
 42 |       return
 43 |     }
 44 | 
 45 |     console.log("starting fallback ffmpeg conversion to mp4 file..")
 46 | 
 47 |     perform_fallback_ffmpeg_video_conversion(configHLS, media)
 48 |     .then(() => {
 49 |       console.log("done")
 50 |       console.log("")
 51 | 
 52 |       resolve(results)
 53 |     })
 54 |     .catch((error) => {
 55 |       console.log("ffmpeg error:")
 56 | 
 57 |       reject(error)
 58 |     })
 59 |   })
 60 | }
 61 | 
 62 | const find_media_video = function(configHLS, video) {
 63 |   video.path  = path.join(configHLS["--directory-prefix"], 'video', 'segment_0.ts')
 64 |   video.found = fs.existsSync(video.path)
 65 | 
 66 |   if (!video.found)
 67 |     throw new Error('ffmpeg error: video media file not found')
 68 | }
 69 | 
 70 | const find_media_audio = function(configHLS, audio) {
 71 |   search_media_audio(configHLS, audio)
 72 | 
 73 |   if (!audio.found)
 74 |     throw new Error('ffmpeg error: audio media file not found')
 75 | 
 76 |   if (audio.names.length > 1) {
 77 |     const default_streams = ['stream_0', 'english']
 78 | 
 79 |     for (let stream of default_streams) {
 80 |       const stream_index = audio.names.indexOf(stream)
 81 | 
 82 |       if (stream_index >= 0) {
 83 |         audio.default = stream_index
 84 |         break
 85 |       }
 86 |     }
 87 |   }
 88 | }
 89 | 
 90 | const search_media_audio = function(configHLS, audio) {
 91 |   const audio_dir = path.join(configHLS["--directory-prefix"], 'audio')
 92 |   if (!fs.existsSync(audio_dir)) return
 93 | 
 94 |   const stream_entries = fs.readdirSync(audio_dir, {withFileTypes: true})
 95 |   for (let stream_entry of stream_entries) {
 96 |     if (stream_entry.isDirectory()) {
 97 |       const audio_path  = path.join(audio_dir, stream_entry.name, 'segment_0.aac')
 98 |       const audio_found = fs.existsSync(audio_path)
 99 | 
100 |       if (audio_found) {
101 |         audio.paths.push(audio_path)
102 |         audio.names.push(stream_entry.name)
103 |         audio.found = true
104 |       }
105 |     }
106 |   }
107 | }
108 | 
109 | const perform_fallback_ffmpeg_video_conversion = function(configHLS, media){
110 |   if (media.audio.paths.length === 1) {
111 |     return perform_fallback_ffmpeg_video_conversion_with_one_audio_stream(configHLS, media)
112 |   }
113 |   else if (media.audio.paths.length > 1) {
114 |     return perform_fallback_ffmpeg_video_conversion_with_multiple_audio_streams(configHLS, media)
115 |     .catch(() => perform_fallback_ffmpeg_video_conversion_with_one_audio_stream(configHLS, media))
116 |   }
117 | }
118 | 
119 | const perform_fallback_ffmpeg_video_conversion_with_one_audio_stream = function(configHLS, media){
120 |   return new Promise((resolve, reject) => {
121 |     const cmd = [
122 |       'ffmpeg',
123 |       '-nostats -hide_banner -loglevel panic',
124 |       `-i "${media.video.path}"`,
125 |       `-i "${media.audio.paths[media.audio.default]}"`,
126 |       '-c copy',
127 |       '-movflags +faststart',
128 |       configHLS["--mp4-ffmpeg-options"],
129 |       qq(configHLS["--mp4"])
130 |     ].join(' ')
131 | 
132 |     const opt = {cwd: configHLS["--directory-prefix"]}
133 | 
134 |     spawn(cmd, opt, (error, stdout, stderr) => {
135 |       if (error)
136 |         reject(error)
137 |       else
138 |         resolve()
139 |     })
140 |   })
141 | }
142 | 
143 | const perform_fallback_ffmpeg_video_conversion_with_multiple_audio_streams = function(configHLS, media){
144 |   return new Promise((resolve, reject) => {
145 |     const cmd = [
146 |       'ffmpeg',
147 |       '-nostats -hide_banner -loglevel panic',
148 |       `-i "${media.video.path}"`,
149 |       ...media.audio.paths.map((path, index) => `-i "${path}"`),
150 |       '-map "0:v"',
151 |       ...media.audio.paths.map((path, index) => `-map "${index + 1}:a"`),
152 |       '-c copy',
153 |       '-movflags +faststart',
154 |       configHLS["--mp4-ffmpeg-options"],
155 |       ...media.audio.names.map((name, index) => `-metadata:s:a:${index} title="${name}"`),
156 |       ...media.audio.names.map((name, index) => `-metadata:s:a:${index} language="${normalize_language_name(name)}"`),
157 |       `-disposition:a:${media.audio.default} default`,
158 |       qq(configHLS["--mp4"])
159 |     ].join(' ')
160 | 
161 |     const opt = {cwd: configHLS["--directory-prefix"]}
162 | 
163 |     spawn(cmd, opt, (error, stdout, stderr) => {
164 |       if (error)
165 |         reject(error)
166 |       else
167 |         resolve()
168 |     })
169 |   })
170 | }
171 | 
172 | const qq = (text) => `"${text}"`
173 | 
174 | const normalize_language_name_regex = /^.*?([A-Za-z_-]+).*$/
175 | const normalize_language_name = (name) => name.replace(normalize_language_name_regex, '$1')
176 | 
177 | module.exports = {
178 |   catch_ffmpeg_conversion_error,
179 |   run_fallback_ffmpeg_video_conversion
180 | }
181 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | ### [TubiTV Downloader](https://github.com/warren-bank/node-hls-downloader-tubitv)
  2 | 
  3 | Command-line utility for downloading an offline copy of [TubiTV](https://tubitv.com/) HLS video streams.
  4 | 
  5 | #### Features:
  6 | 
  7 | * accepts URLs that identify:
  8 |   - a single movie
  9 |   - a single episode contained in a series
 10 |   - an entire series
 11 |     * includes all episodes in every seasons
 12 | * downloads:
 13 |   - the highest available quality for each video stream
 14 |   - _.srt_ subtitles for all available languages
 15 |   - will continue upon restart after an abrupt interruption
 16 | * resulting file structure:
 17 |   ```bash
 18 |     |- {title_series}/
 19 |     |  |- {title_episode}/
 20 |     |  |  |- hls/
 21 |     |  |  |  |- video/
 22 |     |  |  |  |  |- *.ts
 23 |     |  |  |  |- audio/
 24 |     |  |  |  |  |- {language}/
 25 |     |  |  |  |  |  |- *.ts
 26 |     |  |  |  |  |- {language}.m3u8
 27 |     |  |  |  |- subtitles/
 28 |     |  |  |  |  |- {language}/
 29 |     |  |  |  |  |  |- *.vtt
 30 |     |  |  |  |  |- {language}.m3u8
 31 |     |  |  |  |- video.m3u8
 32 |     |  |  |  |- master.m3u8
 33 |     |  |  |- mp4/
 34 |     |  |  |  |- video.mp4
 35 |     |  |  |  |- video.{language}.srt
 36 |   ```
 37 | 
 38 | - - - -
 39 | 
 40 | #### Installation:
 41 | 
 42 | ```bash
 43 | npm install --global @warren-bank/node-hls-downloader-tubitv
 44 | ```
 45 | 
 46 | #### Usage:
 47 | 
 48 | ```bash
 49 | tubidl <options>
 50 | 
 51 | options:
 52 | ========
 53 | "-h"
 54 | "--help"
 55 |     Print a help message describing all command-line options.
 56 | 
 57 | "-v"
 58 | "--version"
 59 |     Display the version.
 60 | 
 61 | "-q"
 62 | "--quiet"
 63 |     Do not print a verbose log of operations.
 64 | 
 65 | "-ll" <integer>
 66 | "--log-level" <integer>
 67 |     Specify the log verbosity level.
 68 |       0 = no output (same as --quiet)
 69 |       1 = include only episode TubiTV URLs
 70 |       2 = include only episode ffmpeg commands
 71 |       3 = include all operational metadata (default)
 72 | 
 73 | "-dr"
 74 | "--dry-run"
 75 |     Do not write to the file system.
 76 | 
 77 | "-nm"
 78 | "--no-mp4"
 79 |     Do not use "ffmpeg" to bundle the downloaded video stream into an .mp4 file container.
 80 | 
 81 | "-mf" <integer>
 82 | "--mp4-filename" <integer>
 83 |     Specify the numeric mode used to configure the filename of the .mp4 file container.
 84 |       0 = "video.mp4" (default)
 85 |       1 = "${movie-or-episode-title}.mp4"
 86 |       2 = "${movie-title}.mp4" or "${series-title} - ${episode-title}.mp4"
 87 | 
 88 | "-mc" <integer>
 89 | "--max-concurrency" <integer>
 90 | "--threads" <integer>
 91 |     Specify the maximum number of URLs to download in parallel.
 92 |     The default is 1, which processes the download queue sequentially.
 93 | 
 94 | "-P" <dirpath>
 95 | "--directory-prefix" <dirpath>
 96 |     Specifies the directory where the resulting file structure will be saved to.
 97 |     The default is "." (the current directory).
 98 | 
 99 | "-u" <URL>
100 | "--url" <URL>
101 |     Specify a TubiTV URL. (movie, episode, or series)
102 | 
103 | "-i <filepath>"
104 | "--input-file <filepath>"
105 |     Read TubiTV URLs from a local text file. Format is one URL per line.
106 | ```
107 | 
108 | #### Example:
109 | 
110 | * download a movie:
111 |   ```bash
112 |     tubidl -q -mc 5 -u 'https://tubitv.com/movies/300443/1984'
113 |   ```
114 | * download an episode:
115 |   ```bash
116 |     tubidl -q -mc 5 -u 'https://tubitv.com/tv-shows/200255733/s01-e01-where-is-everybody'
117 |   ```
118 | * download a series:
119 |   ```bash
120 |     tubidl -mc 5 -u 'https://tubitv.com/series/300017350/the-twilight-zone'
121 |   ```
122 | * print a trace of the operations that would occur IF a series were to be downloaded:
123 |   ```bash
124 |     tubidl -dr -ll 1 -u 'https://tubitv.com/series/300017350/the-twilight-zone'
125 |     tubidl -dr -ll 2 -u 'https://tubitv.com/series/300017350/the-twilight-zone'
126 |     tubidl -dr -ll 3 -u 'https://tubitv.com/series/300017350/the-twilight-zone'
127 |   ```
128 | * download a series (advanced):
129 |   ```bash
130 |     tubidl -dr -ll 1 -u 'https://tubitv.com/series/300017350/the-twilight-zone' >'episode_urls.txt'
131 |     tubidl -dr -ll 2 -u 'https://tubitv.com/series/300017350/the-twilight-zone' >'convert_mp4s.sh'
132 | 
133 |     tubidl -nm -mc 5 -i 'episode_urls.txt' >'log.txt' 2>&1
134 | 
135 |     ./convert_mp4s.sh
136 |   ```
137 | 
138 | ##### Suggestions:
139 | 
140 | 1. download with options: `--no-mp4 --log-level 3`
141 |    * redirect stdout to a log file
142 |    * when download completes, check the log file for any error messages
143 |    * if any _.ts_ chunks encountered a download problem
144 |      - identify the url of the TubiTV page that was being processed when this error occurred
145 |      - redownload that page (using the same `--directory-prefix`)
146 |        * all previously downloaded data __not__ be modified or deleted
147 |        * only missing data will be retrieved
148 | 2. repeat the above process until the log file shows no download errors
149 | 3. finally, convert the HLS stream to mp4
150 |    * the `ffmpeg` command to perform this conversion is included in the log file
151 |    * when converting the episodes in a series, a list of all `ffmpeg` commands can be generated with the options: `--dry-run --log-level 2`
152 | 
153 | - - - -
154 | 
155 | #### Requirements:
156 | 
157 | * Node.js version: v8.6.0 (and higher)
158 |   - transitive [dependency](https://github.com/warren-bank/node-hls-downloader-tubitv/blob/master/package.json#L12-L13) requirements:
159 |     * v8.06.00+: [`@warren-bank/node-hls-downloader`](https://github.com/warren-bank/node-hls-downloader#requirements)
160 |     * v8.06.00+: [`@warren-bank/node-process-argv`](https://github.com/warren-bank/node-process-argv#requirements)
161 | * FFmpeg
162 |   - not required in `PATH` when using the `--no-mp4` CLI option
163 |     * successfully tested with version: 4.1.3
164 | 
165 | #### Legal:
166 | 
167 | * copyright: [Warren Bank](https://github.com/warren-bank)
168 | * license: [GPL-2.0](https://www.gnu.org/licenses/old-licenses/gpl-2.0.txt)
169 | 


--------------------------------------------------------------------------------
/lib/process_cli.js:
--------------------------------------------------------------------------------
  1 | const mkdirSync = require('@warren-bank/mkdir-sync')
  2 | const {requestHTTP, downloadHTTP, downloadHLS} = require('@warren-bank/node-hls-downloader')
  3 | 
  4 | const fallback = require('./fallback')
  5 | const path     = require('path')
  6 | const fs       = require('fs')
  7 | 
  8 | // -----------------------------------------------------------------------------
  9 | // returns a Promise that resolves after all downloads are complete.
 10 | 
 11 | const process_cli = function(argv_vals){
 12 | 
 13 |   const download_file = async function(url){
 14 |     let file
 15 |     try {
 16 |       file = await requestHTTP(url)
 17 |       file = file.response.toString()
 18 |     }
 19 |     catch(err) {
 20 |       file = ""
 21 |     }
 22 |     return file
 23 |   }
 24 | 
 25 |   // ---------------------------------------------------------------------------
 26 | 
 27 |   const regex_url = /^https?:\/\/(?:[^\.]+\.)*tubitv\.com\/(movies|tv-shows|series)\/([^\/]+)(?:\/.*)?$/i
 28 | 
 29 |   const parse_url = function(url){
 30 |     const matches = regex_url.exec(url)
 31 |     let type
 32 | 
 33 |     if (!matches)
 34 |       throw new Error(`Error: cannot parse format of TubiTV URL: '${url}'`)
 35 | 
 36 |     switch(matches[1].toLowerCase()) {
 37 |       case 'movies':
 38 |         type = 'movie'
 39 |         break
 40 |       case 'tv-shows':
 41 |         type = 'episode'
 42 |         break
 43 |       case 'series':
 44 |         type = 'series'
 45 |         break
 46 |     }
 47 | 
 48 |     if (!type)
 49 |       throw new Error(`Error: unrecognized page type '${matches[1]}' in TubiTV URL: '${url}'`)
 50 | 
 51 |     return {type, video_id: matches[2]}
 52 |   }
 53 | 
 54 |   const process_url = async function(url){
 55 |     const {type, video_id} = parse_url(url)
 56 | 
 57 |     // short-circuit optimization
 58 |     if (argv_vals["--dry-run"] && (argv_vals["--log-level"] === 1)) {
 59 |       if (type === 'episode') console.log(url)
 60 |       if (type !== 'series')  return
 61 |     }
 62 | 
 63 |     const html = await download_file(url)
 64 |     if (!html) throw new Error(`Error: empty server response at URL: '${url}'`)
 65 | 
 66 |     await process_html(html, type, video_id, url)
 67 |   }
 68 | 
 69 |   // ---------------------------------------------------------------------------
 70 | 
 71 |   const regex_html_json = /^.*>window\.__REACT_QUERY_STATE__=({.*?});<.*$/i
 72 | 
 73 |   const process_html = async function(html, type, video_id, url){
 74 |     let matches, json, data, video_series
 75 | 
 76 |     html = html.replace(/[\r\n]+/g, ' ')
 77 | 
 78 |     matches = regex_html_json.exec(html)
 79 |     if (!matches) throw new Error(`Error: no ${type} video stream found in server response at URL: '${url}'`)
 80 | 
 81 |     json = matches[1]
 82 | 
 83 |     // fix JSON
 84 |     json = json.replace(/undefined/g, 'null')
 85 |     json = json.replace(/new Date\([^\)]*\)/g, 'null')
 86 | 
 87 |     try {
 88 |       data = JSON.parse(json)
 89 |     }
 90 |     catch(err) {
 91 |       throw new Error(`Error: parsing JSON metadata for ${type} video stream in server response at URL: '${url}'`)
 92 |     }
 93 | 
 94 |     if (!data || !(data instanceof Object))
 95 |       throw new Error(`Error: non-object metadata for ${type} video stream in server response at URL: '${url}'`)
 96 | 
 97 |     html    = null
 98 |     matches = null
 99 |     json    = null
100 | 
101 |     switch(type) {
102 |       case 'episode':
103 |         video_series = extract_video_series_from_page_data(data)
104 |         if (!video_series) throw new Error(`Error: video series object not found in metadata for ${type} in server response at URL: '${url}'`)
105 |       case 'movie':
106 |         const video_stream = extract_video_stream_from_page_data(video_id, data)
107 |         if (!video_stream) throw new Error(`Error: video stream object not found in metadata for ${type} in server response at URL: '${url}'`)
108 | 
109 |         await process_video_stream(video_series, video_stream, type, url)
110 |         break
111 |       case 'series':
112 |         const episodes = extract_episodes_in_series_from_page_data(data)
113 |         if (!episodes) throw new Error(`Error: list of episodes not found in metadata for ${type} in server response at URL: '${url}'`)
114 | 
115 |         await process_series_episodes(episodes)
116 |         break
117 |     }
118 |   }
119 | 
120 |   const extract_video_series_from_page_data = function(page_data) {
121 |     if (page_data && (page_data instanceof Object) && Array.isArray(page_data.queries)) {
122 |       for (let query of page_data.queries) {
123 |         try {
124 |           if (Array.isArray(query.state.data.pages)) {
125 |             for (let page of query.state.data.pages) {
126 |               if (page && (page instanceof Object) && (page.type === 's') && page.title) {
127 |                 return {title: page.title}
128 |               }
129 |             }
130 |           }
131 |         }
132 |         catch(e) {}
133 |       }
134 |     }
135 | 
136 |     return null
137 |   }
138 | 
139 |   const extract_video_stream_from_page_data = function(video_id, page_data) {
140 |     if (video_id && page_data && (page_data instanceof Object) && Array.isArray(page_data.queries)) {
141 |       for (let query of page_data.queries) {
142 |         try {
143 |           if (Array.isArray(query.state.data.pages)) {
144 |             for (let page of query.state.data.pages) {
145 |               if (page && (page instanceof Object) && (page.type === 'v') && (page.id === video_id)) {
146 |                 return page
147 |               }
148 |             }
149 |           }
150 |         }
151 |         catch(e) {}
152 |       }
153 |     }
154 | 
155 |     return null
156 |   }
157 | 
158 |   const extract_episodes_in_series_from_page_data = function(page_data) {
159 |     const episodes = []
160 |     var query, season, episode
161 | 
162 |     if (page_data && (page_data instanceof Object) && Array.isArray(page_data.queries)) {
163 |       for (let query of page_data.queries) {
164 |         try {
165 |           if (Array.isArray(query.state.data.seasons)) {
166 |             for (let season of query.state.data.seasons) {
167 |               if (season && (season instanceof Object) && Array.isArray(season.episodes)) {
168 |                 for (let episode of season.episodes) {
169 |                   if (episode && (episode instanceof Object) && episode.id && episode.num) {
170 |                     episodes.push({video_id: episode.id})
171 |                   }
172 |                 }
173 |               }
174 |             }
175 |           }
176 |         }
177 |         catch(e) {}
178 |       }
179 |     }
180 | 
181 |     return episodes.length
182 |       ? episodes
183 |       : null
184 |   }
185 | 
186 |   // ---------------------------------------------------------------------------
187 |   // returns a Promise that resolves after all downloads complete (HLS video, HLS audio, VTT subtitles, SRT subtitles) for a single movie or TV episode
188 | 
189 |   const process_video_stream = function(video_series, video_stream, type, url){
190 |     let subtitles
191 | 
192 |     const configMP4 = {
193 |       "--filename":           get_mp4_filename()
194 |     }
195 | 
196 |     const configHLS = {
197 |       "--no-clobber":         false,
198 |       "--continue":           true,
199 |     
200 |       "--url":                null,
201 |       "--max-concurrency":    argv_vals["--max-concurrency"],
202 |     
203 |       "--directory-prefix":   null,
204 |       "--mp4":                null,
205 |       "--mp4-ffmpeg-options": '',
206 |     
207 |       "--skip-video":         false,
208 |       "--skip-audio":         false,
209 |       "--skip-subtitles":     false,
210 |     
211 |       "--min-bandwidth":      null,
212 |       "--max-bandwidth":      null,
213 |       "--highest-quality":    true,
214 |       "--lowest-quality":     false,
215 |     
216 |       "--all-audio":          true,
217 |       "--all-subtitles":      true,
218 |       "--filter-audio":       null,
219 |       "--filter-subtitles":   null
220 |     }
221 | 
222 |     const configHTTP = {
223 |       "--input-file":         null,
224 |       "--directory-prefix":   null,
225 |       "--no-clobber":         true,
226 |       "--max-concurrency":    argv_vals["--max-concurrency"]
227 |     }
228 | 
229 |     if (type === 'movie') {
230 |       if (!video_stream || !video_stream.url || !video_stream.title)
231 |         throw new Error(`Assertion Error: missing data fields in video object metadata for ${type} video stream in server response at URL: '${url}'`)
232 | 
233 |       configHLS["--url"]                  = video_stream.url
234 |       configHLS["--directory-prefix"]     = path.join(argv_vals["--directory-prefix"], sanitize_title(video_stream.title), 'hls')
235 | 
236 |       if (!argv_vals["--no-mp4"]) {
237 |         configHLS["--mp4"]                = path.join(argv_vals["--directory-prefix"], sanitize_title(video_stream.title), 'mp4')
238 |         configHLS["--mp4-ffmpeg-options"] = `-metadata title="${ sanitize_title(video_stream.title) }"`
239 |         configMP4["--filename"]           = get_mp4_filename(video_stream.title)
240 |       }
241 | 
242 |       configHTTP["--directory-prefix"]    = path.join(argv_vals["--directory-prefix"], sanitize_title(video_stream.title), 'mp4')
243 | 
244 |       subtitles = video_stream.subtitles
245 |     }
246 | 
247 |     if (type === 'episode') {
248 |       if (!video_series || !video_series.title)
249 |         throw new Error(`Assertion Error: missing data fields in video object metadata for ${type} video stream in server response at URL: '${url}'`)
250 | 
251 |       if (!video_stream || !video_stream.url || !video_stream.title)
252 |         throw new Error(`Assertion Error: missing data fields in video object metadata for ${type} video stream in server response at URL: '${url}'`)
253 | 
254 |       configHLS["--url"]                  = video_stream.url
255 |       configHLS["--directory-prefix"]     = path.join(argv_vals["--directory-prefix"], sanitize_title(video_series.title), sanitize_title(video_stream.title), 'hls')
256 | 
257 |       if (!argv_vals["--no-mp4"]) {
258 |         configHLS["--mp4"]                = path.join(argv_vals["--directory-prefix"], sanitize_title(video_series.title), sanitize_title(video_stream.title), 'mp4')
259 |         configHLS["--mp4-ffmpeg-options"] = `-metadata show="${ sanitize_title(video_series.title) }" -metadata title="${ sanitize_title(video_stream.title) }"`
260 |         configMP4["--filename"]           = get_mp4_filename(video_stream.title, video_series.title)
261 |       }
262 | 
263 |       configHTTP["--directory-prefix"]    = path.join(argv_vals["--directory-prefix"], sanitize_title(video_series.title), sanitize_title(video_stream.title), 'mp4')
264 | 
265 |       subtitles = video_stream.subtitles
266 |     }
267 | 
268 |     if (!argv_vals["--quiet"]) {
269 |       let outputdir = path.dirname(configHLS["--directory-prefix"])
270 |       let ffmpegcmd = `cd "${configHLS["--directory-prefix"]}" && mkdir "${path.join('..', 'mp4')}" & ffmpeg -allowed_extensions ALL -i "master.m3u8" -c copy -movflags +faststart ${configHLS["--mp4-ffmpeg-options"]} "${path.join('..', 'mp4', `${configMP4["--filename"]}.mp4`)}"`
271 | 
272 |       switch(argv_vals["--log-level"]) {
273 |         case 1:
274 |           if (type === 'episode')
275 |             console.log(url)
276 |           break
277 |         case 2:
278 |           if (type === 'episode')
279 |             console.log(ffmpegcmd)
280 |           break
281 |         case 3:
282 |           console.log(`processing page:\n  ${url}\ntype:\n  ${type}\nHLS manifest:\n  ${configHLS["--url"]}\noutput directory:\n  ${outputdir}\nmp4 conversion${argv_vals["--no-mp4"] ? ' (skipped)' : ''}:\n  ${ffmpegcmd}`)
283 |           break
284 |         case 0:
285 |         default:
286 |           // noop
287 |           break
288 |       }
289 |     }
290 | 
291 |     if (argv_vals["--dry-run"]) {
292 |       return Promise.resolve()
293 |     }
294 |     else {
295 |       const promises = []
296 |       let promise
297 | 
298 |       promise = start_downloadHLS(configHLS, configMP4)
299 |       promises.push(promise)
300 | 
301 |       if (subtitles && subtitles.length) {
302 |         subtitles = subtitles.filter(obj => (obj.url && obj.lang))
303 |       }
304 | 
305 |       if (subtitles && subtitles.length) {
306 |         configHTTP["--input-file"] = subtitles.map(obj => `${obj.url}\t${configMP4["--filename"]}.${obj.lang.toLowerCase()}.srt`)
307 | 
308 |         promise = start_downloadHTTP(configHTTP)
309 |         promises.push(promise)
310 |       }
311 | 
312 |       return Promise.all(promises)
313 |         .catch(fallback.catch_ffmpeg_conversion_error)
314 |         .then(fallback.run_fallback_ffmpeg_video_conversion.bind(null, configHLS))
315 |     }
316 |   }
317 | 
318 |   const get_mp4_filename = (video_title, series_title) => {
319 |     let mode = Number(argv_vals["--mp4-filename"]) || 0
320 | 
321 |     if (isNaN(mode))
322 |       mode = 0
323 | 
324 |     if (mode < 0)
325 |       mode = 0
326 | 
327 |     if (mode > 2)
328 |       mode = 2
329 | 
330 |     if ((mode == 2) && !series_title)
331 |       mode = 1
332 | 
333 |     if ((mode == 1) && !video_title)
334 |       mode = 0
335 | 
336 |     switch(mode) {
337 |       case 2:
338 |         return `${ sanitize_title(series_title) } - ${ sanitize_title(video_title) }`
339 |       case 1:
340 |         return sanitize_title(video_title)
341 |       case 0:
342 |       default:
343 |         return 'video'
344 |     }
345 |   }
346 | 
347 |   const sanitize_title = (title) => title.replace(/[\\\/\*\?:"<>|]+/g, '').trim()
348 | 
349 |   const start_downloadHLS = (configHLS, configMP4) => {
350 |     if (configHLS["--directory-prefix"]) {
351 |       mkdirSync(configHLS["--directory-prefix"], {recursive: true})
352 | 
353 |       // files
354 |       ;["master.m3u8","video.m3u8"].forEach(child => {
355 |         let childpath = path.join(configHLS["--directory-prefix"], child)
356 |         if (fs.existsSync(childpath))
357 |           fs.unlinkSync(childpath)
358 |       })
359 |     }
360 | 
361 |     if (configHLS["--mp4"]) {
362 |       mkdirSync(configHLS["--mp4"], {recursive: true})
363 | 
364 |       configHLS["--mp4"] = path.join(configHLS["--mp4"], `${configMP4["--filename"]}.mp4`)
365 | 
366 |       if (fs.existsSync(configHLS["--mp4"]))
367 |         fs.unlinkSync(configHLS["--mp4"])
368 |     }
369 | 
370 |     // Promise
371 |     return downloadHLS(configHLS)
372 |   }
373 | 
374 |   const start_downloadHTTP = (configHTTP) => {
375 |     if (configHTTP["--directory-prefix"])
376 |       mkdirSync(configHTTP["--directory-prefix"], {recursive: true})
377 | 
378 |     // Promise
379 |     return downloadHTTP(configHTTP)
380 |   }
381 | 
382 |   // ---------------------------------------------------------------------------
383 |   // returns a Promise that resolves after all downloads complete for all episodes in all seasons of a series
384 | 
385 |   const process_series_episodes = async function(episodes){
386 |     while(episodes.length) {
387 |       const episode = episodes.shift()
388 |       const url = `https://tubitv.com/tv-shows/${episode.video_id}`
389 |       await process_url(url)
390 |     }
391 |   }
392 | 
393 |   // ---------------------------------------------------------------------------
394 |   // returns a Promise that resolves after all URLs in command-line have been processed
395 | 
396 |   const process_argv = async function(){
397 |     if (argv_vals["--input-file"] && argv_vals["--input-file"].length) {
398 |       while(argv_vals["--input-file"].length) {
399 |         let url = argv_vals["--input-file"].shift()
400 |         await process_url(url)
401 |       }
402 |     }
403 |     else {
404 |       let url = argv_vals["--url"]
405 |       await process_url(url)
406 |     }
407 |   }
408 | 
409 |   return process_argv()
410 | }
411 | 
412 | // -----------------------------------------------------------------------------
413 | 
414 | module.exports = {requestHTTP, downloadHTTP, downloadHLS, downloadTV: process_cli}
415 | 


--------------------------------------------------------------------------------
/LICENSE.txt:
--------------------------------------------------------------------------------
  1 |                     GNU GENERAL PUBLIC LICENSE
  2 |                        Version 2, June 1991
  3 | 
  4 |  Copyright (C) 1989, 1991 Free Software Foundation, Inc.,
  5 |  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  6 |  Everyone is permitted to copy and distribute verbatim copies
  7 |  of this license document, but changing it is not allowed.
  8 | 
  9 |                             Preamble
 10 | 
 11 |   The licenses for most software are designed to take away your
 12 | freedom to share and change it.  By contrast, the GNU General Public
 13 | License is intended to guarantee your freedom to share and change free
 14 | software--to make sure the software is free for all its users.  This
 15 | General Public License applies to most of the Free Software
 16 | Foundation's software and to any other program whose authors commit to
 17 | using it.  (Some other Free Software Foundation software is covered by
 18 | the GNU Lesser General Public License instead.)  You can apply it to
 19 | your programs, too.
 20 | 
 21 |   When we speak of free software, we are referring to freedom, not
 22 | price.  Our General Public Licenses are designed to make sure that you
 23 | have the freedom to distribute copies of free software (and charge for
 24 | this service if you wish), that you receive source code or can get it
 25 | if you want it, that you can change the software or use pieces of it
 26 | in new free programs; and that you know you can do these things.
 27 | 
 28 |   To protect your rights, we need to make restrictions that forbid
 29 | anyone to deny you these rights or to ask you to surrender the rights.
 30 | These restrictions translate to certain responsibilities for you if you
 31 | distribute copies of the software, or if you modify it.
 32 | 
 33 |   For example, if you distribute copies of such a program, whether
 34 | gratis or for a fee, you must give the recipients all the rights that
 35 | you have.  You must make sure that they, too, receive or can get the
 36 | source code.  And you must show them these terms so they know their
 37 | rights.
 38 | 
 39 |   We protect your rights with two steps: (1) copyright the software, and
 40 | (2) offer you this license which gives you legal permission to copy,
 41 | distribute and/or modify the software.
 42 | 
 43 |   Also, for each author's protection and ours, we want to make certain
 44 | that everyone understands that there is no warranty for this free
 45 | software.  If the software is modified by someone else and passed on, we
 46 | want its recipients to know that what they have is not the original, so
 47 | that any problems introduced by others will not reflect on the original
 48 | authors' reputations.
 49 | 
 50 |   Finally, any free program is threatened constantly by software
 51 | patents.  We wish to avoid the danger that redistributors of a free
 52 | program will individually obtain patent licenses, in effect making the
 53 | program proprietary.  To prevent this, we have made it clear that any
 54 | patent must be licensed for everyone's free use or not licensed at all.
 55 | 
 56 |   The precise terms and conditions for copying, distribution and
 57 | modification follow.
 58 | 
 59 |                     GNU GENERAL PUBLIC LICENSE
 60 |    TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
 61 | 
 62 |   0. This License applies to any program or other work which contains
 63 | a notice placed by the copyright holder saying it may be distributed
 64 | under the terms of this General Public License.  The "Program", below,
 65 | refers to any such program or work, and a "work based on the Program"
 66 | means either the Program or any derivative work under copyright law:
 67 | that is to say, a work containing the Program or a portion of it,
 68 | either verbatim or with modifications and/or translated into another
 69 | language.  (Hereinafter, translation is included without limitation in
 70 | the term "modification".)  Each licensee is addressed as "you".
 71 | 
 72 | Activities other than copying, distribution and modification are not
 73 | covered by this License; they are outside its scope.  The act of
 74 | running the Program is not restricted, and the output from the Program
 75 | is covered only if its contents constitute a work based on the
 76 | Program (independent of having been made by running the Program).
 77 | Whether that is true depends on what the Program does.
 78 | 
 79 |   1. You may copy and distribute verbatim copies of the Program's
 80 | source code as you receive it, in any medium, provided that you
 81 | conspicuously and appropriately publish on each copy an appropriate
 82 | copyright notice and disclaimer of warranty; keep intact all the
 83 | notices that refer to this License and to the absence of any warranty;
 84 | and give any other recipients of the Program a copy of this License
 85 | along with the Program.
 86 | 
 87 | You may charge a fee for the physical act of transferring a copy, and
 88 | you may at your option offer warranty protection in exchange for a fee.
 89 | 
 90 |   2. You may modify your copy or copies of the Program or any portion
 91 | of it, thus forming a work based on the Program, and copy and
 92 | distribute such modifications or work under the terms of Section 1
 93 | above, provided that you also meet all of these conditions:
 94 | 
 95 |     a) You must cause the modified files to carry prominent notices
 96 |     stating that you changed the files and the date of any change.
 97 | 
 98 |     b) You must cause any work that you distribute or publish, that in
 99 |     whole or in part contains or is derived from the Program or any
100 |     part thereof, to be licensed as a whole at no charge to all third
101 |     parties under the terms of this License.
102 | 
103 |     c) If the modified program normally reads commands interactively
104 |     when run, you must cause it, when started running for such
105 |     interactive use in the most ordinary way, to print or display an
106 |     announcement including an appropriate copyright notice and a
107 |     notice that there is no warranty (or else, saying that you provide
108 |     a warranty) and that users may redistribute the program under
109 |     these conditions, and telling the user how to view a copy of this
110 |     License.  (Exception: if the Program itself is interactive but
111 |     does not normally print such an announcement, your work based on
112 |     the Program is not required to print an announcement.)
113 | 
114 | These requirements apply to the modified work as a whole.  If
115 | identifiable sections of that work are not derived from the Program,
116 | and can be reasonably considered independent and separate works in
117 | themselves, then this License, and its terms, do not apply to those
118 | sections when you distribute them as separate works.  But when you
119 | distribute the same sections as part of a whole which is a work based
120 | on the Program, the distribution of the whole must be on the terms of
121 | this License, whose permissions for other licensees extend to the
122 | entire whole, and thus to each and every part regardless of who wrote it.
123 | 
124 | Thus, it is not the intent of this section to claim rights or contest
125 | your rights to work written entirely by you; rather, the intent is to
126 | exercise the right to control the distribution of derivative or
127 | collective works based on the Program.
128 | 
129 | In addition, mere aggregation of another work not based on the Program
130 | with the Program (or with a work based on the Program) on a volume of
131 | a storage or distribution medium does not bring the other work under
132 | the scope of this License.
133 | 
134 |   3. You may copy and distribute the Program (or a work based on it,
135 | under Section 2) in object code or executable form under the terms of
136 | Sections 1 and 2 above provided that you also do one of the following:
137 | 
138 |     a) Accompany it with the complete corresponding machine-readable
139 |     source code, which must be distributed under the terms of Sections
140 |     1 and 2 above on a medium customarily used for software interchange; or,
141 | 
142 |     b) Accompany it with a written offer, valid for at least three
143 |     years, to give any third party, for a charge no more than your
144 |     cost of physically performing source distribution, a complete
145 |     machine-readable copy of the corresponding source code, to be
146 |     distributed under the terms of Sections 1 and 2 above on a medium
147 |     customarily used for software interchange; or,
148 | 
149 |     c) Accompany it with the information you received as to the offer
150 |     to distribute corresponding source code.  (This alternative is
151 |     allowed only for noncommercial distribution and only if you
152 |     received the program in object code or executable form with such
153 |     an offer, in accord with Subsection b above.)
154 | 
155 | The source code for a work means the preferred form of the work for
156 | making modifications to it.  For an executable work, complete source
157 | code means all the source code for all modules it contains, plus any
158 | associated interface definition files, plus the scripts used to
159 | control compilation and installation of the executable.  However, as a
160 | special exception, the source code distributed need not include
161 | anything that is normally distributed (in either source or binary
162 | form) with the major components (compiler, kernel, and so on) of the
163 | operating system on which the executable runs, unless that component
164 | itself accompanies the executable.
165 | 
166 | If distribution of executable or object code is made by offering
167 | access to copy from a designated place, then offering equivalent
168 | access to copy the source code from the same place counts as
169 | distribution of the source code, even though third parties are not
170 | compelled to copy the source along with the object code.
171 | 
172 |   4. You may not copy, modify, sublicense, or distribute the Program
173 | except as expressly provided under this License.  Any attempt
174 | otherwise to copy, modify, sublicense or distribute the Program is
175 | void, and will automatically terminate your rights under this License.
176 | However, parties who have received copies, or rights, from you under
177 | this License will not have their licenses terminated so long as such
178 | parties remain in full compliance.
179 | 
180 |   5. You are not required to accept this License, since you have not
181 | signed it.  However, nothing else grants you permission to modify or
182 | distribute the Program or its derivative works.  These actions are
183 | prohibited by law if you do not accept this License.  Therefore, by
184 | modifying or distributing the Program (or any work based on the
185 | Program), you indicate your acceptance of this License to do so, and
186 | all its terms and conditions for copying, distributing or modifying
187 | the Program or works based on it.
188 | 
189 |   6. Each time you redistribute the Program (or any work based on the
190 | Program), the recipient automatically receives a license from the
191 | original licensor to copy, distribute or modify the Program subject to
192 | these terms and conditions.  You may not impose any further
193 | restrictions on the recipients' exercise of the rights granted herein.
194 | You are not responsible for enforcing compliance by third parties to
195 | this License.
196 | 
197 |   7. If, as a consequence of a court judgment or allegation of patent
198 | infringement or for any other reason (not limited to patent issues),
199 | conditions are imposed on you (whether by court order, agreement or
200 | otherwise) that contradict the conditions of this License, they do not
201 | excuse you from the conditions of this License.  If you cannot
202 | distribute so as to satisfy simultaneously your obligations under this
203 | License and any other pertinent obligations, then as a consequence you
204 | may not distribute the Program at all.  For example, if a patent
205 | license would not permit royalty-free redistribution of the Program by
206 | all those who receive copies directly or indirectly through you, then
207 | the only way you could satisfy both it and this License would be to
208 | refrain entirely from distribution of the Program.
209 | 
210 | If any portion of this section is held invalid or unenforceable under
211 | any particular circumstance, the balance of the section is intended to
212 | apply and the section as a whole is intended to apply in other
213 | circumstances.
214 | 
215 | It is not the purpose of this section to induce you to infringe any
216 | patents or other property right claims or to contest validity of any
217 | such claims; this section has the sole purpose of protecting the
218 | integrity of the free software distribution system, which is
219 | implemented by public license practices.  Many people have made
220 | generous contributions to the wide range of software distributed
221 | through that system in reliance on consistent application of that
222 | system; it is up to the author/donor to decide if he or she is willing
223 | to distribute software through any other system and a licensee cannot
224 | impose that choice.
225 | 
226 | This section is intended to make thoroughly clear what is believed to
227 | be a consequence of the rest of this License.
228 | 
229 |   8. If the distribution and/or use of the Program is restricted in
230 | certain countries either by patents or by copyrighted interfaces, the
231 | original copyright holder who places the Program under this License
232 | may add an explicit geographical distribution limitation excluding
233 | those countries, so that distribution is permitted only in or among
234 | countries not thus excluded.  In such case, this License incorporates
235 | the limitation as if written in the body of this License.
236 | 
237 |   9. The Free Software Foundation may publish revised and/or new versions
238 | of the General Public License from time to time.  Such new versions will
239 | be similar in spirit to the present version, but may differ in detail to
240 | address new problems or concerns.
241 | 
242 | Each version is given a distinguishing version number.  If the Program
243 | specifies a version number of this License which applies to it and "any
244 | later version", you have the option of following the terms and conditions
245 | either of that version or of any later version published by the Free
246 | Software Foundation.  If the Program does not specify a version number of
247 | this License, you may choose any version ever published by the Free Software
248 | Foundation.
249 | 
250 |   10. If you wish to incorporate parts of the Program into other free
251 | programs whose distribution conditions are different, write to the author
252 | to ask for permission.  For software which is copyrighted by the Free
253 | Software Foundation, write to the Free Software Foundation; we sometimes
254 | make exceptions for this.  Our decision will be guided by the two goals
255 | of preserving the free status of all derivatives of our free software and
256 | of promoting the sharing and reuse of software generally.
257 | 
258 |                             NO WARRANTY
259 | 
260 |   11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
261 | FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
262 | OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
263 | PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
264 | OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
265 | MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
266 | TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
267 | PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
268 | REPAIR OR CORRECTION.
269 | 
270 |   12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
271 | WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
272 | REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
273 | INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
274 | OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
275 | TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
276 | YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
277 | PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
278 | POSSIBILITY OF SUCH DAMAGES.
279 | 
280 |                      END OF TERMS AND CONDITIONS
281 | 
282 |             How to Apply These Terms to Your New Programs
283 | 
284 |   If you develop a new program, and you want it to be of the greatest
285 | possible use to the public, the best way to achieve this is to make it
286 | free software which everyone can redistribute and change under these terms.
287 | 
288 |   To do so, attach the following notices to the program.  It is safest
289 | to attach them to the start of each source file to most effectively
290 | convey the exclusion of warranty; and each file should have at least
291 | the "copyright" line and a pointer to where the full notice is found.
292 | 
293 |     <one line to give the program's name and a brief idea of what it does.>
294 |     Copyright (C) <year>  <name of author>
295 | 
296 |     This program is free software; you can redistribute it and/or modify
297 |     it under the terms of the GNU General Public License as published by
298 |     the Free Software Foundation; either version 2 of the License, or
299 |     (at your option) any later version.
300 | 
301 |     This program is distributed in the hope that it will be useful,
302 |     but WITHOUT ANY WARRANTY; without even the implied warranty of
303 |     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
304 |     GNU General Public License for more details.
305 | 
306 |     You should have received a copy of the GNU General Public License along
307 |     with this program; if not, write to the Free Software Foundation, Inc.,
308 |     51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
309 | 
310 | Also add information on how to contact you by electronic and paper mail.
311 | 
312 | If the program is interactive, make it output a short notice like this
313 | when it starts in an interactive mode:
314 | 
315 |     Gnomovision version 69, Copyright (C) year name of author
316 |     Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
317 |     This is free software, and you are welcome to redistribute it
318 |     under certain conditions; type `show c' for details.
319 | 
320 | The hypothetical commands `show w' and `show c' should show the appropriate
321 | parts of the General Public License.  Of course, the commands you use may
322 | be called something other than `show w' and `show c'; they could even be
323 | mouse-clicks or menu items--whatever suits your program.
324 | 
325 | You should also get your employer (if you work as a programmer) or your
326 | school, if any, to sign a "copyright disclaimer" for the program, if
327 | necessary.  Here is a sample; alter the names:
328 | 
329 |   Yoyodyne, Inc., hereby disclaims all copyright interest in the program
330 |   `Gnomovision' (which makes passes at compilers) written by James Hacker.
331 | 
332 |   <signature of Ty Coon>, 1 April 1989
333 |   Ty Coon, President of Vice
334 | 
335 | This General Public License does not permit incorporating your program into
336 | proprietary programs.  If your program is a subroutine library, you may
337 | consider it more useful to permit linking proprietary applications with the
338 | library.  If this is what you want to do, use the GNU Lesser General
339 | Public License instead of this License.
340 | 


--------------------------------------------------------------------------------