Release 2021.01.29

Refactor update-version, pyinst.py and related files
* Refactor update-version * Moved pyinst, update-version and icon into devscripts * pyinst doesn't bump version anymore * Merge pyinst and pyinst32. Usage: `pyinst.py [32|64]` * Add mutagen as requirement * Remove make_win and related files
2026-01-13 02:11:18 +00:00 · 2021-01-29 23:25:18 +05:30 · 2021-01-29 23:16:00 +05:30 · 2021-01-29 22:30:22 +05:30 · 2021-01-29 01:57:14 +05:30 · 2021-01-29 01:03:32 +05:30
45 changed files with 1410 additions and 696 deletions
--- a/.github/ISSUE_TEMPLATE/1_broken_site.md
+++ b/.github/ISSUE_TEMPLATE/1_broken_site.md
@@ -21,7 +21,7 @@ assignees: ''

 <!--
 Carefully read and work through this check list in order to prevent the most common mistakes and misuse of youtube-dlc:
- First of, make sure you are using the latest version of yt-dlp. Run `youtube-dlc --version` and ensure your version is 2021.01.20. If it's not, see https://github.com/pukkandan/yt-dlp on how to update. Issues with outdated version will be REJECTED.
+- First of, make sure you are using the latest version of yt-dlp. Run `youtube-dlc --version` and ensure your version is 2021.01.24. If it's not, see https://github.com/pukkandan/yt-dlp on how to update. Issues with outdated version will be REJECTED.
 - Make sure that all provided video/audio/playlist URLs (if any) are alive and playable in a browser.
 - Make sure that all URLs and arguments with special characters are properly quoted or escaped as explained in https://github.com/pukkandan/yt-dlp.
 - Search the bugtracker for similar issues: https://github.com/pukkandan/yt-dlp. DO NOT post duplicates.
@@ -29,7 +29,7 @@ Carefully read and work through this check list in order to prevent the most com
 -->

 - [ ] I'm reporting a broken site support
- [ ] I've verified that I'm running yt-dlp version **2021.01.20**
+- [ ] I've verified that I'm running yt-dlp version **2021.01.24**
 - [ ] I've checked that all provided URLs are alive and playable in a browser
 - [ ] I've checked that all URLs and arguments with special characters are properly quoted or escaped
 - [ ] I've searched the bugtracker for similar issues including closed ones
@@ -44,7 +44,7 @@ Add the `-v` flag to your command line you run youtube-dlc with (`youtube-dlc -v
 [debug] User config: []
 [debug] Command-line args: [u'-v', u'http://www.youtube.com/watch?v=BaW_jenozKcj']
 [debug] Encodings: locale cp1251, fs mbcs, out cp866, pref cp1251
- [debug] yt-dlp version 2021.01.20
+ [debug] yt-dlp version 2021.01.24
 [debug] Python version 2.7.11 - Windows-2003Server-5.2.3790-SP2
 [debug] exe versions: ffmpeg N-75573-g1d0487f, ffprobe N-75573-g1d0487f, rtmpdump 2.4
 [debug] Proxy map: {}
--- a/.github/ISSUE_TEMPLATE/2_site_support_request.md
+++ b/.github/ISSUE_TEMPLATE/2_site_support_request.md
@@ -21,7 +21,7 @@ assignees: ''

 <!--
 Carefully read and work through this check list in order to prevent the most common mistakes and misuse of youtube-dlc:
- First of, make sure you are using the latest version of yt-dlp. Run `youtube-dlc --version` and ensure your version is 2021.01.20. If it's not, see https://github.com/pukkandan/yt-dlp on how to update. Issues with outdated version will be REJECTED.
+- First of, make sure you are using the latest version of yt-dlp. Run `youtube-dlc --version` and ensure your version is 2021.01.24. If it's not, see https://github.com/pukkandan/yt-dlp on how to update. Issues with outdated version will be REJECTED.
 - Make sure that all provided video/audio/playlist URLs (if any) are alive and playable in a browser.
 - Make sure that site you are requesting is not dedicated to copyright infringement, see https://github.com/pukkandan/yt-dlp. yt-dlp does not support such sites. In order for site support request to be accepted all provided example URLs should not violate any copyrights.
 - Search the bugtracker for similar site support requests: https://github.com/pukkandan/yt-dlp. DO NOT post duplicates.
@@ -29,7 +29,7 @@ Carefully read and work through this check list in order to prevent the most com
 -->

 - [ ] I'm reporting a new site support request
- [ ] I've verified that I'm running yt-dlp version **2021.01.20**
+- [ ] I've verified that I'm running yt-dlp version **2021.01.24**
 - [ ] I've checked that all provided URLs are alive and playable in a browser
 - [ ] I've checked that none of provided URLs violate any copyrights
 - [ ] I've searched the bugtracker for similar site support requests including closed ones
--- a/.github/ISSUE_TEMPLATE/3_site_feature_request.md
+++ b/.github/ISSUE_TEMPLATE/3_site_feature_request.md
@@ -21,13 +21,13 @@ assignees: ''

 <!--
 Carefully read and work through this check list in order to prevent the most common mistakes and misuse of youtube-dlc:
- First of, make sure you are using the latest version of yt-dlp. Run `youtube-dlc --version` and ensure your version is 2021.01.20. If it's not, see https://github.com/pukkandan/yt-dlp on how to update. Issues with outdated version will be REJECTED.
+- First of, make sure you are using the latest version of yt-dlp. Run `youtube-dlc --version` and ensure your version is 2021.01.24. If it's not, see https://github.com/pukkandan/yt-dlp on how to update. Issues with outdated version will be REJECTED.
 - Search the bugtracker for similar site feature requests: https://github.com/pukkandan/yt-dlp. DO NOT post duplicates.
 - Finally, put x into all relevant boxes like this [x] (Dont forget to delete the empty space)
 -->

 - [ ] I'm reporting a site feature request
- [ ] I've verified that I'm running yt-dlp version **2021.01.20**
+- [ ] I've verified that I'm running yt-dlp version **2021.01.24**
 - [ ] I've searched the bugtracker for similar site feature requests including closed ones


--- a/.github/ISSUE_TEMPLATE/4_bug_report.md
+++ b/.github/ISSUE_TEMPLATE/4_bug_report.md
@@ -21,7 +21,7 @@ assignees: ''

 <!--
 Carefully read and work through this check list in order to prevent the most common mistakes and misuse of youtube-dlc:
- First of, make sure you are using the latest version of yt-dlp. Run `youtube-dlc --version` and ensure your version is 2021.01.20. If it's not, see https://github.com/pukkandan/yt-dlp on how to update. Issues with outdated version will be REJECTED.
+- First of, make sure you are using the latest version of yt-dlp. Run `youtube-dlc --version` and ensure your version is 2021.01.24. If it's not, see https://github.com/pukkandan/yt-dlp on how to update. Issues with outdated version will be REJECTED.
 - Make sure that all provided video/audio/playlist URLs (if any) are alive and playable in a browser.
 - Make sure that all URLs and arguments with special characters are properly quoted or escaped as explained in https://github.com/pukkandan/yt-dlp.
 - Search the bugtracker for similar issues: https://github.com/pukkandan/yt-dlp. DO NOT post duplicates.
@@ -30,7 +30,7 @@ Carefully read and work through this check list in order to prevent the most com
 -->

 - [ ] I'm reporting a broken site support issue
- [ ] I've verified that I'm running yt-dlp version **2021.01.20**
+- [ ] I've verified that I'm running yt-dlp version **2021.01.24**
 - [ ] I've checked that all provided URLs are alive and playable in a browser
 - [ ] I've checked that all URLs and arguments with special characters are properly quoted or escaped
 - [ ] I've searched the bugtracker for similar bug reports including closed ones
@@ -46,7 +46,7 @@ Add the `-v` flag to your command line you run youtube-dlc with (`youtube-dlc -v
 [debug] User config: []
 [debug] Command-line args: [u'-v', u'http://www.youtube.com/watch?v=BaW_jenozKcj']
 [debug] Encodings: locale cp1251, fs mbcs, out cp866, pref cp1251
- [debug] yt-dlp version 2021.01.20
+ [debug] yt-dlp version 2021.01.24
 [debug] Python version 2.7.11 - Windows-2003Server-5.2.3790-SP2
 [debug] exe versions: ffmpeg N-75573-g1d0487f, ffprobe N-75573-g1d0487f, rtmpdump 2.4
 [debug] Proxy map: {}
--- a/.github/ISSUE_TEMPLATE/5_feature_request.md
+++ b/.github/ISSUE_TEMPLATE/5_feature_request.md
@@ -21,13 +21,13 @@ assignees: ''

 <!--
 Carefully read and work through this check list in order to prevent the most common mistakes and misuse of youtube-dlc:
- First of, make sure you are using the latest version of yt-dlp. Run `youtube-dlc --version` and ensure your version is 2021.01.20. If it's not, see https://github.com/pukkandan/yt-dlp on how to update. Issues with outdated version will be REJECTED.
+- First of, make sure you are using the latest version of yt-dlp. Run `youtube-dlc --version` and ensure your version is 2021.01.24. If it's not, see https://github.com/pukkandan/yt-dlp on how to update. Issues with outdated version will be REJECTED.
 - Search the bugtracker for similar feature requests: https://github.com/pukkandan/yt-dlp. DO NOT post duplicates.
 - Finally, put x into all relevant boxes like this [x] (Dont forget to delete the empty space)
 -->

 - [ ] I'm reporting a feature request
- [ ] I've verified that I'm running yt-dlp version **2021.01.20**
+- [ ] I've verified that I'm running yt-dlp version **2021.01.24**
 - [ ] I've searched the bugtracker for similar feature requests including closed ones


--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -25,8 +25,8 @@ jobs:
      run: sudo apt-get -y install zip pandoc man
    - name: Bump version
      id: bump_version
-      run: python scripts/update-version-workflow.py
-    - name: Check the output from My action
+      run: python devscripts/update-version.py
+    - name: Print version
      run: echo "${{ steps.bump_version.outputs.ytdlc_version }}"
    - name: Run Make
      run: make
@@ -84,11 +84,14 @@ jobs:
      with:
          python-version: '3.8'
    - name: Install Requirements
-      run: pip install pyinstaller
+      run: pip install pyinstaller mutagen
    - name: Bump version
-      run: python scripts/update-version-workflow.py
+      id: bump_version
+      run: python devscripts/update-version.py
+    - name: Print version
+      run: echo "${{ steps.bump_version.outputs.ytdlc_version }}"
    - name: Run PyInstaller Script
-      run: python pyinst.py
+      run: python devscripts/pyinst.py 64
    - name: Upload youtube-dlc.exe Windows binary
      id: upload-release-windows
      uses: actions/upload-release-asset@v1
@@ -119,11 +122,14 @@ jobs:
          python-version: '3.4.4'
          architecture: 'x86'
    - name: Install Requirements for 32 Bit
-      run: pip install pyinstaller==3.5
+      run: pip install pyinstaller==3.5 mutagen
    - name: Bump version
-      run: python scripts/update-version-workflow.py
+      id: bump_version
+      run: python devscripts/update-version.py
+    - name: Print version
+      run: echo "${{ steps.bump_version.outputs.ytdlc_version }}"
    - name: Run PyInstaller Script for 32 Bit
-      run: python pyinst32.py
+      run: python devscripts/pyinst.py 32
    - name: Upload Executable youtube-dlc_x86.exe
      id: upload-release-windows32
      uses: actions/upload-release-asset@v1
@@ -162,18 +168,15 @@ jobs:
        asset_name: SHA2-256SUMS
        asset_content_type: text/plain

-  update_version_badge:
-
-    runs-on: ubuntu-latest
-
-    needs: build_unix
-
-    steps:
-    - name: Create Version Badge
-      uses: schneegans/dynamic-badges-action@v1.0.0
-      with:
-        auth: ${{ secrets.GIST_TOKEN }}
-        gistID: c69cb23c3c5b3316248e52022790aa57
-        filename: version.json
-        label: Version
-        message: ${{ needs.build_unix.outputs.ytdlc_version }}
+#  update_version_badge:
+#    runs-on: ubuntu-latest
+#    needs: build_unix
+#    steps:
+#    - name: Create Version Badge
+#      uses: schneegans/dynamic-badges-action@v1.0.0
+#      with:
+#        auth: ${{ secrets.GIST_TOKEN }}
+#        gistID: c69cb23c3c5b3316248e52022790aa57
+#        filename: version.json
+#        label: Version
+#        message: ${{ needs.build_unix.outputs.ytdlc_version }}
--- a/.gitignore
+++ b/.gitignore
@@ -1,35 +1,43 @@
+# Python
 *.pyc
 *.pyo
-*.class
-*~
-*.DS_Store
 wine-py2exe/
 py2exe.log
-*.kate-swp
 build/
 dist/
 zip/
+tmp/
+venv/
+
+# Misc
+*~
+*.DS_Store
+*.kate-swp
 MANIFEST
-README.txt
-youtube-dl.1
-youtube-dlc.1
-youtube-dl.bash-completion
-youtube-dlc.bash-completion
-youtube-dl.fish
-youtube-dlc.fish
-youtube_dl/extractor/lazy_extractors.py
-youtube_dlc/extractor/lazy_extractors.py
-youtube-dl
-youtube-dlc
-youtube-dl.exe
-youtube-dlc.exe
-youtube-dl.tar.gz
-youtube-dlc.tar.gz
-youtube-dlc.spec
+test/local_parameters.json
 .coverage
 cover/
 updates_key.pem
 *.egg-info
+.tox
+*.class
+
+# Generated
+README.txt
+*.1
+*.bash-completion
+*.fish
+*.exe
+*.tar.gz
+*.zsh
+*.spec
+
+# Binary
+youtube-dl
+youtube-dlc
+*.exe
+
+# Downloaded
 *.srt
 *.ttml
 *.sbv
@@ -46,32 +54,29 @@ updates_key.pem
 *.swf
 *.part
 *.ytdl
-*.conf
 *.swp
+*.ogg
+*.opus
+
+# Config
+*.conf
 *.spec
-*.exe
-test/local_parameters.json
-.tox
-youtube-dl.zsh
-youtube-dlc.zsh
-
-# IntelliJ related files
-.idea
-*.iml
-
-tmp/
-venv/
-
-# VS Code related files
-.vscode
-
-# SublimeText files
-*.sublime-workspace
-
-# Cookies
 cookies
 cookies.txt

+
+
+# Text Editor / IDE
+.idea
+*.iml
+.vscode
+*.sublime-workspace
+*.sublime-project
+!yt-dlp.sublime-project
+
+# Lazy extractors
+*/extractor/lazy_extractors.py
+
 # Plugins
 ytdlp_plugins/extractor/*
 !ytdlp_plugins/extractor/__init__.py
--- a/Changelog.md
+++ b/Changelog.md
@@ -8,14 +8,48 @@
 * Change "Merged with youtube-dl" version in Readme.md if needed
 * Commit to master as `Release <version>`
 * Push to origin/release - build task will now run
-* Update version.py and run `make issuetemplates`
-* Commit to master as `[version] update :skip ci all`
+* Update version.py using devscripts\update-version.py
+* Run `make issuetemplates`
+* Commit to master as `[version] update :ci skip all`
 * Push to origin/master
 * Update changelog in /releases

 -->


+### 2021.01.29
+* **Features from [animelover1984/youtube-dl](https://github.com/animelover1984/youtube-dl)**: Co-authored by @animelover1984 and @bbepis
+    * Add `--get-comments`
+    * [youtube] Extract comments
+    * [billibilli] Added BiliBiliSearchIE, BilibiliChannelIE
+    * [billibilli] Extract comments
+    * [billibilli] Better video extraction
+    * Write playlist data to infojson
+    * [FFmpegMetadata] Embed infojson inside the video
+    * [EmbedThumbnail] Try embedding in mp4 using ffprobe and `-disposition`
+    * [EmbedThumbnail] Treat mka like mkv and mov like mp4
+    * [EmbedThumbnail] Embed in ogg/opus
+    * [VideoRemuxer] Conditionally remux video
+    * [VideoRemuxer] Add `-movflags +faststart` when remuxing to mp4
+    * [ffmpeg] Print entire stderr in verbose when there is error
+    * [EmbedSubtitle] Warn when embedding ass in mp4
+    * [anvato] Use NFLTokenGenerator if possible
+* **Parse additional metadata**: New option `--parse-metadata` to extract additional metadata from existing fields
+    * The extracted fields can be used in `--output`
+    * Deprecated `--metadata-from-title`
+* [Audius] Add extractor
+* [youtube] Extract playlist description and write it to `.description` file
+* Detect existing files even when using `recode`/`remux` (`extract-audio` is partially fixed)
+* Fix wrong user config from v2021.01.24
+* [youtube] Report error message from youtube as error instead of warning
+* [FormatSort] Fix some fields not sorting from v2021.01.24
+* [postprocessor] Deprecate `avconv`/`avprobe`.  All current functionality is left untouched. But don't expect any new features to work with avconv
+* [postprocessor] fix `write_debug` to not throw error when there is no `_downloader`
+* [movefiles] Don't give "cant find" warning when move is unnecessary
+* Refactor `update-version`, `pyinst.py` and related files
+* [ffmpeg] Document more formats that are supported for remux/recode
+
+
 ### 2021.01.24
 * **Merge youtube-dl:** Upto [2021.01.24](https://github.com/ytdl-org/youtube-dl/releases/tag/2021.01.16)
 * Plugin support ([documentation](https://github.com/pukkandan/yt-dlp#plugins))
@@ -30,8 +64,8 @@
 * [sponskrub] Output `unrecognized argument` error message correctly
 * [cbs] Make failure to extract title non-fatal
 * Fix typecasting when pre-checking archive
-* Fix issue with setting title on unix
-* Deprecate redundant aliases in `formatSort`. The aliases remain functional for backward compatability, but will be left undocumented
+* Fix issue with setting title on UNIX
+* Deprecate redundant aliases in `formatSort`. The aliases remain functional for backward compatibility, but will be left undocumented
 * [tests] Fix test_post_hooks
 * [tests] Split core and download tests

--- a/README.md
+++ b/README.md
@@ -1,9 +1,12 @@
 # YT-DLP

-<!-- See: https://github.com/marketplace/actions/dynamic-badges -->
-[![Release Version](https://img.shields.io/endpoint?url=https://gist.githubusercontent.com/pukkandan/c69cb23c3c5b3316248e52022790aa57/raw/version.json&color=brightgreen)](https://github.com/pukkandan/yt-dlp/releases/latest)
+[![Release version](https://img.shields.io/github/v/release/pukkandan/yt-dlp?color=brightgreen&label=Release)](https://github.com/pukkandan/yt-dlp/releases/latest)
 [![License: Unlicense](https://img.shields.io/badge/License-Unlicense-blue.svg)](LICENSE)
-[![CI Status](https://github.com/pukkandan/yt-dlp/workflows/Core%20Tests/badge.svg?branch=master)](https://github.com/pukkandan/yt-dlp/actions)
+[![CI Status](https://github.com/pukkandan/yt-dlp/workflows/Core%20Tests/badge.svg?branch=master)](https://github.com/pukkandan/yt-dlp/actions)  
+[![Commits](https://img.shields.io/github/commit-activity/m/pukkandan/yt-dlp?label=commits)](https://github.com/pukkandan/yt-dlp/commits)
+[![Last Commit](https://img.shields.io/github/last-commit/pukkandan/yt-dlp/master)](https://github.com/pukkandan/yt-dlp/commits)
+[![Downloads](https://img.shields.io/github/downloads/pukkandan/yt-dlp/total)](https://github.com/pukkandan/yt-dlp/releases/latest)
+[![PyPi Downloads](https://img.shields.io/pypi/dm/yt-dlp?label=PyPi)](https://pypi.org/project/yt-dlp)

 A command-line program to download videos from youtube.com and many other [video platforms](docs/supportedsites.md)

@@ -53,25 +56,30 @@ The major new features from the latest release of [blackjack4494/yt-dlc](https:/

 * **Merged with youtube-dl v2021.01.24.1**: You get all the latest features and patches of [youtube-dl](https://github.com/ytdl-org/youtube-dl) in addition to all the features of [youtube-dlc](https://github.com/blackjack4494/yt-dlc)

+* **Merged with animelover1984/youtube-dl**: You get most of the features and improvements from [animelover1984/youtube-dl](https://github.com/animelover1984/youtube-dl) including `--get-comments`, `BiliBiliSearch`, `BilibiliChannel`, Embedding thumbnail in mp4/ogg/opus, Playlist infojson etc. Note that the NicoNico improvements are not available. See [#31](https://github.com/pukkandan/yt-dlp/pull/31) for details.
+
 * **Youtube improvements**:
    * All Youtube Feeds (`:ytfav`, `:ytwatchlater`, `:ytsubs`, `:ythistory`, `:ytrec`) works correctly and support downloading multiple pages of content
    * Youtube search works correctly (`ytsearch:`, `ytsearchdate:`) along with Search URLs
    * Redirect channel's home URL automatically to `/video` to preserve the old behaviour

-* **New extractors**: AnimeLab, Philo MSO, Rcs, Gedi, bitwave.tv, mildom
+* **New extractors**: AnimeLab, Philo MSO, Rcs, Gedi, bitwave.tv, mildom, audius

 * **Fixed extractors**: archive.org, roosterteeth.com, skyit, instagram, itv, SouthparkDe, spreaker, Vlive, tiktok, akamai, ina

 * **Plugin support**: Extractors can be loaded from an external file. See [plugins](#plugins) for details

-* **Multiple paths**: You can give different paths for different types of files. You can also set a temporary path where intermediary files are downloaded to. See [--paths](#:~:text=-P,%20--paths%20TYPE:PATH) for details
+* **Multiple paths**: You can give different paths for different types of files. You can also set a temporary path where intermediary files are downloaded to. See [`--paths`](https://github.com/pukkandan/yt-dlp/#:~:text=-P,%20--paths%20TYPE:PATH) for details
+
+<!-- Relative link doesn't work for "#:~:text=" -->

 * **Portable Configuration**: Configuration files are automatically loaded from the home and root directories. See [configuration](#configuration) for details

-* **Other new options**: `--list-formats-as-table`, `--write-link`, `--force-download-archive`, `--force-overwrites`, `--break-on-reject` etc
+* **Other new options**: `--parse-metadata`, `--list-formats-as-table`, `--write-link`, `--force-download-archive`, `--force-overwrites`, `--break-on-reject` etc

 * **Improvements**: Multiple `--postprocessor-args` and `--external-downloader-args`, `%(duration_string)s` in `-o`, faster archive checking, more [format selection options](#format-selection) etc

+
 See [changelog](Changelog.md) or [commits](https://github.com/pukkandan/yt-dlp/commits) for the full list of changes


@@ -83,7 +91,7 @@ If you are coming from [youtube-dl](https://github.com/ytdl-org/youtube-dl), the
 # INSTALLATION

 You can install yt-dlp using one of the following methods:
-* Use [PyPI package](https://pypi.org/project/yt-dlp/): `python -m pip install --upgrade yt-dlp`
+* Use [PyPI package](https://pypi.org/project/yt-dlp): `python -m pip install --upgrade yt-dlp`
 * Download the binary from the [latest release](https://github.com/pukkandan/yt-dlp/releases/latest)
 * Use pip+git: `python -m pip install --upgrade git+https://github.com/pukkandan/yt-dlp.git@release`
 * Install master branch: `python -m pip install --upgrade git+https://github.com/pukkandan/yt-dlp`
@@ -94,16 +102,15 @@ You can install yt-dlp using one of the following methods:
 ### COMPILE

 **For Windows**:
-To build the Windows executable yourself (without version info!)
+To build the Windows executable, you must have pyinstaller (and optionally mutagen for embedding thumbnail in opus/ogg files)
+
+    python -m pip install --upgrade pyinstaller mutagen
+
+For the 64bit version, run `py devscripts\pyinst.py 64` using 64bit python3. Similarly, to install 32bit version, run `py devscripts\pyinst.py 32` using 32bit python (preferably 3)
+
+You can also build the executable without any version info or metadata by using:

-    python -m pip install --upgrade pyinstaller
    pyinstaller.exe youtube_dlc\__main__.py --onefile --name youtube-dlc
-    
-Or simply execute the `make_win.bat` if pyinstaller is installed.
-There will be a `youtube-dlc.exe` in `/dist`  
-
-New way to build Windows is to use `python pyinst.py` (please use python3 64Bit)  
-For 32Bit Version use a 32Bit Version of python (3 preferred here as well) and run `python pyinst32.py`  

 **For Unix**:
 You will need the required build tools  
@@ -112,6 +119,7 @@ Then simply type this

    make

+**Note**: In either platform, `devscripts\update-version.py` can be used to automatically update the version number

 # DESCRIPTION
 **youtube-dlc** is a command-line program to download videos from youtube.com many other [video platforms](docs/supportedsites.md). It requires the Python interpreter, version 2.6, 2.7, or 3.2+, and it is not platform specific. It should work on your Unix box, on Windows or on macOS. It is released to the public domain, which means you can modify it, redistribute it or use it however you like.
@@ -315,8 +323,8 @@ Then simply type this
    --downloader-args NAME:ARGS      Give these arguments to the external
                                     downloader. Specify the downloader name and
                                     the arguments separated by a colon ":". You
-                                     can use this option multiple times (Alias:
-                                     --external-downloader-args)
+                                     can use this option multiple times
+                                     (Alias: --external-downloader-args)

 ## Filesystem Options:
    -a, --batch-file FILE            File containing URLs to download ('-' for
@@ -370,6 +378,8 @@ Then simply type this
    --write-annotations              Write video annotations to a
                                     .annotations.xml file
    --no-write-annotations           Do not write video annotations (default)
+    --get-comments                   Retrieve video comments to be placed in the
+                                     .info.json file
    --load-info-json FILE            JSON file containing the video information
                                     (created with the "--write-info-json"
                                     option)
@@ -504,17 +514,17 @@ Then simply type this
    --list-formats-old               Present the output of -F in the old form
                                     (Alias: --no-list-formats-as-table)
    --youtube-include-dash-manifest  Download the DASH manifests and related
-                                     data on YouTube videos (default) (Alias:
-                                     --no-youtube-skip-dash-manifest)
+                                     data on YouTube videos (default)
+                                     (Alias: --no-youtube-skip-dash-manifest)
    --youtube-skip-dash-manifest     Do not download the DASH manifests and
-                                     related data on YouTube videos (Alias:
-                                     --no-youtube-include-dash-manifest)
+                                     related data on YouTube videos
+                                     (Alias: --no-youtube-include-dash-manifest)
    --youtube-include-hls-manifest   Download the HLS manifests and related data
-                                     on YouTube videos (default) (Alias:
-                                    --no-youtube-skip-hls-manifest)
+                                     on YouTube videos (default)
+                                     (Alias: --no-youtube-skip-hls-manifest)
    --youtube-skip-hls-manifest      Do not download the HLS manifests and
-                                     related data on YouTube videos (Alias:
-                                     --no-youtube-include-hls-manifest)
+                                     related data on YouTube videos
+                                     (Alias: --no-youtube-include-hls-manifest)
    --merge-output-format FORMAT     If a merge is required (e.g.
                                     bestvideo+bestaudio), output to given
                                     container format. One of mkv, mp4, ogg,
@@ -558,23 +568,26 @@ Then simply type this

 ## Post-Processing Options:
    -x, --extract-audio              Convert video files to audio-only files
-                                     (requires ffmpeg or avconv and ffprobe or
-                                     avprobe)
+                                     (requires ffmpeg and ffprobe)
    --audio-format FORMAT            Specify audio format: "best", "aac",
                                     "flac", "mp3", "m4a", "opus", "vorbis", or
                                     "wav"; "best" by default; No effect without
                                     -x
-    --audio-quality QUALITY          Specify ffmpeg/avconv audio quality, insert
-                                     a value between 0 (better) and 9 (worse)
-                                     for VBR or a specific bitrate like 128K
+    --audio-quality QUALITY          Specify ffmpeg audio quality, insert a
+                                     value between 0 (better) and 9 (worse) for
+                                     VBR or a specific bitrate like 128K
                                     (default 5)
    --remux-video FORMAT             Remux the video into another container if
-                                     necessary (currently supported: mp4|mkv).
-                                     If target container does not support the
-                                     video/audio codec, remuxing will fail
+                                     necessary (currently supported: mp4|mkv|flv
+                                     |webm|mov|avi|mp3|mka|m4a|ogg|opus). If
+                                     target container does not support the
+                                     video/audio codec, remuxing will fail. You
+                                     can specify multiple rules; eg.
+                                     "aac>m4a/mov>mp4/mkv" will remux aac to
+                                     m4a, mov to mp4 and anything else to mkv.
    --recode-video FORMAT            Re-encode the video into another format if
-                                     re-encoding is necessary (currently
-                                     supported: mp4|flv|ogg|webm|mkv|avi)
+                                     re-encoding is necessary. The supported
+                                     formats are the same as --remux-video
    --postprocessor-args NAME:ARGS   Give these arguments to the postprocessors.
                                     Specify the postprocessor/executable name
                                     and the arguments separated by a colon ":"
@@ -586,15 +599,14 @@ Then simply type this
                                     FixupStretched, FixupM4a, FixupM3u8,
                                     SubtitlesConvertor and EmbedThumbnail. The
                                     supported executables are: SponSkrub,
-                                     FFmpeg, FFprobe, avconf, avprobe and
-                                     AtomicParsley. You can use this option
-                                     multiple times to give different arguments
-                                     to different postprocessors. You can also
-                                     specify "PP+EXE:ARGS" to give the arguments
-                                     to the specified executable only when being
-                                     used by the specified postprocessor. You
-                                     can use this option multiple times (Alias:
-                                     --ppa)
+                                     FFmpeg, FFprobe, and AtomicParsley. You can
+                                     use this option multiple times to give
+                                     different arguments to different
+                                     postprocessors. You can also specify
+                                     "PP+EXE:ARGS" to give the arguments to the
+                                     specified executable only when being used
+                                     by the specified postprocessor. You can use
+                                     this option multiple times (Alias: --ppa)
    -k, --keep-video                 Keep the intermediate video file on disk
                                     after post-processing
    --no-keep-video                  Delete the intermediate video file after
@@ -608,16 +620,20 @@ Then simply type this
    --no-embed-thumbnail             Do not embed thumbnail (default)
    --add-metadata                   Write metadata to the video file
    --no-add-metadata                Do not write metadata (default)
-    --metadata-from-title FORMAT     Parse additional metadata like song title /
-                                     artist from the video title. The format
-                                     syntax is the same as --output. Regular
-                                     expression with named capture groups may
+    --parse-metadata FIELD:FORMAT    Parse additional metadata like title/artist
+                                     from other fields. Give field name to
+                                     extract data from, and format of the field
+                                     seperated by a ":". Either regular
+                                     expression with named capture groups or a
+                                     similar syntax to the output template can
                                     also be used. The parsed parameters replace
-                                     existing values. Example: --metadata-from-
-                                     title "%(artist)s - %(title)s" matches a
+                                     any existing values and can be use in
+                                     output templateThis option can be used
+                                     multiple times. Example: --parse-metadata
+                                     "title:%(artist)s - %(title)s" matches a
                                     title like "Coldplay - Paradise". Example
-                                     (regex): --metadata-from-title
-                                     "(?P<artist>.+?) - (?P<title>.+)"
+                                     (regex): --parse-metadata
+                                     "description:Artist - (?P<artist>.+?)"
    --xattrs                         Write metadata to the video file's xattrs
                                     (using dublin core and xdg standards)
    --fixup POLICY                   Automatically correct known faults of the
@@ -625,15 +641,9 @@ Then simply type this
                                     emit a warning), detect_or_warn (the
                                     default; fix file if we can, warn
                                     otherwise)
-    --prefer-avconv                  Prefer avconv over ffmpeg for running the
-                                     postprocessors (Alias: --no-prefer-ffmpeg)
-    --prefer-ffmpeg                  Prefer ffmpeg over avconv for running the
-                                     postprocessors (default)
-                                     (Alias: --no-prefer-avconv)
-    --ffmpeg-location PATH           Location of the ffmpeg/avconv binary;
-                                     either the path to the binary or its
-                                     containing directory
-                                     (Alias: --avconv-location)
+    --ffmpeg-location PATH           Location of the ffmpeg binary; either the
+                                     path to the binary or its containing
+                                     directory
    --exec CMD                       Execute a command on the file after
                                     downloading and post-processing, similar to
                                     find's -exec syntax. Example: --exec 'adb
@@ -766,7 +776,7 @@ The basic usage is not to set any template arguments when downloading a single f
 - `is_live` (boolean): Whether this video is a live stream or a fixed-length video
 - `start_time` (numeric): Time in seconds where the reproduction should start, as specified in the URL
 - `end_time` (numeric): Time in seconds where the reproduction should end, as specified in the URL
- - `format` (string): A human-readable description of the format 
+ - `format` (string): A human-readable description of the format
 - `format_id` (string): Format code specified by `--format`
 - `format_note` (string): Additional info about the format
 - `width` (numeric): Width of the video
@@ -871,7 +881,7 @@ $ youtube-dlc -o - BaW_jenozKc
 # FORMAT SELECTION

 By default, youtube-dlc tries to download the best available quality if you **don't** pass any options.
-This is generally equivalent to using `-f bestvideo*+bestaudio/best`. However, if multiple audiostreams is enabled (`--audio-multistreams`), the default format changes to `-f bestvideo+bestaudio/best`. Similarly, if ffmpeg and avconv are unavailable, or if you use youtube-dlc to stream to `stdout` (`-o -`), the default becomes `-f best/bestvideo+bestaudio`.
+This is generally equivalent to using `-f bestvideo*+bestaudio/best`. However, if multiple audiostreams is enabled (`--audio-multistreams`), the default format changes to `-f bestvideo+bestaudio/best`. Similarly, if ffmpeg is unavailable, or if you use youtube-dlc to stream to `stdout` (`-o -`), the default becomes `-f best/bestvideo+bestaudio`.

 The general syntax for format selection is `--f FORMAT` (or `--format FORMAT`) where `FORMAT` is a *selector expression*, i.e. an expression that describes format or formats you would like to download.

@@ -902,7 +912,7 @@ If you want to download multiple videos and they don't have the same formats ava

 If you want to download several formats of the same video use a comma as a separator, e.g. `-f 22,17,18` will download all these three formats, of course if they are available. Or a more sophisticated example combined with the precedence feature: `-f 136/137/mp4/bestvideo,140/m4a/bestaudio`.

-You can merge the video and audio of multiple formats into a single file using `-f <format1>+<format2>+...` (requires ffmpeg or avconv installed), for example `-f bestvideo+bestaudio` will download the best video-only format, the best audio-only format and mux them together with ffmpeg/avconv. If `--no-video-multistreams` is used, all formats with a video stream except the first one are ignored. Similarly, if `--no-audio-multistreams` is used, all formats with an audio stream except the first one are ignored. For example, `-f bestvideo+best+bestaudio` will download and merge all 3 given formats. The resulting file will have 2 video streams and 2 audio streams. But `-f bestvideo+best+bestaudio --no-video-multistreams` will download and merge only `bestvideo` and `bestaudio`. `best` is ignored since another format containing a video stream (`bestvideo`) has already been selected. The order of the formats is therefore important. `-f best+bestaudio --no-audio-multistreams` will download and merge both formats while `-f bestaudio+best --no-audio-multistreams` will ignore `best` and download only `bestaudio`.
+You can merge the video and audio of multiple formats into a single file using `-f <format1>+<format2>+...` (requires ffmpeg installed), for example `-f bestvideo+bestaudio` will download the best video-only format, the best audio-only format and mux them together with ffmpeg. If `--no-video-multistreams` is used, all formats with a video stream except the first one are ignored. Similarly, if `--no-audio-multistreams` is used, all formats with an audio stream except the first one are ignored. For example, `-f bestvideo+best+bestaudio` will download and merge all 3 given formats. The resulting file will have 2 video streams and 2 audio streams. But `-f bestvideo+best+bestaudio --no-video-multistreams` will download and merge only `bestvideo` and `bestaudio`. `best` is ignored since another format containing a video stream (`bestvideo`) has already been selected. The order of the formats is therefore important. `-f best+bestaudio --no-audio-multistreams` will download and merge both formats while `-f bestaudio+best --no-audio-multistreams` will ignore `best` and download only `bestaudio`.

 ## Filtering Formats

@@ -1096,7 +1106,7 @@ $ youtube-dlc -S '+res:480,codec,br'

 Plugins are loaded from `<root-dir>/ytdlp_plugins/<type>/__init__.py`. Currently only `extractor` plugins are supported. Support for `downloader` and `postprocessor` plugins may be added in the future. See [ytdlp_plugins](ytdlp_plugins) for example.

-**Note**: `<root-dir>` is the directory of the binary (`<root-dir>/youtube-dlc`), or the root directory of the module if you are running directly from source-code ((`<root dir>/youtube_dlc/__main__.py`)
+**Note**: `<root-dir>` is the directory of the binary (`<root-dir>/youtube-dlc`), or the root directory of the module if you are running directly from source-code (`<root dir>/youtube_dlc/__main__.py`)

 # MORE
-For FAQ, Developer Instructions etc., see the [original README](https://github.com/ytdl-org/youtube-dl)
+For FAQ, Developer Instructions etc., see the [original README](https://github.com/ytdl-org/youtube-dl#faq)
--- a/devscripts/cloud.ico
+++ b/devscripts/cloud.ico
--- a/devscripts/pyinst.py
+++ b/devscripts/pyinst.py
@@ -0,0 +1,69 @@
+from __future__ import unicode_literals
+import sys
+
+from PyInstaller.utils.win32.versioninfo import (
+    VarStruct, VarFileInfo, StringStruct, StringTable,
+    StringFileInfo, FixedFileInfo, VSVersionInfo, SetVersion,
+)
+import PyInstaller.__main__
+
+
+assert len(sys.argv) > 1 and sys.argv[1] in ("32", "64")
+_x86 = "_x86" if sys.argv[1] == "32" else ""
+
+FILE_DESCRIPTION = 'Media Downloader%s' % (" (32 Bit)" if _x86 else '')
+SHORT_URLS = {"32": "git.io/JUGsM", "64": "git.io/JLh7K"}
+
+
+exec(compile(open('youtube_dlc/version.py').read(), 'youtube_dlc/version.py', 'exec'))
+VERSION = locals()['__version__']
+
+VERSION_LIST = VERSION.replace('-', '.').split('.')
+VERSION_LIST = list(map(int, VERSION_LIST)) + [0] * (4 - len(VERSION_LIST))
+
+print('Version: %s%s' % (VERSION, _x86))
+print('Remember to update the version using devscipts\\update-version.py')
+
+VERSION_FILE = VSVersionInfo(
+    ffi=FixedFileInfo(
+        filevers=VERSION_LIST,
+        prodvers=VERSION_LIST,
+        mask=0x3F,
+        flags=0x0,
+        OS=0x4,
+        fileType=0x1,
+        subtype=0x0,
+        date=(0, 0),
+    ),
+    kids=[
+        StringFileInfo([
+            StringTable(
+                "040904B0", [
+                    StringStruct("Comments", "Youtube-dlc%s Command Line Interface." % _x86),
+                    StringStruct("CompanyName", "pukkandan@gmail.com"),
+                    StringStruct("FileDescription", FILE_DESCRIPTION),
+                    StringStruct("FileVersion", VERSION),
+                    StringStruct("InternalName", "youtube-dlc%s" % _x86),
+                    StringStruct(
+                        "LegalCopyright",
+                        "pukkandan@gmail.com | UNLICENSE",
+                    ),
+                    StringStruct("OriginalFilename", "youtube-dlc%s.exe" % _x86),
+                    StringStruct("ProductName", "Youtube-dlc%s" % _x86),
+                    StringStruct("ProductVersion", "%s%s | %s" % (VERSION, _x86, SHORT_URLS[sys.argv[1]])),
+                ])]),
+        VarFileInfo([VarStruct("Translation", [0, 1200])])
+    ]
+)
+
+PyInstaller.__main__.run([
+    '--name=youtube-dlc%s' % _x86,
+    '--onefile',
+    '--icon=devscripts/cloud.ico',
+    '--exclude-module=youtube_dl',
+    '--exclude-module=test',
+    '--exclude-module=ytdlp_plugins',
+    '--hidden-import=mutagen',
+    'youtube_dlc/__main__.py',
+])
+SetVersion('dist/youtube-dlc%s.exe' % _x86, VERSION_FILE)
--- a/devscripts/update-version.py
+++ b/devscripts/update-version.py
@@ -0,0 +1,31 @@
+from __future__ import unicode_literals
+from datetime import datetime
+# import urllib.request
+
+# response = urllib.request.urlopen('https://blackjack4494.github.io/youtube-dlc/update/LATEST_VERSION')
+# old_version = response.read().decode('utf-8')
+
+exec(compile(open('youtube_dlc/version.py').read(), 'youtube_dlc/version.py', 'exec'))
+old_version = locals()['__version__']
+
+old_version_list = old_version.replace('-', '.').split(".", 4)
+
+old_ver = '.'.join(old_version_list[:3])
+old_rev = old_version_list[3] if len(old_version_list) > 3 else ''
+
+ver = datetime.now().strftime("%Y.%m.%d")
+rev = str(int(old_rev or 0) + 1) if old_ver == ver else ''
+
+VERSION = '.'.join((ver, rev)) if rev else ver
+# VERSION_LIST = [(int(v) for v in ver.split(".") + [rev or 0])]
+
+print('::set-output name=ytdlc_version::' + VERSION)
+
+file_version_py = open('youtube_dlc/version.py', 'rt')
+data = file_version_py.read()
+data = data.replace(old_version, VERSION)
+file_version_py.close()
+
+file_version_py = open('youtube_dlc/version.py', 'wt')
+file_version_py.write(data)
+file_version_py.close()
--- a/docs/supportedsites.md
+++ b/docs/supportedsites.md
@@ -80,6 +80,8 @@
 - **AudioBoom**
 - **audiomack**
 - **audiomack:album**
+ - **Audius**
+ - **audius:playlist**
 - **AWAAN**
 - **awaan:live**
 - **awaan:season**
@@ -112,7 +114,9 @@
 - **BiliBili**
 - **BilibiliAudio**
 - **BilibiliAudioAlbum**
+ - **BilibiliChannel**
 - **BiliBiliPlayer**
+ - **BiliBiliSearch**: Bilibili video search, "bilisearch" keyword
 - **BioBioChileTV**
 - **Biography**
 - **BIQLE**
--- a/make_win.bat
+++ b/make_win.bat
@@ -1 +0,0 @@
-py -m PyInstaller youtube_dlc\__main__.py --onefile --name youtube-dlc --version-file win\ver.txt --icon win\icon\cloud.ico --upx-exclude=vcruntime140.dll --exclude-module ytdlp_plugins
--- a/pyinst.py
+++ b/pyinst.py
@@ -1,92 +0,0 @@
-from __future__ import unicode_literals
-from PyInstaller.utils.win32.versioninfo import (
-    VarStruct, VarFileInfo, StringStruct, StringTable,
-    StringFileInfo, FixedFileInfo, VSVersionInfo, SetVersion,
-)
-import PyInstaller.__main__
-
-from datetime import datetime
-
-FILE_DESCRIPTION = 'Media Downloader'
-
-exec(compile(open('youtube_dlc/version.py').read(), 'youtube_dlc/version.py', 'exec'))
-
-_LATEST_VERSION = locals()['__version__']
-
-_OLD_VERSION = _LATEST_VERSION.rsplit("-", 1)
-
-if len(_OLD_VERSION) > 0:
-    old_ver = _OLD_VERSION[0]
-
-old_rev = ''
-if len(_OLD_VERSION) > 1:
-    old_rev = _OLD_VERSION[1]
-
-now = datetime.now()
-# ver = f'{datetime.today():%Y.%m.%d}'
-ver = now.strftime("%Y.%m.%d")
-rev = ''
-
-if old_ver == ver:
-    if old_rev:
-        rev = int(old_rev) + 1
-    else:
-        rev = 1
-
-_SEPARATOR = '-'
-
-version = _SEPARATOR.join(filter(None, [ver, str(rev)]))
-
-print(version)
-
-version_list = ver.split(".")
-_year, _month, _day = [int(value) for value in version_list]
-_rev = 0
-if rev:
-    _rev = rev
-_ver_tuple = _year, _month, _day, _rev
-
-version_file = VSVersionInfo(
-    ffi=FixedFileInfo(
-        filevers=_ver_tuple,
-        prodvers=_ver_tuple,
-        mask=0x3F,
-        flags=0x0,
-        OS=0x4,
-        fileType=0x1,
-        subtype=0x0,
-        date=(0, 0),
-    ),
-    kids=[
-        StringFileInfo(
-            [
-                StringTable(
-                    "040904B0",
-                    [
-                        StringStruct("Comments", "Youtube-dlc Command Line Interface."),
-                        StringStruct("CompanyName", "theidel@uni-bremen.de"),
-                        StringStruct("FileDescription", FILE_DESCRIPTION),
-                        StringStruct("FileVersion", version),
-                        StringStruct("InternalName", "youtube-dlc"),
-                        StringStruct(
-                            "LegalCopyright",
-                            "theidel@uni-bremen.de | UNLICENSE",
-                        ),
-                        StringStruct("OriginalFilename", "youtube-dlc.exe"),
-                        StringStruct("ProductName", "Youtube-dlc"),
-                        StringStruct("ProductVersion", version + " | git.io/JLh7K"),
-                    ],
-                )
-            ]
-        ),
-        VarFileInfo([VarStruct("Translation", [0, 1200])])
-    ]
-)
-
-PyInstaller.__main__.run([
-    '--name=youtube-dlc',
-    '--onefile',
-    '--icon=win/icon/cloud.ico',
-    'youtube_dlc/__main__.py',
-])
-SetVersion('dist/youtube-dlc.exe', version_file)
--- a/pyinst32.py
+++ b/pyinst32.py
@@ -1,92 +0,0 @@
-from __future__ import unicode_literals
-from PyInstaller.utils.win32.versioninfo import (
-    VarStruct, VarFileInfo, StringStruct, StringTable,
-    StringFileInfo, FixedFileInfo, VSVersionInfo, SetVersion,
-)
-import PyInstaller.__main__
-
-from datetime import datetime
-
-FILE_DESCRIPTION = 'Media Downloader 32 Bit Version'
-
-exec(compile(open('youtube_dlc/version.py').read(), 'youtube_dlc/version.py', 'exec'))
-
-_LATEST_VERSION = locals()['__version__']
-
-_OLD_VERSION = _LATEST_VERSION.rsplit("-", 1)
-
-if len(_OLD_VERSION) > 0:
-    old_ver = _OLD_VERSION[0]
-
-old_rev = ''
-if len(_OLD_VERSION) > 1:
-    old_rev = _OLD_VERSION[1]
-
-now = datetime.now()
-# ver = f'{datetime.today():%Y.%m.%d}'
-ver = now.strftime("%Y.%m.%d")
-rev = ''
-
-if old_ver == ver:
-    if old_rev:
-        rev = int(old_rev) + 1
-    else:
-        rev = 1
-
-_SEPARATOR = '-'
-
-version = _SEPARATOR.join(filter(None, [ver, str(rev)]))
-
-print(version)
-
-version_list = ver.split(".")
-_year, _month, _day = [int(value) for value in version_list]
-_rev = 0
-if rev:
-    _rev = rev
-_ver_tuple = _year, _month, _day, _rev
-
-version_file = VSVersionInfo(
-    ffi=FixedFileInfo(
-        filevers=_ver_tuple,
-        prodvers=_ver_tuple,
-        mask=0x3F,
-        flags=0x0,
-        OS=0x4,
-        fileType=0x1,
-        subtype=0x0,
-        date=(0, 0),
-    ),
-    kids=[
-        StringFileInfo(
-            [
-                StringTable(
-                    "040904B0",
-                    [
-                        StringStruct("Comments", "Youtube-dlc_x86 Command Line Interface."),
-                        StringStruct("CompanyName", "theidel@uni-bremen.de"),
-                        StringStruct("FileDescription", FILE_DESCRIPTION),
-                        StringStruct("FileVersion", version),
-                        StringStruct("InternalName", "youtube-dlc_x86"),
-                        StringStruct(
-                            "LegalCopyright",
-                            "theidel@uni-bremen.de | UNLICENSE",
-                        ),
-                        StringStruct("OriginalFilename", "youtube-dlc_x86.exe"),
-                        StringStruct("ProductName", "Youtube-dlc_x86"),
-                        StringStruct("ProductVersion", version + "_x86 | git.io/JUGsM"),
-                    ],
-                )
-            ]
-        ),
-        VarFileInfo([VarStruct("Translation", [0, 1200])])
-    ]
-)
-
-PyInstaller.__main__.run([
-    '--name=youtube-dlc_x86',
-    '--onefile',
-    '--icon=win/icon/cloud.ico',
-    'youtube_dlc/__main__.py',
-])
-SetVersion('dist/youtube-dlc_x86.exe', version_file)
--- a/requirements.txt
+++ b/requirements.txt
@@ -0,0 +1 @@
+mutagen
--- a/scripts/update-version-workflow.py
+++ b/scripts/update-version-workflow.py
@@ -1,44 +0,0 @@
-from __future__ import unicode_literals
-from datetime import datetime
-# import urllib.request
-
-# response = urllib.request.urlopen('https://blackjack4494.github.io/youtube-dlc/update/LATEST_VERSION')
-# _LATEST_VERSION = response.read().decode('utf-8')
-
-exec(compile(open('youtube_dlc/version.py').read(), 'youtube_dlc/version.py', 'exec'))
-
-_LATEST_VERSION = locals()['__version__']
-
-_OLD_VERSION = _LATEST_VERSION.rsplit("-", 1)
-
-if len(_OLD_VERSION) > 0:
-    old_ver = _OLD_VERSION[0]
-
-old_rev = ''
-if len(_OLD_VERSION) > 1:
-    old_rev = _OLD_VERSION[1]
-
-now = datetime.now()
-# ver = f'{datetime.today():%Y.%m.%d}'
-ver = now.strftime("%Y.%m.%d")
-rev = ''
-
-if old_ver == ver:
-    if old_rev:
-        rev = int(old_rev) + 1
-    else:
-        rev = 1
-
-_SEPARATOR = '-'
-
-version = _SEPARATOR.join(filter(None, [ver, str(rev)]))
-
-print('::set-output name=ytdlc_version::' + version)
-
-file_version_py = open('youtube_dlc/version.py', 'rt')
-data = file_version_py.read()
-data = data.replace(locals()['__version__'], version)
-file_version_py.close()
-file_version_py = open('youtube_dlc/version.py', 'wt')
-file_version_py.write(data)
-file_version_py.close()
--- a/scripts/update-version.py
+++ b/scripts/update-version.py
@@ -1,33 +0,0 @@
-# Unused
-
-from __future__ import unicode_literals
-from datetime import datetime
-import urllib.request
-
-response = urllib.request.urlopen('https://blackjack4494.github.io/youtube-dlc/update/LATEST_VERSION')
-
-_LATEST_VERSION = response.read().decode('utf-8')
-
-_OLD_VERSION = _LATEST_VERSION.rsplit("-", 1)
-
-if len(_OLD_VERSION) > 0:
-    old_ver = _OLD_VERSION[0]
-
-old_rev = ''
-if len(_OLD_VERSION) > 1:
-    old_rev = _OLD_VERSION[1]
-
-now = datetime.now()
-# ver = f'{datetime.today():%Y.%m.%d}'
-ver = now.strftime("%Y.%m.%d")
-rev = ''
-
-if old_ver == ver:
-    if old_rev:
-        rev = int(old_rev) + 1
-    else:
-        rev = 1
-
-_SEPARATOR = '-'
-
-version = _SEPARATOR.join(filter(None, [ver, str(rev)]))
--- a/setup.cfg
+++ b/setup.cfg
@@ -2,5 +2,5 @@
 universal = True

 [flake8]
-exclude = youtube_dlc/extractor/__init__.py,devscripts/buildserver.py,devscripts/lazy_load_template.py,devscripts/make_issue_template.py,setup.py,build,.git,venv,devscripts/create-github-release.py,devscripts/release.sh,devscripts/show-downloads-statistics.py,scripts/update-version.py
+exclude = youtube_dlc/extractor/__init__.py,devscripts/buildserver.py,devscripts/lazy_load_template.py,devscripts/make_issue_template.py,setup.py,build,.git,venv,devscripts/create-github-release.py,devscripts/release.sh,devscripts/show-downloads-statistics.py
 ignore = E402,E501,E731,E741,W503
--- a/setup.py
+++ b/setup.py
@@ -7,10 +7,12 @@ import warnings
 import sys
 from distutils.spawn import spawn

+
 # Get the version from youtube_dlc/version.py without importing the package
 exec(compile(open('youtube_dlc/version.py').read(),
             'youtube_dlc/version.py', 'exec'))

+
 DESCRIPTION = 'Command-line program to download videos from YouTube.com and many other other video platforms.'

 LONG_DESCRIPTION = '\n\n'.join((
@@ -18,6 +20,9 @@ LONG_DESCRIPTION = '\n\n'.join((
    '**PS**: Many links in this document will not work since this is a copy of the README.md from Github',
    open("README.md", "r", encoding="utf-8").read()))

+REQUIREMENTS = ['mutagen']
+
+
 if len(sys.argv) >= 2 and sys.argv[1] == 'py2exe':
    print("inv")
 else:
@@ -41,10 +46,8 @@ else:
    params = {
        'data_files': data_files,
    }
-    #if setuptools_available:
    params['entry_points'] = {'console_scripts': ['youtube-dlc = youtube_dlc:main']}
-    #else:
-    #    params['scripts'] = ['bin/youtube-dlc']
+

 class build_lazy_extractors(Command):
    description = 'Build the extractor lazy loading module'
@@ -62,6 +65,9 @@ class build_lazy_extractors(Command):
            dry_run=self.dry_run,
        )

+
+packages = find_packages(exclude=("youtube_dl", "test", "ytdlp_plugins"))
+
 setup(
    name="yt-dlp",
    version=__version__,
@@ -71,7 +77,8 @@ setup(
    long_description=LONG_DESCRIPTION,
    long_description_content_type="text/markdown",
    url="https://github.com/pukkandan/yt-dlp",
-    packages=find_packages(exclude=("youtube_dl","test",)),
+    packages=packages,
+    install_requires=REQUIREMENTS,
    project_urls={
        'Documentation': 'https://github.com/pukkandan/yt-dlp#yt-dlp',
        'Source': 'https://github.com/pukkandan/yt-dlp',
--- a/test/test_postprocessors.py
+++ b/test/test_postprocessors.py
@@ -8,10 +8,16 @@ import sys
 import unittest
 sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))

-from youtube_dlc.postprocessor import MetadataFromTitlePP
+from youtube_dlc.postprocessor import MetadataFromFieldPP, MetadataFromTitlePP
+
+
+class TestMetadataFromField(unittest.TestCase):
+    def test_format_to_regex(self):
+        pp = MetadataFromFieldPP(None, ['title:%(title)s - %(artist)s'])
+        self.assertEqual(pp._data[0]['regex'], r'(?P<title>[^\r\n]+)\ \-\ (?P<artist>[^\r\n]+)')


 class TestMetadataFromTitle(unittest.TestCase):
    def test_format_to_regex(self):
        pp = MetadataFromTitlePP(None, '%(title)s - %(artist)s')
-        self.assertEqual(pp._titleregex, r'(?P<title>.+)\ \-\ (?P<artist>.+)')
+        self.assertEqual(pp._titleregex, r'(?P<title>[^\r\n]+)\ \-\ (?P<artist>[^\r\n]+)')
--- a/test/test_unicode_literals.py
+++ b/test/test_unicode_literals.py
@@ -15,8 +15,6 @@ IGNORED_FILES = [
    'setup.py',  # http://bugs.python.org/issue13943
    'conf.py',
    'buildserver.py',
-    'pyinst.py',
-    'pyinst32.py',
 ]

 IGNORED_DIRS = [
--- a/win/ver.txt
+++ b/win/ver.txt
@@ -1,45 +0,0 @@
-# UTF-8
-#
-# For more details about fixed file info 'ffi' see:
-# http://msdn.microsoft.com/en-us/library/ms646997.aspx
-VSVersionInfo(
-  ffi=FixedFileInfo(
-    # filevers and prodvers should be always a tuple with four items: (1, 2, 3, 4)
-    # Set not needed items to zero 0.
-    filevers=(16, 9, 2020, 0),
-    prodvers=(16, 9, 2020, 0),
-    # Contains a bitmask that specifies the valid bits 'flags'r
-    mask=0x3f,
-    # Contains a bitmask that specifies the Boolean attributes of the file.
-    flags=0x0,
-    # The operating system for which this file was designed.
-    # 0x4 - NT and there is no need to change it.
-    # OS=0x40004,
-	OS=0x4,
-    # The general type of file.
-    # 0x1 - the file is an application.
-    fileType=0x1,
-    # The function of the file.
-    # 0x0 - the function is not defined for this fileType
-    subtype=0x0,
-    # Creation date and time stamp.
-    date=(0, 0)
-    ),
-  kids=[
-    StringFileInfo(
-      [
-      StringTable(
-        u'040904B0',
-        [StringStruct(u'Comments', u'Youtube-dlc Command Line Interface.'),
-	StringStruct(u'CompanyName', u'theidel@uni-bremen.de'),
-        StringStruct(u'FileDescription', u'Media Downloader'),
-        StringStruct(u'FileVersion', u'16.9.2020.0'),
-        StringStruct(u'InternalName', u'youtube-dlc'),
-        StringStruct(u'LegalCopyright', u'theidel@uni-bremen.de | UNLICENSE'),
-        StringStruct(u'OriginalFilename', u'youtube-dlc.exe'),
-        StringStruct(u'ProductName', u'Youtube-dlc'),
-        StringStruct(u'ProductVersion', u'16.9.2020.0 | git.io/JUGsM')])
-      ]), 
-    VarFileInfo([VarStruct(u'Translation', [0, 1200])])
-  ]
-)
--- a/youtube_dlc/YoutubeDL.py
+++ b/youtube_dlc/YoutubeDL.py
@@ -202,6 +202,8 @@ class YoutubeDL(object):
    logtostderr:       Log messages to stderr instead of stdout.
    writedescription:  Write the video description to a .description file
    writeinfojson:     Write the video description to a .info.json file
+    writecomments:     Extract video comments. This will not be written to disk
+                       unless writeinfojson is also given
    writeannotations:  Write the video annotations to a .annotations.xml file
    writethumbnail:    Write the thumbnail image to a file
    write_all_thumbnails:  Write all thumbnail formats to files
@@ -294,6 +296,9 @@ class YoutubeDL(object):
                       Progress hooks are guaranteed to be called at least once
                       (with status "finished") if the download is successful.
    merge_output_format: Extension to use when merging formats.
+    final_ext:         Expected final extension; used to detect when the file was
+                       already downloaded and converted. "merge_output_format" is
+                       replaced by this extension when given
    fixup:             Automatically correct known faults of the file.
                       One of:
                       - "never": do nothing
@@ -347,7 +352,7 @@ class YoutubeDL(object):

    The following options are used by the post processors:
    prefer_ffmpeg:     If False, use avconv instead of ffmpeg if both are available,
-                       otherwise prefer ffmpeg.
+                       otherwise prefer ffmpeg. (avconv support is deprecated)
    ffmpeg_location:   Location of the ffmpeg/avconv binary; either the path
                       to the binary or its containing directory.
    postprocessor_args: A dictionary of postprocessor/executable keys (in lower case)
@@ -375,8 +380,7 @@ class YoutubeDL(object):

    params = None
    _ies = []
-    _pps = []
-    _pps_end = []
+    _pps = {'beforedl': [], 'aftermove': [], 'normal': []}
    __prepare_filename_warned = False
    _download_retcode = None
    _num_downloads = None
@@ -390,8 +394,7 @@ class YoutubeDL(object):
            params = {}
        self._ies = []
        self._ies_instances = {}
-        self._pps = []
-        self._pps_end = []
+        self._pps = {'beforedl': [], 'aftermove': [], 'normal': []}
        self.__prepare_filename_warned = False
        self._post_hooks = []
        self._progress_hooks = []
@@ -438,6 +441,11 @@ class YoutubeDL(object):
            if self.params.get('geo_verification_proxy') is None:
                self.params['geo_verification_proxy'] = self.params['cn_verification_proxy']

+        if self.params.get('final_ext'):
+            if self.params.get('merge_output_format'):
+                self.report_warning('--merge-output-format will be ignored since --remux-video or --recode-video is given')
+            self.params['merge_output_format'] = self.params['final_ext']
+
        check_deprecated('autonumber_size', '--autonumber-size', 'output template with %(autonumber)0Nd, where N in the number of digits')
        check_deprecated('autonumber', '--auto-number', '-o "%(autonumber)s-%(title)s.%(ext)s"')
        check_deprecated('usetitle', '--title', '-o "%(title)s-%(id)s.%(ext)s"')
@@ -494,11 +502,13 @@ class YoutubeDL(object):
            pp_class = get_postprocessor(pp_def_raw['key'])
            pp_def = dict(pp_def_raw)
            del pp_def['key']
-            after_move = pp_def.get('_after_move', False)
-            if '_after_move' in pp_def:
-                del pp_def['_after_move']
+            if 'when' in pp_def:
+                when = pp_def['when']
+                del pp_def['when']
+            else:
+                when = 'normal'
            pp = pp_class(self, **compat_kwargs(pp_def))
-            self.add_post_processor(pp, after_move=after_move)
+            self.add_post_processor(pp, when=when)

        for ph in self.params.get('post_hooks', []):
            self.add_post_hook(ph)
@@ -550,12 +560,9 @@ class YoutubeDL(object):
        for ie in gen_extractor_classes():
            self.add_info_extractor(ie)

-    def add_post_processor(self, pp, after_move=False):
+    def add_post_processor(self, pp, when='normal'):
        """Add a PostProcessor object to the end of the chain."""
-        if after_move:
-            self._pps_end.append(pp)
-        else:
-            self._pps.append(pp)
+        self._pps[when].append(pp)
        pp.set_downloader(self)

    def add_post_hook(self, ph):
@@ -933,9 +940,7 @@ class YoutubeDL(object):
                self.to_screen("[%s] %s: has already been recorded in archive" % (
                               ie_key, temp_id))
                break
-
            return self.__extract_info(url, ie, download, extra_info, process, info_dict)
-
        else:
            self.report_error('no suitable InfoExtractor for URL %s' % url)

@@ -1103,6 +1108,54 @@ class YoutubeDL(object):
        # We process each entry in the playlist
        playlist = ie_result.get('title') or ie_result.get('id')
        self.to_screen('[download] Downloading playlist: %s' % playlist)
+        ie_copy = {
+            'playlist': playlist,
+            'playlist_id': ie_result.get('id'),
+            'playlist_title': ie_result.get('title'),
+            'playlist_uploader': ie_result.get('uploader'),
+            'playlist_uploader_id': ie_result.get('uploader_id'),
+            'playlist_index': 0
+        }
+        ie_copy.update(dict(ie_result))
+
+        def ensure_dir_exists(path):
+            return make_dir(path, self.report_error)
+
+        if self.params.get('writeinfojson', False):
+            infofn = replace_extension(
+                self.prepare_filepath(self.prepare_filename(ie_copy), 'infojson'),
+                'info.json', ie_result.get('ext'))
+            if not ensure_dir_exists(encodeFilename(infofn)):
+                return
+            if self.params.get('overwrites', True) and os.path.exists(encodeFilename(infofn)):
+                self.to_screen('[info] Playlist metadata is already present')
+            else:
+                self.to_screen('[info] Writing playlist metadata as JSON to: ' + infofn)
+                playlist_info = dict(ie_result)
+                playlist_info.pop('entries')
+                try:
+                    write_json_file(self.filter_requested_info(playlist_info), infofn)
+                except (OSError, IOError):
+                    self.report_error('Cannot write playlist metadata to JSON file ' + infofn)
+
+        if self.params.get('writedescription', False):
+            descfn = replace_extension(
+                self.prepare_filepath(self.prepare_filename(ie_copy), 'description'),
+                'description', ie_result.get('ext'))
+            if not ensure_dir_exists(encodeFilename(descfn)):
+                return
+            if not self.params.get('overwrites', True) and os.path.exists(encodeFilename(descfn)):
+                self.to_screen('[info] Playlist description is already present')
+            elif ie_result.get('description') is None:
+                self.report_warning('There\'s no playlist description to write.')
+            else:
+                try:
+                    self.to_screen('[info] Writing playlist description to: ' + descfn)
+                    with io.open(encodeFilename(descfn), 'w', encoding='utf-8') as descfile:
+                        descfile.write(ie_result['description'])
+                except (OSError, IOError):
+                    self.report_error('Cannot write playlist description file ' + descfn)
+                    return

        playlist_results = []

@@ -1948,6 +2001,8 @@ class YoutubeDL(object):

        self._num_downloads += 1

+        info_dict = self.pre_process(info_dict)
+
        filename = self.prepare_filename(info_dict, warn=True)
        info_dict['_filename'] = full_filename = self.prepare_filepath(filename)
        temp_filename = self.prepare_filepath(filename, 'temp')
@@ -2098,14 +2153,15 @@ class YoutubeDL(object):
            if not ensure_dir_exists(encodeFilename(infofn)):
                return
            if not self.params.get('overwrites', True) and os.path.exists(encodeFilename(infofn)):
-                self.to_screen('[info] Video description metadata is already present')
+                self.to_screen('[info] Video metadata is already present')
            else:
-                self.to_screen('[info] Writing video description metadata as JSON to: ' + infofn)
+                self.to_screen('[info] Writing video metadata as JSON to: ' + infofn)
                try:
                    write_json_file(self.filter_requested_info(info_dict), infofn)
                except (OSError, IOError):
-                    self.report_error('Cannot write metadata to JSON file ' + infofn)
+                    self.report_error('Cannot write video metadata to JSON file ' + infofn)
                    return
+            info_dict['__infojson_filepath'] = infofn

        thumbdir = os.path.dirname(self.prepare_filepath(filename, 'thumbnail'))
        for thumbfn in self._write_thumbnails(info_dict, temp_filename):
@@ -2165,22 +2221,27 @@ class YoutubeDL(object):
        if not self.params.get('skip_download', False):
            try:

-                def existing_file(filename, temp_filename):
-                    file_exists = os.path.exists(encodeFilename(filename))
-                    tempfile_exists = (
-                        False if temp_filename == filename
-                        else os.path.exists(encodeFilename(temp_filename)))
-                    if not self.params.get('overwrites', False) and (file_exists or tempfile_exists):
-                        existing_filename = temp_filename if tempfile_exists else filename
-                        self.to_screen('[download] %s has already been downloaded and merged' % existing_filename)
-                        return existing_filename
-                    if tempfile_exists:
-                        self.report_file_delete(temp_filename)
-                        os.remove(encodeFilename(temp_filename))
-                    if file_exists:
-                        self.report_file_delete(filename)
-                        os.remove(encodeFilename(filename))
-                    return None
+                def existing_file(*filepaths):
+                    ext = info_dict.get('ext')
+                    final_ext = self.params.get('final_ext', ext)
+                    existing_files = []
+                    for file in orderedSet(filepaths):
+                        if final_ext != ext:
+                            converted = replace_extension(file, final_ext, ext)
+                            if os.path.exists(encodeFilename(converted)):
+                                existing_files.append(converted)
+                        if os.path.exists(encodeFilename(file)):
+                            existing_files.append(file)
+
+                    if not existing_files or self.params.get('overwrites', False):
+                        for file in orderedSet(existing_files):
+                            self.report_file_delete(file)
+                            os.remove(encodeFilename(file))
+                        return None
+
+                    self.report_file_already_downloaded(existing_files[0])
+                    info_dict['ext'] = os.path.splitext(existing_files[0])[1][1:]
+                    return existing_files[0]

                success = True
                if info_dict.get('requested_formats') is not None:
@@ -2189,7 +2250,7 @@ class YoutubeDL(object):
                    if not merger.available:
                        postprocessors = []
                        self.report_warning('You have requested multiple '
-                                            'formats but ffmpeg or avconv are not installed.'
+                                            'formats but ffmpeg is not installed.'
                                            ' The formats won\'t be merged.')
                    else:
                        postprocessors = [merger]
@@ -2273,7 +2334,7 @@ class YoutubeDL(object):
                if fixup_policy is None:
                    fixup_policy = 'detect_or_warn'

-                INSTALL_FFMPEG_MESSAGE = 'Install ffmpeg or avconv to fix this automatically.'
+                INSTALL_FFMPEG_MESSAGE = 'Install ffmpeg to fix this automatically.'

                stretched_ratio = info_dict.get('stretched_ratio')
                if stretched_ratio is not None and stretched_ratio != 1:
@@ -2292,7 +2353,8 @@ class YoutubeDL(object):
                        assert fixup_policy in ('ignore', 'never')

                if (info_dict.get('requested_formats') is None
-                        and info_dict.get('container') == 'm4a_dash'):
+                        and info_dict.get('container') == 'm4a_dash'
+                        and info_dict.get('ext') == 'm4a'):
                    if fixup_policy == 'warn':
                        self.report_warning(
                            '%s: writing DASH m4a. '
@@ -2400,41 +2462,45 @@ class YoutubeDL(object):
            (k, v) for k, v in info_dict.items()
            if k not in ['requested_formats', 'requested_subtitles'])

+    def run_pp(self, pp, infodict, files_to_move={}):
+        files_to_delete = []
+        try:
+            files_to_delete, infodict = pp.run(infodict)
+        except PostProcessingError as e:
+            self.report_error(e.msg)
+        if not files_to_delete:
+            return files_to_move, infodict
+
+        if self.params.get('keepvideo', False):
+            for f in files_to_delete:
+                files_to_move.setdefault(f, '')
+        else:
+            for old_filename in set(files_to_delete):
+                self.to_screen('Deleting original file %s (pass -k to keep)' % old_filename)
+                try:
+                    os.remove(encodeFilename(old_filename))
+                except (IOError, OSError):
+                    self.report_warning('Unable to remove downloaded original file')
+                if old_filename in files_to_move:
+                    del files_to_move[old_filename]
+        return files_to_move, infodict
+
+    def pre_process(self, ie_info):
+        info = dict(ie_info)
+        for pp in self._pps['beforedl']:
+            info = self.run_pp(pp, info)[1]
+        return info
+
    def post_process(self, filename, ie_info, files_to_move={}):
        """Run all the postprocessors on the given file."""
        info = dict(ie_info)
        info['filepath'] = filename

-        def run_pp(pp):
-            files_to_delete = []
-            infodict = info
-            try:
-                files_to_delete, infodict = pp.run(infodict)
-            except PostProcessingError as e:
-                self.report_error(e.msg)
-            if not files_to_delete:
-                return infodict
-
-            if self.params.get('keepvideo', False):
-                for f in files_to_delete:
-                    files_to_move.setdefault(f, '')
-            else:
-                for old_filename in set(files_to_delete):
-                    self.to_screen('Deleting original file %s (pass -k to keep)' % old_filename)
-                    try:
-                        os.remove(encodeFilename(old_filename))
-                    except (IOError, OSError):
-                        self.report_warning('Unable to remove downloaded original file')
-                    if old_filename in files_to_move:
-                        del files_to_move[old_filename]
-            return infodict
-
-        for pp in ie_info.get('__postprocessors', []) + self._pps:
-            info = run_pp(pp)
-        info = run_pp(MoveFilesAfterDownloadPP(self, files_to_move))
-        files_to_move = {}
-        for pp in self._pps_end:
-            info = run_pp(pp)
+        for pp in ie_info.get('__postprocessors', []) + self._pps['normal']:
+            files_to_move, info = self.run_pp(pp, info, files_to_move)
+        info = self.run_pp(MoveFilesAfterDownloadPP(self, files_to_move), info, files_to_move)[1]
+        for pp in self._pps['aftermove']:
+            files_to_move, info = self.run_pp(pp, info, {})

    def _make_archive_id(self, info_dict):
        video_id = info_dict.get('id')
--- a/youtube_dlc/init.py
+++ b/youtube_dlc/init.py
@@ -15,6 +15,7 @@ import sys

 from .options import (
    parseOpts,
+    _remux_formats,
 )
 from .compat import (
    compat_getpass,
@@ -45,6 +46,7 @@ from .downloader import (
 from .extractor import gen_extractors, list_extractors
 from .extractor.common import InfoExtractor
 from .extractor.adobepass import MSO_INFO
+from .postprocessor.metadatafromfield import MetadataFromFieldPP
 from .YoutubeDL import YoutubeDL


@@ -208,12 +210,15 @@ def _real_main(argv=None):
        opts.audioquality = opts.audioquality.strip('k').strip('K')
        if not opts.audioquality.isdigit():
            parser.error('invalid audio quality specified')
-    if opts.remuxvideo is not None:
-        if opts.remuxvideo not in ['mp4', 'mkv']:
-            parser.error('invalid video container format specified')
    if opts.recodevideo is not None:
-        if opts.recodevideo not in ['mp4', 'flv', 'webm', 'ogg', 'mkv', 'avi']:
+        if opts.recodevideo not in _remux_formats:
            parser.error('invalid video recode format specified')
+    if opts.remuxvideo and opts.recodevideo:
+        opts.remuxvideo = None
+        write_string('WARNING: --remux-video is ignored since --recode-video was given\n', out=sys.stderr)
+    if opts.remuxvideo is not None:
+        if opts.remuxvideo not in _remux_formats:
+            parser.error('invalid video remux format specified')
    if opts.convertsubtitles is not None:
        if opts.convertsubtitles not in ['srt', 'vtt', 'ass', 'lrc']:
            parser.error('invalid subtitle format specified')
@@ -249,16 +254,25 @@ def _real_main(argv=None):
        if re.match(InfoExtractor.FormatSort.regex, f) is None:
            parser.error('invalid format sort string "%s" specified' % f)

+    if opts.metafromfield is None:
+        opts.metafromfield = []
+    if opts.metafromtitle is not None:
+        opts.metafromfield.append('title:%s' % opts.metafromtitle)
+    for f in opts.metafromfield:
+        if re.match(MetadataFromFieldPP.regex, f) is None:
+            parser.error('invalid format string "%s" specified for --parse-metadata' % f)
+
    any_getting = opts.geturl or opts.gettitle or opts.getid or opts.getthumbnail or opts.getdescription or opts.getfilename or opts.getformat or opts.getduration or opts.dumpjson or opts.dump_single_json
    any_printing = opts.print_json
    download_archive_fn = expand_path(opts.download_archive) if opts.download_archive is not None else opts.download_archive

    # PostProcessors
    postprocessors = []
-    if opts.metafromtitle:
+    if opts.metafromfield:
        postprocessors.append({
-            'key': 'MetadataFromTitle',
-            'titleformat': opts.metafromtitle
+            'key': 'MetadataFromField',
+            'formats': opts.metafromfield,
+            'when': 'beforedl'
        })
    if opts.extractaudio:
        postprocessors.append({
@@ -324,7 +338,7 @@ def _real_main(argv=None):
        postprocessors.append({
            'key': 'ExecAfterDownload',
            'exec_cmd': opts.exec_cmd,
-            '_after_move': True
+            'when': 'aftermove'
        })

    _args_compat_warning = 'WARNING: %s given without specifying name. The arguments will be given to all %s\n'
@@ -336,6 +350,8 @@ def _real_main(argv=None):
        opts.postprocessor_args.setdefault('sponskrub', [])
        opts.postprocessor_args['default'] = opts.postprocessor_args['default-compat']

+    audio_ext = opts.audioformat if (opts.extractaudio and opts.audioformat != 'best') else None
+
    match_filter = (
        None if opts.match_filter is None
        else match_filter_func(opts.match_filter))
@@ -403,7 +419,8 @@ def _real_main(argv=None):
        'updatetime': opts.updatetime,
        'writedescription': opts.writedescription,
        'writeannotations': opts.writeannotations,
-        'writeinfojson': opts.writeinfojson,
+        'writeinfojson': opts.writeinfojson or opts.getcomments,
+        'getcomments': opts.getcomments,
        'writethumbnail': opts.writethumbnail,
        'write_all_thumbnails': opts.write_all_thumbnails,
        'writelink': opts.writelink,
@@ -454,6 +471,7 @@ def _real_main(argv=None):
        'extract_flat': opts.extract_flat,
        'mark_watched': opts.mark_watched,
        'merge_output_format': opts.merge_output_format,
+        'final_ext': opts.recodevideo or opts.remuxvideo or audio_ext,
        'postprocessors': postprocessors,
        'fixup': opts.fixup,
        'source_address': opts.source_address,
--- a/youtube_dlc/downloader/external.py
+++ b/youtube_dlc/downloader/external.py
@@ -233,7 +233,7 @@ class FFmpegFD(ExternalFD):
        url = info_dict['url']
        ffpp = FFmpegPostProcessor(downloader=self)
        if not ffpp.available:
-            self.report_error('m3u8 download detected but ffmpeg or avconv could not be found. Please install one.')
+            self.report_error('m3u8 download detected but ffmpeg could not be found. Please install one.')
            return False
        ffpp.check_version()

--- a/youtube_dlc/extractor/init.py
+++ b/youtube_dlc/extractor/init.py
@@ -7,9 +7,10 @@ try:
    from .lazy_extractors import _ALL_CLASSES
    _LAZY_LOADER = True
    _PLUGIN_CLASSES = []
-
 except ImportError:
    _LAZY_LOADER = False
+
+if not _LAZY_LOADER:
    from .extractors import *

    _PLUGIN_CLASSES = load_plugins('extractor', 'IE', globals())
--- a/youtube_dlc/extractor/anvato.py
+++ b/youtube_dlc/extractor/anvato.py
@@ -21,6 +21,16 @@ from ..utils import (
    unsmuggle_url,
 )

+# This import causes a ModuleNotFoundError on some systems for unknown reason.
+# See issues:
+# https://github.com/pukkandan/yt-dlp/issues/35
+# https://github.com/ytdl-org/youtube-dl/issues/27449
+# https://github.com/animelover1984/youtube-dl/issues/17
+try:
+    from .anvato_token_generator import NFLTokenGenerator
+except ImportError:
+    NFLTokenGenerator = None
+

 def md5_text(s):
    if not isinstance(s, compat_str):
@@ -203,6 +213,10 @@ class AnvatoIE(InfoExtractor):
        'telemundo': 'anvato_mcp_telemundo_web_prod_c5278d51ad46fda4b6ca3d0ea44a7846a054f582'
    }

+    _TOKEN_GENERATORS = {
+        'GXvEgwyJeWem8KCYXfeoHWknwP48Mboj': NFLTokenGenerator,
+    }
+
    _API_KEY = '3hwbSuqqT690uxjNYBktSQpa5ZrpYYR0Iofx7NcJHyA'

    _ANVP_RE = r'<script[^>]+\bdata-anvp\s*=\s*(["\'])(?P<anvp>(?:(?!\1).)+)\1'
@@ -262,9 +276,12 @@ class AnvatoIE(InfoExtractor):
            'anvrid': anvrid,
            'anvts': server_time,
        }
-        api['anvstk'] = md5_text('%s|%s|%d|%s' % (
-            access_key, anvrid, server_time,
-            self._ANVACK_TABLE.get(access_key, self._API_KEY)))
+        if self._TOKEN_GENERATORS.get(access_key) is not None:
+            api['anvstk2'] = self._TOKEN_GENERATORS[access_key].generate(self, access_key, video_id)
+        else:
+            api['anvstk'] = md5_text('%s|%s|%d|%s' % (
+                access_key, anvrid, server_time,
+                self._ANVACK_TABLE.get(access_key, self._API_KEY)))

        return self._download_json(
            video_data_url, video_id, transform_source=strip_jsonp,
--- a/youtube_dlc/extractor/audius.py
+++ b/youtube_dlc/extractor/audius.py
@@ -0,0 +1,224 @@
+# coding: utf-8
+from __future__ import unicode_literals
+
+import random
+import re
+
+from .common import InfoExtractor
+from ..utils import ExtractorError, try_get, compat_str, str_or_none
+from ..compat import compat_urllib_parse_unquote
+
+
+class AudiusBaseIE(InfoExtractor):
+    _API_BASE = None
+    _API_V = '/v1'
+
+    def _get_response_data(self, response):
+        if isinstance(response, dict):
+            response_data = response.get('data')
+            if response_data is not None:
+                return response_data
+            if len(response) == 1 and 'message' in response:
+                raise ExtractorError('API error: %s' % response['message'],
+                                     expected=True)
+        raise ExtractorError('Unexpected API response')
+
+    def _select_api_base(self):
+        """Selecting one of the currently available API hosts"""
+        response = super(AudiusBaseIE, self)._download_json(
+            'https://api.audius.co/', None,
+            note='Requesting available API hosts',
+            errnote='Unable to request available API hosts')
+        hosts = self._get_response_data(response)
+        if isinstance(hosts, list):
+            self._API_BASE = random.choice(hosts)
+            return
+        raise ExtractorError('Unable to get available API hosts')
+
+    @staticmethod
+    def _prepare_url(url, title):
+        """
+        Audius removes forward slashes from the uri, but leaves backslashes.
+        The problem is that the current version of Chrome replaces backslashes
+        in the address bar with a forward slashes, so if you copy the link from
+        there and paste it into youtube-dl, you won't be able to download
+        anything from this link, since the Audius API won't be able to resolve
+        this url
+        """
+        url = compat_urllib_parse_unquote(url)
+        title = compat_urllib_parse_unquote(title)
+        if '/' in title or '%2F' in title:
+            fixed_title = title.replace('/', '%5C').replace('%2F', '%5C')
+            return url.replace(title, fixed_title)
+        return url
+
+    def _api_request(self, path, item_id=None, note='Downloading JSON metadata',
+                     errnote='Unable to download JSON metadata',
+                     expected_status=None):
+        if self._API_BASE is None:
+            self._select_api_base()
+        try:
+            response = super(AudiusBaseIE, self)._download_json(
+                '%s%s%s' % (self._API_BASE, self._API_V, path), item_id, note=note,
+                errnote=errnote, expected_status=expected_status)
+        except ExtractorError as exc:
+            # some of Audius API hosts may not work as expected and return HTML
+            if 'Failed to parse JSON' in compat_str(exc):
+                raise ExtractorError('An error occurred while receiving data. Try again',
+                                     expected=True)
+            raise exc
+        return self._get_response_data(response)
+
+    def _resolve_url(self, url, item_id):
+        return self._api_request('/resolve?url=%s' % url, item_id,
+                                 expected_status=404)
+
+
+class AudiusIE(AudiusBaseIE):
+    _VALID_URL = r'''(?x)https?://(?:www\.)?(?:audius\.co/(?P<uploader>[\w\d-]+)(?!/album|/playlist)/(?P<title>\S+))'''
+    _TESTS = [
+        {
+            # URL from Chrome address bar which replace backslash to forward slash
+            'url': 'https://audius.co/test_acc/t%D0%B5%D0%B5%D0%B5est-1.%5E_%7B%7D/%22%3C%3E.%E2%84%96~%60-198631',
+            'md5': '92c35d3e754d5a0f17eef396b0d33582',
+            'info_dict': {
+                'id': 'xd8gY',
+                'title': '''Tеееest/ 1.!@#$%^&*()_+=[]{};'\\\":<>,.?/№~`''',
+                'ext': 'mp3',
+                'description': 'Description',
+                'duration': 30,
+                'track': '''Tеееest/ 1.!@#$%^&*()_+=[]{};'\\\":<>,.?/№~`''',
+                'artist': 'test',
+                'genre': 'Electronic',
+                'thumbnail': r're:https?://.*\.jpg',
+                'view_count': int,
+                'like_count': int,
+                'repost_count': int,
+            }
+        },
+        {
+            # Regular track
+            'url': 'https://audius.co/voltra/radar-103692',
+            'md5': '491898a0a8de39f20c5d6a8a80ab5132',
+            'info_dict': {
+                'id': 'KKdy2',
+                'title': 'RADAR',
+                'ext': 'mp3',
+                'duration': 318,
+                'track': 'RADAR',
+                'artist': 'voltra',
+                'genre': 'Trance',
+                'thumbnail': r're:https?://.*\.jpg',
+                'view_count': int,
+                'like_count': int,
+                'repost_count': int,
+            }
+        },
+    ]
+
+    _ARTWORK_MAP = {
+        "150x150": 150,
+        "480x480": 480,
+        "1000x1000": 1000
+    }
+
+    def _real_extract(self, url):
+        mobj = re.match(self._VALID_URL, url)
+        uploader, title, track_id = mobj.groups()
+        if track_id is None:
+            url = self._prepare_url(url, title)
+            track_data = self._resolve_url(url, title)
+        else:  # API link
+            track_data = self._api_request('/tracks/%s' % track_id, track_id)
+
+        if not isinstance(track_data, dict):
+            raise ExtractorError('Unexpected API response')
+
+        track_id = track_data.get('id')
+        if track_id is None:
+            raise ExtractorError('Unable to get ID of the track')
+
+        artworks_data = track_data.get('artwork')
+        thumbnails = []
+        if isinstance(artworks_data, dict):
+            for quality_key, thumbnail_url in artworks_data.items():
+                thumbnail = {
+                    "url": thumbnail_url
+                }
+                quality_code = self._ARTWORK_MAP.get(quality_key)
+                if quality_code is not None:
+                    thumbnail['preference'] = quality_code
+                thumbnails.append(thumbnail)
+
+        return {
+            'id': track_id,
+            'title': track_data.get('title', title),
+            'url': '%s/v1/tracks/%s/stream' % (self._API_BASE, track_id),
+            'ext': 'mp3',
+            'description': track_data.get('description'),
+            'duration': track_data.get('duration'),
+            'track': track_data.get('title'),
+            'artist': try_get(track_data, lambda x: x['user']['name'], compat_str),
+            'genre': track_data.get('genre'),
+            'thumbnails': thumbnails,
+            'view_count': track_data.get('play_count'),
+            'like_count': track_data.get('favorite_count'),
+            'repost_count': track_data.get('repost_count'),
+        }
+
+
+class AudiusPlaylistIE(AudiusBaseIE):
+    _VALID_URL = r'https?://(?:www\.)?audius\.co/(?P<uploader>[\w\d-]+)/(?:album|playlist)/(?P<title>\S+)'
+    IE_NAME = 'audius:playlist'
+    _TEST = {
+        'url': 'https://audius.co/test_acc/playlist/test-playlist-22910',
+        'info_dict': {
+            'id': 'DNvjN',
+            'title': 'test playlist',
+            'description': 'Test description\n\nlol',
+        },
+        'playlist_count': 175,
+    }
+
+    def _build_playlist(self, tracks):
+        entries = []
+        for track in tracks:
+            if not isinstance(track, dict):
+                raise ExtractorError('Unexpected API response')
+            track_id = str_or_none(track.get('id'))
+            if not track_id:
+                raise ExtractorError('Unable to get track ID from playlist')
+            entries.append(self.url_result(
+                '%s%s/tracks/%s' % (self._API_BASE, self._API_V, track_id),
+                ie=AudiusIE.ie_key(), video_id=track_id))
+        return entries
+
+    def _real_extract(self, url):
+        self._select_api_base()
+        mobj = re.match(self._VALID_URL, url)
+        uploader, title = mobj.groups()
+        url = self._prepare_url(url, title)
+        playlist_response = self._resolve_url(url, title)
+
+        if not isinstance(playlist_response, list) or len(playlist_response) != 1:
+            raise ExtractorError('Unexpected API response')
+
+        playlist_data = playlist_response[0]
+        if not isinstance(playlist_data, dict):
+            raise ExtractorError('Unexpected API response')
+
+        playlist_id = playlist_data.get('id')
+        if playlist_id is None:
+            raise ExtractorError('Unable to get playlist ID')
+
+        playlist_tracks = self._api_request(
+            '/playlists/%s/tracks' % playlist_id,
+            title, note='Downloading playlist tracks metadata',
+            errnote='Unable to download playlist tracks metadata')
+        if not isinstance(playlist_tracks, list):
+            raise ExtractorError('Unexpected API response')
+
+        entries = self._build_playlist(playlist_tracks)
+        return self.playlist_result(entries, playlist_id,
+                                    playlist_data.get('playlist_name', title),
+                                    playlist_data.get('description'))
--- a/youtube_dlc/extractor/bilibili.py
+++ b/youtube_dlc/extractor/bilibili.py
@@ -2,9 +2,10 @@
 from __future__ import unicode_literals

 import hashlib
+import json
 import re

-from .common import InfoExtractor
+from .common import InfoExtractor, SearchInfoExtractor
 from ..compat import (
    compat_parse_qs,
    compat_urlparse,
@@ -32,13 +33,14 @@ class BiliBiliIE(InfoExtractor):
                            (?:
                                video/[aA][vV]|
                                anime/(?P<anime_id>\d+)/play\#
-                            )(?P<id_bv>\d+)|
-                            video/[bB][vV](?P<id>[^/?#&]+)
+                            )(?P<id>\d+)|
+                            video/[bB][vV](?P<id_bv>[^/?#&]+)
                        )
+                        (?:/?\?p=(?P<page>\d+))?
                    '''

    _TESTS = [{
-        'url': 'http://www.bilibili.tv/video/av1074402/',
+        'url': 'http://www.bilibili.com/video/av1074402/',
        'md5': '5f7d29e1a2872f3df0cf76b1f87d3788',
        'info_dict': {
            'id': '1074402',
@@ -56,6 +58,10 @@ class BiliBiliIE(InfoExtractor):
        # Tested in BiliBiliBangumiIE
        'url': 'http://bangumi.bilibili.com/anime/1869/play#40062',
        'only_matching': True,
+    }, {
+        # bilibili.tv
+        'url': 'http://www.bilibili.tv/video/av1074402/',
+        'only_matching': True,
    }, {
        'url': 'http://bangumi.bilibili.com/anime/5802/play#100643',
        'md5': '3f721ad1e75030cc06faf73587cfec57',
@@ -124,12 +130,20 @@ class BiliBiliIE(InfoExtractor):
        url, smuggled_data = unsmuggle_url(url, {})

        mobj = re.match(self._VALID_URL, url)
-        video_id = mobj.group('id') or mobj.group('id_bv')
+        video_id = mobj.group('id_bv') or mobj.group('id')
+
+        av_id, bv_id = self._get_video_id_set(video_id, mobj.group('id_bv') is not None)
+        video_id = av_id
+
        anime_id = mobj.group('anime_id')
+        page_id = mobj.group('page')
        webpage = self._download_webpage(url, video_id)

        if 'anime/' not in url:
            cid = self._search_regex(
+                r'\bcid(?:["\']:|=)(\d+),["\']page(?:["\']:|=)' + str(page_id), webpage, 'cid',
+                default=None
+            ) or self._search_regex(
                r'\bcid(?:["\']:|=)(\d+)', webpage, 'cid',
                default=None
            ) or compat_parse_qs(self._search_regex(
@@ -207,9 +221,9 @@ class BiliBiliIE(InfoExtractor):
            break

        title = self._html_search_regex(
-            ('<h1[^>]+\btitle=(["\'])(?P<title>(?:(?!\1).)+)\1',
-             '(?s)<h1[^>]*>(?P<title>.+?)</h1>'), webpage, 'title',
-            group='title')
+            (r'<h1[^>]+\btitle=(["\'])(?P<title>(?:(?!\1).)+)\1',
+             r'(?s)<h1[^>]*>(?P<title>.+?)</h1>'), webpage, 'title',
+            group='title') + ('_p' + str(page_id) if page_id is not None else '')
        description = self._html_search_meta('description', webpage)
        timestamp = unified_timestamp(self._html_search_regex(
            r'<time[^>]+datetime="([^"]+)"', webpage, 'upload time',
@@ -219,7 +233,8 @@ class BiliBiliIE(InfoExtractor):

        # TODO 'view_count' requires deobfuscating Javascript
        info = {
-            'id': video_id,
+            'id': str(video_id) if page_id is None else '%s_p%s' % (video_id, page_id),
+            'cid': cid,
            'title': title,
            'description': description,
            'timestamp': timestamp,
@@ -235,27 +250,134 @@ class BiliBiliIE(InfoExtractor):
                'uploader': uploader_mobj.group('name'),
                'uploader_id': uploader_mobj.group('id'),
            })
+
        if not info.get('uploader'):
            info['uploader'] = self._html_search_meta(
                'author', webpage, 'uploader', default=None)

+        comments = None
+        if self._downloader.params.get('getcomments', False):
+            comments = self._get_all_comment_pages(video_id)
+
+        raw_danmaku = self._get_raw_danmaku(video_id, cid)
+
+        raw_tags = self._get_tags(video_id)
+        tags = list(map(lambda x: x['tag_name'], raw_tags))
+
+        top_level_info = {
+            'raw_danmaku': raw_danmaku,
+            'comments': comments,
+            'comment_count': len(comments) if comments is not None else None,
+            'tags': tags,
+            'raw_tags': raw_tags,
+        }
+
+        '''
+        # Requires https://github.com/m13253/danmaku2ass which is licenced under GPL3
+        # See https://github.com/animelover1984/youtube-dl
+        danmaku = NiconicoIE.CreateDanmaku(raw_danmaku, commentType='Bilibili', x=1024, y=576)
+        entries[0]['subtitles'] = {
+            'danmaku': [{
+                'ext': 'ass',
+                'data': danmaku
+            }]
+        }
+        '''
+
        for entry in entries:
            entry.update(info)

        if len(entries) == 1:
+            entries[0].update(top_level_info)
            return entries[0]
        else:
            for idx, entry in enumerate(entries):
                entry['id'] = '%s_part%d' % (video_id, (idx + 1))

-            return {
+            global_info = {
                '_type': 'multi_video',
                'id': video_id,
+                'bv_id': bv_id,
                'title': title,
                'description': description,
                'entries': entries,
            }

+            global_info.update(info)
+            global_info.update(top_level_info)
+
+            return global_info
+
+    def _get_video_id_set(self, id, is_bv):
+        query = {'bvid': id} if is_bv else {'aid': id}
+        response = self._download_json(
+            "http://api.bilibili.cn/x/web-interface/view",
+            id, query=query,
+            note='Grabbing original ID via API')
+
+        if response['code'] == -400:
+            raise ExtractorError('Video ID does not exist', expected=True, video_id=id)
+        elif response['code'] != 0:
+            raise ExtractorError('Unknown error occurred during API check (code %s)' % response['code'], expected=True, video_id=id)
+        return (response['data']['aid'], response['data']['bvid'])
+
+    # recursive solution to getting every page of comments for the video
+    # we can stop when we reach a page without any comments
+    def _get_all_comment_pages(self, video_id, commentPageNumber=0):
+        comment_url = "https://api.bilibili.com/x/v2/reply?jsonp=jsonp&pn=%s&type=1&oid=%s&sort=2&_=1567227301685" % (commentPageNumber, video_id)
+        json_str = self._download_webpage(
+            comment_url, video_id,
+            note='Extracting comments from page %s' % (commentPageNumber))
+        replies = json.loads(json_str)['data']['replies']
+        if replies is None:
+            return []
+        return self._get_all_children(replies) + self._get_all_comment_pages(video_id, commentPageNumber + 1)
+
+    # extracts all comments in the tree
+    def _get_all_children(self, replies):
+        if replies is None:
+            return []
+
+        ret = []
+        for reply in replies:
+            author = reply['member']['uname']
+            author_id = reply['member']['mid']
+            id = reply['rpid']
+            text = reply['content']['message']
+            timestamp = reply['ctime']
+            parent = reply['parent'] if reply['parent'] != 0 else 'root'
+
+            comment = {
+                "author": author,
+                "author_id": author_id,
+                "id": id,
+                "text": text,
+                "timestamp": timestamp,
+                "parent": parent,
+            }
+            ret.append(comment)
+
+            # from the JSON, the comment structure seems arbitrarily deep, but I could be wrong.
+            # Regardless, this should work.
+            ret += self._get_all_children(reply['replies'])
+
+        return ret
+
+    def _get_raw_danmaku(self, video_id, cid):
+        # This will be useful if I decide to scrape all pages instead of doing them individually
+        # cid_url = "https://www.bilibili.com/widget/getPageList?aid=%s" % (video_id)
+        # cid_str = self._download_webpage(cid_url, video_id, note=False)
+        # cid = json.loads(cid_str)[0]['cid']
+
+        danmaku_url = "https://comment.bilibili.com/%s.xml" % (cid)
+        danmaku = self._download_webpage(danmaku_url, video_id, note='Downloading danmaku comments')
+        return danmaku
+
+    def _get_tags(self, video_id):
+        tags_url = "https://api.bilibili.com/x/tag/archive/tags?aid=%s" % (video_id)
+        tags_json = self._download_json(tags_url, video_id, note='Downloading tags')
+        return tags_json['data']
+

 class BiliBiliBangumiIE(InfoExtractor):
    _VALID_URL = r'https?://bangumi\.bilibili\.com/anime/(?P<id>\d+)'
@@ -324,6 +446,73 @@ class BiliBiliBangumiIE(InfoExtractor):
            season_info.get('bangumi_title'), season_info.get('evaluate'))


+class BilibiliChannelIE(InfoExtractor):
+    _VALID_URL = r'https?://space.bilibili\.com/(?P<id>\d+)'
+    # May need to add support for pagination? Need to find a user with many video uploads to test
+    _API_URL = "https://api.bilibili.com/x/space/arc/search?mid=%s&pn=1&ps=25&jsonp=jsonp"
+    _TEST = {}  # TODO: Add tests
+
+    def _real_extract(self, url):
+        list_id = self._match_id(url)
+        json_str = self._download_webpage(self._API_URL % list_id, "None")
+
+        json_parsed = json.loads(json_str)
+        entries = [{
+            '_type': 'url',
+            'ie_key': BiliBiliIE.ie_key(),
+            'url': ('https://www.bilibili.com/video/%s' %
+                    entry['bvid']),
+            'id': entry['bvid'],
+        } for entry in json_parsed['data']['list']['vlist']]
+
+        return {
+            '_type': 'playlist',
+            'id': list_id,
+            'entries': entries
+        }
+
+
+class BiliBiliSearchIE(SearchInfoExtractor):
+    IE_DESC = 'Bilibili video search, "bilisearch" keyword'
+    _MAX_RESULTS = 100000
+    _SEARCH_KEY = 'bilisearch'
+    MAX_NUMBER_OF_RESULTS = 1000
+
+    def _get_n_results(self, query, n):
+        """Get a specified number of results for a query"""
+
+        entries = []
+        pageNumber = 0
+        while True:
+            pageNumber += 1
+            # FIXME
+            api_url = "https://api.bilibili.com/x/web-interface/search/type?context=&page=%s&order=pubdate&keyword=%s&duration=0&tids_2=&__refresh__=true&search_type=video&tids=0&highlight=1" % (pageNumber, query)
+            json_str = self._download_webpage(
+                api_url, "None", query={"Search_key": query},
+                note='Extracting results from page %s' % pageNumber)
+            data = json.loads(json_str)['data']
+
+            # FIXME: this is hideous
+            if "result" not in data:
+                return {
+                    '_type': 'playlist',
+                    'id': query,
+                    'entries': entries[:n]
+                }
+
+            videos = data['result']
+            for video in videos:
+                e = self.url_result(video['arcurl'], 'BiliBili', str(video['aid']))
+                entries.append(e)
+
+            if(len(entries) >= n or len(videos) >= BiliBiliSearchIE.MAX_NUMBER_OF_RESULTS):
+                return {
+                    '_type': 'playlist',
+                    'id': query,
+                    'entries': entries[:n]
+                }
+
+
 class BilibiliAudioBaseIE(InfoExtractor):
    def _call_api(self, path, sid, query=None):
        if not query:
--- a/youtube_dlc/extractor/common.py
+++ b/youtube_dlc/extractor/common.py
@@ -1375,7 +1375,7 @@ class InfoExtractor(object):
                       'order': ['vp9', '(h265|he?vc?)', '(h264|avc)', 'vp8', '(mp4v|h263)', 'theora', '', None, 'none']},
            'acodec': {'type': 'ordered', 'regex': True,
                       'order': ['opus', 'vorbis', 'aac', 'mp?4a?', 'mp3', 'e?a?c-?3', 'dts', '', None, 'none']},
-            'proto': {'type': 'ordered', 'regex': True,
+            'proto': {'type': 'ordered', 'regex': True, 'field': 'protocol',
                      'order': ['(ht|f)tps', '(ht|f)tp$', 'm3u8.+', 'm3u8', '.*dash', '', 'mms|rtsp', 'none', 'f4']},
            'vext': {'type': 'ordered', 'field': 'video_ext',
                     'order': ('mp4', 'webm', 'flv', '', 'none'),
@@ -1384,14 +1384,14 @@ class InfoExtractor(object):
                     'order': ('m4a', 'aac', 'mp3', 'ogg', 'opus', 'webm', '', 'none'),
                     'order_free': ('opus', 'ogg', 'webm', 'm4a', 'mp3', 'aac', '', 'none')},
            'hidden': {'visible': False, 'forced': True, 'type': 'extractor', 'max': -1000},
-            'ie_pref': {'priority': True, 'type': 'extractor'},
+            'ie_pref': {'priority': True, 'type': 'extractor', 'field': 'extractor_preference'},
            'hasvid': {'priority': True, 'field': 'vcodec', 'type': 'boolean', 'not_in_list': ('none',)},
            'hasaud': {'field': 'acodec', 'type': 'boolean', 'not_in_list': ('none',)},
-            'lang': {'priority': True, 'convert': 'ignore'},
+            'lang': {'priority': True, 'convert': 'ignore', 'field': 'language_preference'},
            'quality': {'priority': True, 'convert': 'float_none'},
            'filesize': {'convert': 'bytes'},
-            'fs_approx': {'convert': 'bytes'},
-            'id': {'convert': 'string'},
+            'fs_approx': {'convert': 'bytes', 'field': 'filesize_approx'},
+            'id': {'convert': 'string', 'field': 'format_id'},
            'height': {'convert': 'float_none'},
            'width': {'convert': 'float_none'},
            'fps': {'convert': 'float_none'},
@@ -1399,7 +1399,7 @@ class InfoExtractor(object):
            'vbr': {'convert': 'float_none'},
            'abr': {'convert': 'float_none'},
            'asr': {'convert': 'float_none'},
-            'source': {'convert': 'ignore'},
+            'source': {'convert': 'ignore', 'field': 'source_preference'},

            'codec': {'type': 'combined', 'field': ('vcodec', 'acodec')},
            'br': {'type': 'combined', 'field': ('tbr', 'vbr', 'abr'), 'same_limit': True},
--- a/youtube_dlc/extractor/extractors.py
+++ b/youtube_dlc/extractor/extractors.py
@@ -90,6 +90,7 @@ from .atvat import ATVAtIE
 from .audimedia import AudiMediaIE
 from .audioboom import AudioBoomIE
 from .audiomack import AudiomackIE, AudiomackAlbumIE
+from .audius import AudiusIE, AudiusPlaylistIE
 from .awaan import (
    AWAANIE,
    AWAANVideoIE,
@@ -122,10 +123,12 @@ from .bigflix import BigflixIE
 from .bild import BildIE
 from .bilibili import (
    BiliBiliIE,
+    BiliBiliSearchIE,
    BiliBiliBangumiIE,
    BilibiliAudioIE,
    BilibiliAudioAlbumIE,
    BiliBiliPlayerIE,
+    BilibiliChannelIE,
 )
 from .biobiochiletv import BioBioChileTVIE
 from .bitchute import (
--- a/youtube_dlc/extractor/youtube.py
+++ b/youtube_dlc/extractor/youtube.py
@@ -2424,9 +2424,10 @@ class YoutubeIE(YoutubeBaseInfoExtractor):
            default=None
        ))

-        # annotations
-        video_annotations = None
-        if self._downloader.params.get('writeannotations', False):
+        # get xsrf for annotations or comments
+        get_annotations = self._downloader.params.get('writeannotations', False)
+        get_comments = self._downloader.params.get('getcomments', False)
+        if get_annotations or get_comments:
            xsrf_token = None
            ytcfg = self._extract_ytcfg(video_id, video_webpage)
            if ytcfg:
@@ -2435,6 +2436,10 @@ class YoutubeIE(YoutubeBaseInfoExtractor):
                xsrf_token = self._search_regex(
                    r'([\'"])XSRF_TOKEN\1\s*:\s*([\'"])(?P<xsrf_token>(?:(?!\2).)+)\2',
                    video_webpage, 'xsrf token', group='xsrf_token', fatal=False)
+
+        # annotations
+        video_annotations = None
+        if get_annotations:
            invideo_url = try_get(
                player_response, lambda x: x['annotations'][0]['playerAnnotationsUrlsRenderer']['invideoUrl'], compat_str)
            if xsrf_token and invideo_url:
@@ -2454,6 +2459,149 @@ class YoutubeIE(YoutubeBaseInfoExtractor):

        chapters = self._extract_chapters(video_webpage, description_original, video_id, video_duration)

+        # Get comments
+        # TODO: Refactor and move to seperate function
+        if get_comments:
+            expected_video_comment_count = 0
+            video_comments = []
+
+            def find_value(html, key, num_chars=2, separator='"'):
+                pos_begin = html.find(key) + len(key) + num_chars
+                pos_end = html.find(separator, pos_begin)
+                return html[pos_begin: pos_end]
+
+            def search_dict(partial, key):
+                if isinstance(partial, dict):
+                    for k, v in partial.items():
+                        if k == key:
+                            yield v
+                        else:
+                            for o in search_dict(v, key):
+                                yield o
+                elif isinstance(partial, list):
+                    for i in partial:
+                        for o in search_dict(i, key):
+                            yield o
+
+            try:
+                ncd = next(search_dict(yt_initial_data, 'nextContinuationData'))
+                continuations = [ncd['continuation']]
+            # Handle videos where comments have been disabled entirely
+            except StopIteration:
+                continuations = []
+
+            def get_continuation(continuation, session_token, replies=False):
+                query = {
+                    'pbj': 1,
+                    'ctoken': continuation,
+                }
+                if replies:
+                    query['action_get_comment_replies'] = 1
+                else:
+                    query['action_get_comments'] = 1
+
+                while True:
+                    content, handle = self._download_webpage_handle(
+                        'https://www.youtube.com/comment_service_ajax',
+                        video_id,
+                        note=False,
+                        expected_status=[413],
+                        data=urlencode_postdata({
+                            'session_token': session_token
+                        }),
+                        query=query,
+                        headers={
+                            'Accept': '*/*',
+                            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:76.0) Gecko/20100101 Firefox/76.0',
+                            'X-YouTube-Client-Name': '1',
+                            'X-YouTube-Client-Version': '2.20201202.06.01'
+                        }
+                    )
+
+                    response_code = handle.getcode()
+                    if (response_code == 200):
+                        return self._parse_json(content, video_id)
+                    if (response_code == 413):
+                        return None
+                    raise ExtractorError('Unexpected HTTP error code: %s' % response_code)
+
+            first_continuation = True
+            while continuations:
+                continuation, itct = continuations.pop()
+                comment_response = get_continuation(continuation, xsrf_token)
+                if not comment_response:
+                    continue
+                if list(search_dict(comment_response, 'externalErrorMessage')):
+                    raise ExtractorError('Error returned from server: ' + next(search_dict(comment_response, 'externalErrorMessage')))
+
+                if 'continuationContents' not in comment_response['response']:
+                    # Something is wrong here. Youtube won't accept this continuation token for some reason and responds with a user satisfaction dialog (error?)
+                    continue
+                # not sure if this actually helps
+                if 'xsrf_token' in comment_response:
+                    xsrf_token = comment_response['xsrf_token']
+
+                item_section = comment_response['response']['continuationContents']['itemSectionContinuation']
+                if first_continuation:
+                    expected_video_comment_count = int(item_section['header']['commentsHeaderRenderer']['countText']['runs'][0]['text'].replace(' Comments', '').replace('1 Comment', '1').replace(',', ''))
+                    first_continuation = False
+                if 'contents' not in item_section:
+                    # continuation returned no comments?
+                    # set an empty array as to not break the for loop
+                    item_section['contents'] = []
+
+                for meta_comment in item_section['contents']:
+                    comment = meta_comment['commentThreadRenderer']['comment']['commentRenderer']
+                    video_comments.append({
+                        'id': comment['commentId'],
+                        'text': ''.join([c['text'] for c in comment['contentText']['runs']]),
+                        'time_text': ''.join([c['text'] for c in comment['publishedTimeText']['runs']]),
+                        'author': comment.get('authorText', {}).get('simpleText', ''),
+                        'votes': comment.get('voteCount', {}).get('simpleText', '0'),
+                        'author_thumbnail': comment['authorThumbnail']['thumbnails'][-1]['url'],
+                        'parent': 'root'
+                    })
+                    if 'replies' not in meta_comment['commentThreadRenderer']:
+                        continue
+
+                    reply_continuations = [rcn['nextContinuationData']['continuation'] for rcn in meta_comment['commentThreadRenderer']['replies']['commentRepliesRenderer']['continuations']]
+                    while reply_continuations:
+                        time.sleep(1)
+                        continuation = reply_continuations.pop()
+                        replies_data = get_continuation(continuation, xsrf_token, True)
+                        if not replies_data or 'continuationContents' not in replies_data[1]['response']:
+                            continue
+
+                        if self._downloader.params.get('verbose', False):
+                            self.to_screen('[debug] Comments downloaded (chain %s) %s of ~%s' % (comment['commentId'], len(video_comments), expected_video_comment_count))
+                        reply_comment_meta = replies_data[1]['response']['continuationContents']['commentRepliesContinuation']
+                        for reply_meta in replies_data[1]['response']['continuationContents']['commentRepliesContinuation']['contents']:
+                            reply_comment = reply_meta['commentRenderer']
+                            video_comments.append({
+                                'id': reply_comment['commentId'],
+                                'text': ''.join([c['text'] for c in reply_comment['contentText']['runs']]),
+                                'time_text': ''.join([c['text'] for c in reply_comment['publishedTimeText']['runs']]),
+                                'author': reply_comment.get('authorText', {}).get('simpleText', ''),
+                                'votes': reply_comment.get('voteCount', {}).get('simpleText', '0'),
+                                'author_thumbnail': reply_comment['authorThumbnail']['thumbnails'][-1]['url'],
+                                'parent': comment['commentId']
+                            })
+                        if 'continuations' not in reply_comment_meta or len(reply_comment_meta['continuations']) == 0:
+                            continue
+
+                        reply_continuations += [rcn['nextContinuationData']['continuation'] for rcn in reply_comment_meta['continuations']]
+
+                self.to_screen('Comments downloaded %s of ~%s' % (len(video_comments), expected_video_comment_count))
+
+                if 'continuations' in item_section:
+                    continuations += [ncd['nextContinuationData']['continuation'] for ncd in item_section['continuations']]
+                time.sleep(1)
+
+            self.to_screen('Total comments downloaded %s of ~%s' % (len(video_comments), expected_video_comment_count))
+        else:
+            expected_video_comment_count = None
+            video_comments = None
+
        # Look for the DASH manifest
        if self._downloader.params.get('youtube_include_dash_manifest', True):
            dash_mpd_fatal = True
@@ -2572,6 +2720,8 @@ class YoutubeIE(YoutubeBaseInfoExtractor):
            'release_year': release_year,
            'subscriber_count': subscriber_count,
            'playable_in_embed': playable_in_embed,
+            'comments': video_comments,
+            'comment_count': expected_video_comment_count,
        }


@@ -3276,12 +3426,19 @@ class YoutubeTabIE(YoutubeBaseInfoExtractor):
                title += ' - %s' % tab_title
            description = renderer.get('description')
            playlist_id = renderer.get('externalId')
+
+        # this has thumbnails, but there is currently no thumbnail field for playlists
+        # sidebar.playlistSidebarRenderer has even more data, but its stucture is more complec
        renderer = try_get(
-            data, lambda x: x['metadata']['playlistMetadataRenderer'], dict)
+            data, lambda x: x['microformat']['microformatDataRenderer'], dict)
+        if not renderer:
+            renderer = try_get(
+                data, lambda x: x['metadata']['playlistMetadataRenderer'], dict)
        if renderer:
            title = renderer.get('title')
-            description = None
+            description = renderer.get('description')
            playlist_id = item_id
+
        if playlist_id is None:
            playlist_id = item_id
        if title is None:
@@ -3371,8 +3528,16 @@ class YoutubeTabIE(YoutubeBaseInfoExtractor):
        webpage = self._download_webpage(url, item_id)
        identity_token = self._extract_identity_token(webpage, item_id)
        data = self._extract_yt_initial_data(item_id, webpage)
+        err_msg = None
        for alert_type, alert_message in self._extract_alerts(data):
-            self._downloader.report_warning('YouTube said: %s - %s' % (alert_type, alert_message))
+            if alert_type.lower() == 'error':
+                if err_msg:
+                    self._downloader.report_warning('YouTube said: %s - %s' % ('ERROR', err_msg))
+                err_msg = alert_message
+            else:
+                self._downloader.report_warning('YouTube said: %s - %s' % (alert_type, alert_message))
+        if err_msg:
+            raise ExtractorError('YouTube said: %s' % err_msg, expected=True)
        tabs = try_get(
            data, lambda x: x['contents']['twoColumnBrowseResultsRenderer']['tabs'], list)
        if tabs:
--- a/youtube_dlc/options.py
+++ b/youtube_dlc/options.py
@@ -22,6 +22,9 @@ from .utils import (
 from .version import __version__


+_remux_formats = ('mp4', 'mkv', 'flv', 'webm', 'mov', 'avi', 'mp3', 'mka', 'm4a', 'ogg', 'opus')
+
+
 def _hide_login_info(opts):
    PRIVATE_OPTS = set(['-p', '--password', '-u', '--username', '--video-password', '--ap-password', '--ap-username'])
    eqre = re.compile('^(?P<key>' + ('|'.join(re.escape(po) for po in PRIVATE_OPTS)) + ')=.+$')
@@ -934,6 +937,10 @@ def parseOpts(overrideArguments=None):
        '--no-write-annotations',
        action='store_false', dest='writeannotations',
        help='Do not write video annotations (default)')
+    filesystem.add_option(
+        '--get-comments',
+        action='store_true', dest='getcomments', default=False,
+        help='Retrieve video comments to be placed in the .info.json file')
    filesystem.add_option(
        '--load-info-json', '--load-info',
        dest='load_info_filename', metavar='FILE',
@@ -1001,24 +1008,28 @@ def parseOpts(overrideArguments=None):
    postproc.add_option(
        '-x', '--extract-audio',
        action='store_true', dest='extractaudio', default=False,
-        help='Convert video files to audio-only files (requires ffmpeg/avconv and ffprobe/avprobe)')
+        help='Convert video files to audio-only files (requires ffmpeg and ffprobe)')
    postproc.add_option(
        '--audio-format', metavar='FORMAT', dest='audioformat', default='best',
        help='Specify audio format: "best", "aac", "flac", "mp3", "m4a", "opus", "vorbis", or "wav"; "%default" by default; No effect without -x')
    postproc.add_option(
        '--audio-quality', metavar='QUALITY',
        dest='audioquality', default='5',
-        help='Specify ffmpeg/avconv audio quality, insert a value between 0 (better) and 9 (worse) for VBR or a specific bitrate like 128K (default %default)')
+        help='Specify ffmpeg audio quality, insert a value between 0 (better) and 9 (worse) for VBR or a specific bitrate like 128K (default %default)')
    postproc.add_option(
        '--remux-video',
        metavar='FORMAT', dest='remuxvideo', default=None,
        help=(
-            'Remux the video into another container if necessary (currently supported: mp4|mkv). '
-            'If target container does not support the video/audio codec, remuxing will fail'))
+            'Remux the video into another container if necessary (currently supported: %s). '
+            'If target container does not support the video/audio codec, remuxing will fail. '
+            'You can specify multiple rules; eg. "aac>m4a/mov>mp4/mkv" will remux aac to m4a, mov to mp4 '
+            'and anything else to mkv.' % '|'.join(_remux_formats)))
    postproc.add_option(
        '--recode-video',
        metavar='FORMAT', dest='recodevideo', default=None,
-        help='Re-encode the video into another format if re-encoding is necessary (currently supported: mp4|flv|ogg|webm|mkv|avi)')
+        help=(
+            'Re-encode the video into another format if re-encoding is necessary. '
+            'The supported formats are the same as --remux-video'))
    postproc.add_option(
        '--postprocessor-args', '--ppa',
        metavar='NAME:ARGS', dest='postprocessor_args', default={}, type='str',
@@ -1030,7 +1041,7 @@ def parseOpts(overrideArguments=None):
            'to give the argument to the specified postprocessor/executable. Supported postprocessors are: '
            'SponSkrub, ExtractAudio, VideoRemuxer, VideoConvertor, EmbedSubtitle, Metadata, Merger, '
            'FixupStretched, FixupM4a, FixupM3u8, SubtitlesConvertor and EmbedThumbnail. '
-            'The supported executables are: SponSkrub, FFmpeg, FFprobe, avconf, avprobe and AtomicParsley. '
+            'The supported executables are: SponSkrub, FFmpeg, FFprobe, and AtomicParsley. '
            'You can use this option multiple times to give different arguments to different postprocessors. '
            'You can also specify "PP+EXE:ARGS" to give the arguments to the specified executable '
            'only when being used by the specified postprocessor. '
@@ -1078,14 +1089,20 @@ def parseOpts(overrideArguments=None):
    postproc.add_option(
        '--metadata-from-title',
        metavar='FORMAT', dest='metafromtitle',
+        help=optparse.SUPPRESS_HELP)
+    postproc.add_option(
+        '--parse-metadata',
+        metavar='FIELD:FORMAT', dest='metafromfield', action='append',
        help=(
-            'Parse additional metadata like song title / artist from the video title. '
-            'The format syntax is the same as --output. Regular expression with '
-            'named capture groups may also be used. '
-            'The parsed parameters replace existing values. '
-            'Example: --metadata-from-title "%(artist)s - %(title)s" matches a title like '
+            'Parse additional metadata like title/artist from other fields. '
+            'Give field name to extract data from, and format of the field seperated by a ":". '
+            'Either regular expression with named capture groups or a '
+            'similar syntax to the output template can also be used. '
+            'The parsed parameters replace any existing values and can be use in output template'
+            'This option can be used multiple times. '
+            'Example: --parse-metadata "title:%(artist)s - %(title)s" matches a title like '
            '"Coldplay - Paradise". '
-            'Example (regex): --metadata-from-title "(?P<artist>.+?) - (?P<title>.+)"'))
+            'Example (regex): --parse-metadata "description:Artist - (?P<artist>.+?)"'))
    postproc.add_option(
        '--xattrs',
        action='store_true', dest='xattrs', default=False,
@@ -1100,15 +1117,15 @@ def parseOpts(overrideArguments=None):
    postproc.add_option(
        '--prefer-avconv', '--no-prefer-ffmpeg',
        action='store_false', dest='prefer_ffmpeg',
-        help='Prefer avconv over ffmpeg for running the postprocessors (Alias: --no-prefer-ffmpeg)')
+        help=optparse.SUPPRESS_HELP)
    postproc.add_option(
        '--prefer-ffmpeg', '--no-prefer-avconv',
-        action='store_true', dest='prefer_ffmpeg',
-        help='Prefer ffmpeg over avconv for running the postprocessors (default) (Alias: --no-prefer-avconv)')
+        action='store_true', dest='prefer_ffmpeg', default=True,
+        help=optparse.SUPPRESS_HELP)
    postproc.add_option(
        '--ffmpeg-location', '--avconv-location', metavar='PATH',
        dest='ffmpeg_location',
-        help='Location of the ffmpeg/avconv binary; either the path to the binary or its containing directory (Alias: --avconv-location)')
+        help='Location of the ffmpeg binary; either the path to the binary or its containing directory')
    postproc.add_option(
        '--exec',
        metavar='CMD', dest='exec_cmd',
@@ -1217,19 +1234,15 @@ def parseOpts(overrideArguments=None):
                return

            def read_options(path, user=False):
-                func = _readUserConf if user else _readOptions
-                current_path = os.path.join(path, 'yt-dlp.conf')
-                config = func(current_path, default=None)
-                if user:
-                    config, current_path = config
-                if config is None:
-                    current_path = os.path.join(path, 'youtube-dlc.conf')
-                    config = func(current_path, default=None)
+                for package in ('yt-dlp', 'youtube-dlc'):
                    if user:
-                        config, current_path = config
-                if config is None:
-                    return [], None
-                return config, current_path
+                        config, current_path = _readUserConf(package, default=None)
+                    else:
+                        current_path = os.path.join(path, '%s.conf' % package)
+                        config = _readOptions(current_path, default=None)
+                    if config is not None:
+                        return config, current_path
+                return [], None

            configs['portable'], paths['portable'] = read_options(get_executable_path())
            if '--ignore-config' in configs['portable']:
--- a/youtube_dlc/postprocessor/init.py
+++ b/youtube_dlc/postprocessor/init.py
@@ -16,7 +16,8 @@ from .ffmpeg import (
 )
 from .xattrpp import XAttrMetadataPP
 from .execafterdownload import ExecAfterDownloadPP
-from .metadatafromtitle import MetadataFromTitlePP
+from .metadatafromfield import MetadataFromFieldPP
+from .metadatafromfield import MetadataFromTitlePP
 from .movefilesafterdownload import MoveFilesAfterDownloadPP
 from .sponskrub import SponSkrubPP

@@ -39,6 +40,7 @@ __all__ = [
    'FFmpegSubtitlesConvertorPP',
    'FFmpegVideoConvertorPP',
    'FFmpegVideoRemuxerPP',
+    'MetadataFromFieldPP',
    'MetadataFromTitlePP',
    'MoveFilesAfterDownloadPP',
    'SponSkrubPP',
--- a/youtube_dlc/postprocessor/common.py
+++ b/youtube_dlc/postprocessor/common.py
@@ -56,7 +56,7 @@ class PostProcessor(object):

    def write_debug(self, text, prefix=True, *args, **kwargs):
        tag = '[debug] ' if prefix else ''
-        if self.get_param('verbose', False):
+        if self.get_param('verbose', False) and self._downloader:
            return self._downloader.to_screen('%s%s' % (tag, text), *args, **kwargs)

    def get_param(self, name, default=None, *args, **kwargs):
--- a/youtube_dlc/postprocessor/embedthumbnail.py
+++ b/youtube_dlc/postprocessor/embedthumbnail.py
@@ -4,6 +4,15 @@ from __future__ import unicode_literals

 import os
 import subprocess
+import struct
+import re
+import base64
+
+try:
+    import mutagen
+    _has_mutagen = True
+except ImportError:
+    _has_mutagen = False

 from .ffmpeg import FFmpegPostProcessor

@@ -11,11 +20,12 @@ from ..utils import (
    check_executable,
    encodeArgument,
    encodeFilename,
+    error_to_compat_str,
    PostProcessingError,
    prepend_extension,
+    process_communicate_or_kill,
    replace_extension,
    shell_quote,
-    process_communicate_or_kill,
 )


@@ -73,6 +83,7 @@ class EmbedThumbnailPP(FFmpegPostProcessor):
            # Rename back to unescaped for further processing
            os.rename(encodeFilename(escaped_thumbnail_jpg_filename), encodeFilename(thumbnail_jpg_filename))
            thumbnail_filename = thumbnail_jpg_filename
+            thumbnail_ext = 'jpg'

        success = True
        if info['ext'] == 'mp3':
@@ -83,47 +94,92 @@ class EmbedThumbnailPP(FFmpegPostProcessor):
            self.to_screen('Adding thumbnail to "%s"' % filename)
            self.run_ffmpeg_multiple_files([filename, thumbnail_filename], temp_filename, options)

-        elif info['ext'] == 'mkv':
-            options = [
-                '-c', 'copy', '-map', '0', '-dn', '-attach', thumbnail_filename,
-                '-metadata:s:t', 'mimetype=image/jpeg', '-metadata:s:t', 'filename=cover.jpg']
+        elif info['ext'] in ['mkv', 'mka']:
+            options = ['-c', 'copy', '-map', '0', '-dn']
+
+            mimetype = 'image/%s' % ('png' if thumbnail_ext == 'png' else 'jpeg')
+            old_stream, new_stream = self.get_stream_number(
+                filename, ('tags', 'mimetype'), mimetype)
+            if old_stream is not None:
+                options.extend(['-map', '-0:%d' % old_stream])
+                new_stream -= 1
+            options.extend([
+                '-attach', thumbnail_filename,
+                '-metadata:s:%d' % new_stream, 'mimetype=%s' % mimetype,
+                '-metadata:s:%d' % new_stream, 'filename=cover.%s' % thumbnail_ext])

            self.to_screen('Adding thumbnail to "%s"' % filename)
-            self.run_ffmpeg_multiple_files([filename], temp_filename, options)
+            self.run_ffmpeg(filename, temp_filename, options)

-        elif info['ext'] in ['m4a', 'mp4']:
-            if not check_executable('AtomicParsley', ['-v']):
-                raise EmbedThumbnailPPError('AtomicParsley was not found. Please install.')
+        elif info['ext'] in ['m4a', 'mp4', 'mov']:
+            try:
+                options = ['-c', 'copy', '-map', '0', '-dn', '-map', '1']

-            cmd = [encodeFilename('AtomicParsley', True),
-                   encodeFilename(filename, True),
-                   encodeArgument('--artwork'),
-                   encodeFilename(thumbnail_filename, True),
-                   encodeArgument('-o'),
-                   encodeFilename(temp_filename, True)]
-            cmd += [encodeArgument(o) for o in self._configuration_args(exe='AtomicParsley')]
+                old_stream, new_stream = self.get_stream_number(
+                    filename, ('disposition', 'attached_pic'), 1)
+                if old_stream is not None:
+                    options.extend(['-map', '-0:%d' % old_stream])
+                    new_stream -= 1
+                options.extend(['-disposition:%s' % new_stream, 'attached_pic'])

-            self.to_screen('Adding thumbnail to "%s"' % filename)
-            self.write_debug('AtomicParsley command line: %s' % shell_quote(cmd))
+                self.to_screen('Adding thumbnail to "%s"' % filename)
+                self.run_ffmpeg_multiple_files([filename, thumbnail_filename], temp_filename, options)

-            p = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
-            stdout, stderr = process_communicate_or_kill(p)
+            except PostProcessingError as err:
+                self.report_warning('unable to embed using ffprobe & ffmpeg; %s' % error_to_compat_str(err))
+                if not check_executable('AtomicParsley', ['-v']):
+                    raise EmbedThumbnailPPError('AtomicParsley was not found. Please install.')

-            if p.returncode != 0:
-                msg = stderr.decode('utf-8', 'replace').strip()
-                raise EmbedThumbnailPPError(msg)
-            # for formats that don't support thumbnails (like 3gp) AtomicParsley
-            # won't create to the temporary file
-            if b'No changes' in stdout:
-                self.report_warning('The file format doesn\'t support embedding a thumbnail')
-                success = False
+                cmd = [encodeFilename('AtomicParsley', True),
+                       encodeFilename(filename, True),
+                       encodeArgument('--artwork'),
+                       encodeFilename(thumbnail_filename, True),
+                       encodeArgument('-o'),
+                       encodeFilename(temp_filename, True)]
+                cmd += [encodeArgument(o) for o in self._configuration_args(exe='AtomicParsley')]
+
+                self.to_screen('Adding thumbnail to "%s"' % filename)
+                self.write_debug('AtomicParsley command line: %s' % shell_quote(cmd))
+                p = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+                stdout, stderr = process_communicate_or_kill(p)
+                if p.returncode != 0:
+                    msg = stderr.decode('utf-8', 'replace').strip()
+                    raise EmbedThumbnailPPError(msg)
+                # for formats that don't support thumbnails (like 3gp) AtomicParsley
+                # won't create to the temporary file
+                if b'No changes' in stdout:
+                    self.report_warning('The file format doesn\'t support embedding a thumbnail')
+                    success = False
+
+        elif info['ext'] in ['ogg', 'opus']:
+            if not _has_mutagen:
+                raise EmbedThumbnailPPError('module mutagen was not found. Please install using `python -m pip install mutagen`')
+            size_regex = r',\s*(?P<w>\d+)x(?P<h>\d+)\s*[,\[]'
+            size_result = self.run_ffmpeg(thumbnail_filename, thumbnail_filename, ['-hide_banner'])
+            mobj = re.search(size_regex, size_result)
+            width, height = int(mobj.group('w')), int(mobj.group('h'))
+            mimetype = ('image/%s' % ('png' if thumbnail_ext == 'png' else 'jpeg')).encode('ascii')
+
+            # https://xiph.org/flac/format.html#metadata_block_picture
+            data = bytearray()
+            data += struct.pack('>II', 3, len(mimetype))
+            data += mimetype
+            data += struct.pack('>IIIIII', 0, width, height, 8, 0, os.stat(thumbnail_filename).st_size)  # 32 if png else 24
+
+            fin = open(thumbnail_filename, "rb")
+            data += fin.read()
+            fin.close()
+
+            temp_filename = filename
+            f = mutagen.File(temp_filename)
+            f.tags['METADATA_BLOCK_PICTURE'] = base64.b64encode(data).decode('ascii')
+            f.save()

        else:
-            raise EmbedThumbnailPPError('Only mp3, mkv, m4a and mp4 are supported for thumbnail embedding for now.')
+            raise EmbedThumbnailPPError('Supported filetypes for thumbnail embedding are: mp3, mkv/mka, ogg/opus, m4a/mp4/mov')

-        if success:
+        if success and temp_filename != filename:
            os.remove(encodeFilename(filename))
            os.rename(encodeFilename(temp_filename), encodeFilename(filename))
-
        files_to_delete = [] if self._already_have_thumbnail else [thumbnail_filename]
        return files_to_delete, info
--- a/youtube_dlc/postprocessor/ffmpeg.py
+++ b/youtube_dlc/postprocessor/ffmpeg.py
@@ -5,6 +5,7 @@ import os
 import subprocess
 import time
 import re
+import json


 from .common import AudioConversionError, PostProcessor
@@ -20,8 +21,9 @@ from ..utils import (
    subtitles_filename,
    dfxp2srt,
    ISO639Utils,
-    replace_extension,
    process_communicate_or_kill,
+    replace_extension,
+    traverse_dict,
 )


@@ -59,7 +61,7 @@ class FFmpegPostProcessor(PostProcessor):

    def check_version(self):
        if not self.available:
-            raise FFmpegPostProcessorError('ffmpeg or avconv not found. Please install one.')
+            raise FFmpegPostProcessorError('ffmpeg not found. Please install one.')

        required_version = '10-0' if self.basename == 'avconv' else '1.0'
        if is_outdated_version(
@@ -102,7 +104,7 @@ class FFmpegPostProcessor(PostProcessor):
                if not os.path.exists(location):
                    self.report_warning(
                        'ffmpeg-location %s does not exist! '
-                        'Continuing without avconv/ffmpeg.' % (location))
+                        'Continuing without ffmpeg.' % (location))
                    self._versions = {}
                    return
                elif not os.path.isdir(location):
@@ -110,7 +112,7 @@ class FFmpegPostProcessor(PostProcessor):
                    if basename not in programs:
                        self.report_warning(
                            'Cannot identify executable %s, its basename should be one of %s. '
-                            'Continuing without avconv/ffmpeg.' %
+                            'Continuing without ffmpeg.' %
                            (location, ', '.join(programs)))
                        self._versions = {}
                        return None
@@ -163,7 +165,7 @@ class FFmpegPostProcessor(PostProcessor):

    def get_audio_codec(self, path):
        if not self.probe_available and not self.available:
-            raise PostProcessingError('ffprobe/avprobe and ffmpeg/avconv not found. Please install one.')
+            raise PostProcessingError('ffprobe and ffmpeg not found. Please install one.')
        try:
            if self.probe_available:
                cmd = [
@@ -201,6 +203,37 @@ class FFmpegPostProcessor(PostProcessor):
                return mobj.group(1)
        return None

+    def get_metadata_object(self, path, opts=[]):
+        if self.probe_basename != 'ffprobe':
+            if self.probe_available:
+                self.report_warning('Only ffprobe is supported for metadata extraction')
+            raise PostProcessingError('ffprobe not found. Please install.')
+        self.check_version()
+
+        cmd = [
+            encodeFilename(self.probe_executable, True),
+            encodeArgument('-hide_banner'),
+            encodeArgument('-show_format'),
+            encodeArgument('-show_streams'),
+            encodeArgument('-print_format'),
+            encodeArgument('json'),
+        ]
+
+        cmd += opts
+        cmd.append(encodeFilename(self._ffmpeg_filename_argument(path), True))
+        if self._downloader.params.get('verbose', False):
+            self._downloader.to_screen('[debug] ffprobe command line: %s' % shell_quote(cmd))
+        p = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, stdin=subprocess.PIPE)
+        stdout, stderr = p.communicate()
+        return json.loads(stdout.decode('utf-8', 'replace'))
+
+    def get_stream_number(self, path, keys, value):
+        streams = self.get_metadata_object(path)['streams']
+        num = next(
+            (i for i, stream in enumerate(streams) if traverse_dict(stream, keys, casesense=False) == value),
+            None)
+        return num, len(streams)
+
    def run_ffmpeg_multiple_files(self, input_paths, out_path, opts):
        self.check_version()

@@ -227,19 +260,23 @@ class FFmpegPostProcessor(PostProcessor):
        p = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, stdin=subprocess.PIPE)
        stdout, stderr = process_communicate_or_kill(p)
        if p.returncode != 0:
-            stderr = stderr.decode('utf-8', 'replace')
-            msg = stderr.strip().split('\n')[-1]
-            raise FFmpegPostProcessorError(msg)
+            stderr = stderr.decode('utf-8', 'replace').strip()
+            if self._downloader.params.get('verbose', False):
+                self.report_error(stderr)
+            raise FFmpegPostProcessorError(stderr.split('\n')[-1])
        self.try_utime(out_path, oldest_mtime, oldest_mtime)
+        return stderr.decode('utf-8', 'replace')

    def run_ffmpeg(self, path, out_path, opts):
-        self.run_ffmpeg_multiple_files([path], out_path, opts)
+        return self.run_ffmpeg_multiple_files([path], out_path, opts)

    def _ffmpeg_filename_argument(self, fn):
        # Always use 'file:' because the filename may contain ':' (ffmpeg
        # interprets that as a protocol) or can start with '-' (-- is broken in
        # ffmpeg, see https://ffmpeg.org/trac/ffmpeg/ticket/2127 for details)
        # Also leave '-' intact in order not to break streaming to stdout.
+        if fn.startswith(('http://', 'https://')):
+            return fn
        return 'file:' + fn if fn != '-' else fn


@@ -349,21 +386,35 @@ class FFmpegExtractAudioPP(FFmpegPostProcessor):
 class FFmpegVideoRemuxerPP(FFmpegPostProcessor):
    def __init__(self, downloader=None, preferedformat=None):
        super(FFmpegVideoRemuxerPP, self).__init__(downloader)
-        self._preferedformat = preferedformat
+        self._preferedformats = preferedformat.lower().split('/')

    def run(self, information):
        path = information['filepath']
-        if information['ext'] == self._preferedformat:
-            self.to_screen('Not remuxing video file %s - already is in target format %s' % (path, self._preferedformat))
+        sourceext, targetext = information['ext'].lower(), None
+        for pair in self._preferedformats:
+            kv = pair.split('>')
+            if len(kv) == 1 or kv[0].strip() == sourceext:
+                targetext = kv[-1].strip()
+                break
+
+        _skip_msg = (
+            'could not find a mapping for %s' if not targetext
+            else 'already is in target format %s' if sourceext == targetext
+            else None)
+        if _skip_msg:
+            self.to_screen('Not remuxing media file %s; %s' % (path, _skip_msg % sourceext))
            return [], information
+
        options = ['-c', 'copy', '-map', '0', '-dn']
-        prefix, sep, ext = path.rpartition('.')
-        outpath = prefix + sep + self._preferedformat
-        self.to_screen('Remuxing video from %s to %s, Destination: ' % (information['ext'], self._preferedformat) + outpath)
+        if targetext in ['mp4', 'm4a', 'mov']:
+            options.extend(['-movflags', '+faststart'])
+        prefix, sep, oldext = path.rpartition('.')
+        outpath = prefix + sep + targetext
+        self.to_screen('Remuxing video from %s to %s; Destination: %s' % (sourceext, targetext, outpath))
        self.run_ffmpeg(path, outpath, options)
        information['filepath'] = outpath
-        information['format'] = self._preferedformat
-        information['ext'] = self._preferedformat
+        information['format'] = targetext
+        information['ext'] = targetext
        return [path], information


@@ -406,18 +457,22 @@ class FFmpegEmbedSubtitlePP(FFmpegPostProcessor):
        sub_langs = []
        sub_filenames = []
        webm_vtt_warn = False
+        mp4_ass_warn = False

        for lang, sub_info in subtitles.items():
            sub_ext = sub_info['ext']
            if sub_ext == 'json':
-                self.to_screen('JSON subtitles cannot be embedded')
+                self.report_warning('JSON subtitles cannot be embedded')
            elif ext != 'webm' or ext == 'webm' and sub_ext == 'vtt':
                sub_langs.append(lang)
                sub_filenames.append(subtitles_filename(filename, lang, sub_ext, ext))
            else:
                if not webm_vtt_warn and ext == 'webm' and sub_ext != 'vtt':
                    webm_vtt_warn = True
-                    self.to_screen('Only WebVTT subtitles can be embedded in webm files')
+                    self.report_warning('Only WebVTT subtitles can be embedded in webm files')
+            if not mp4_ass_warn and ext == 'mp4' and sub_ext == 'ass':
+                mp4_ass_warn = True
+                self.report_warning('ASS subtitles cannot be properly embedded in mp4 files; expect issues')

        if not sub_langs:
            return [], information
@@ -441,7 +496,7 @@ class FFmpegEmbedSubtitlePP(FFmpegPostProcessor):
            opts.extend(['-metadata:s:s:%d' % i, 'language=%s' % lang_code])

        temp_filename = prepend_extension(filename, 'temp')
-        self.to_screen('Embedding subtitles in \'%s\'' % filename)
+        self.to_screen('Embedding subtitles in "%s"' % filename)
        self.run_ffmpeg_multiple_files(input_files, temp_filename, opts)
        os.remove(encodeFilename(filename))
        os.rename(encodeFilename(temp_filename), encodeFilename(filename))
@@ -471,7 +526,6 @@ class FFmpegMetadataPP(FFmpegPostProcessor):
        # 1. https://kdenlive.org/en/project/adding-meta-data-to-mp4-video/
        # 2. https://wiki.multimedia.cx/index.php/FFmpeg_Metadata
        # 3. https://kodi.wiki/view/Video_file_tagging
-        # 4. http://atomicparsley.sourceforge.net/mpeg-4files.html

        add('title', ('track', 'title'))
        add('date', 'upload_date')
@@ -524,6 +578,18 @@ class FFmpegMetadataPP(FFmpegPostProcessor):
                in_filenames.append(metadata_filename)
                options.extend(['-map_metadata', '1'])

+        if '__infojson_filepath' in info and info['ext'] in ('mkv', 'mka'):
+            old_stream, new_stream = self.get_stream_number(
+                filename, ('tags', 'mimetype'), 'application/json')
+            if old_stream is not None:
+                options.extend(['-map', '-0:%d' % old_stream])
+                new_stream -= 1
+
+            options.extend([
+                '-attach', info['__infojson_filepath'],
+                '-metadata:s:%d' % new_stream, 'mimetype=application/json'
+            ])
+
        self.to_screen('Adding metadata to \'%s\'' % filename)
        self.run_ffmpeg_multiple_files(in_filenames, temp_filename, options)
        if chapters:
--- a/youtube_dlc/postprocessor/metadatafromfield.py
+++ b/youtube_dlc/postprocessor/metadatafromfield.py
@@ -0,0 +1,66 @@
+from __future__ import unicode_literals
+
+import re
+
+from .common import PostProcessor
+from ..compat import compat_str
+
+
+class MetadataFromFieldPP(PostProcessor):
+    regex = r'(?P<field>\w+):(?P<format>.+)$'
+
+    def __init__(self, downloader, formats):
+        PostProcessor.__init__(self, downloader)
+        assert isinstance(formats, (list, tuple))
+        self._data = []
+        for f in formats:
+            assert isinstance(f, compat_str)
+            match = re.match(self.regex, f)
+            assert match is not None
+            self._data.append({
+                'field': match.group('field'),
+                'format': match.group('format'),
+                'regex': self.format_to_regex(match.group('format'))})
+
+    def format_to_regex(self, fmt):
+        r"""
+        Converts a string like
+           '%(title)s - %(artist)s'
+        to a regex like
+           '(?P<title>.+)\ \-\ (?P<artist>.+)'
+        """
+        if not re.search(r'%\(\w+\)s', fmt):
+            return fmt
+        lastpos = 0
+        regex = ''
+        # replace %(..)s with regex group and escape other string parts
+        for match in re.finditer(r'%\((\w+)\)s', fmt):
+            regex += re.escape(fmt[lastpos:match.start()])
+            regex += r'(?P<' + match.group(1) + r'>[^\r\n]+)'
+            lastpos = match.end()
+        if lastpos < len(fmt):
+            regex += re.escape(fmt[lastpos:])
+        return regex
+
+    def run(self, info):
+        for dictn in self._data:
+            field, regex = dictn['field'], dictn['regex']
+            if field not in info:
+                self.report_warning('Video doesnot have a %s' % field)
+                continue
+            self.write_debug('Searching for r"%s" in %s' % (regex, field))
+            match = re.search(regex, info[field])
+            if match is None:
+                self.report_warning('Could not interpret video %s as "%s"' % (field, dictn['format']))
+                continue
+            for attribute, value in match.groupdict().items():
+                info[attribute] = value
+                self.to_screen('parsed %s from %s: %s' % (attribute, field, value if value is not None else 'NA'))
+        return [], info
+
+
+class MetadataFromTitlePP(MetadataFromFieldPP):  # for backward compatibility
+    def __init__(self, downloader, titleformat):
+        super(MetadataFromTitlePP, self).__init__(downloader, ['title:%s' % titleformat])
+        self._titleformat = titleformat
+        self._titleregex = self._data[0]['regex']
--- a/youtube_dlc/postprocessor/metadatafromtitle.py
+++ b/youtube_dlc/postprocessor/metadatafromtitle.py
@@ -1,44 +0,0 @@
-from __future__ import unicode_literals
-
-import re
-
-from .common import PostProcessor
-
-
-class MetadataFromTitlePP(PostProcessor):
-    def __init__(self, downloader, titleformat):
-        super(MetadataFromTitlePP, self).__init__(downloader)
-        self._titleformat = titleformat
-        self._titleregex = (self.format_to_regex(titleformat)
-                            if re.search(r'%\(\w+\)s', titleformat)
-                            else titleformat)
-
-    def format_to_regex(self, fmt):
-        r"""
-        Converts a string like
-           '%(title)s - %(artist)s'
-        to a regex like
-           '(?P<title>.+)\ \-\ (?P<artist>.+)'
-        """
-        lastpos = 0
-        regex = ''
-        # replace %(..)s with regex group and escape other string parts
-        for match in re.finditer(r'%\((\w+)\)s', fmt):
-            regex += re.escape(fmt[lastpos:match.start()])
-            regex += r'(?P<' + match.group(1) + '>.+)'
-            lastpos = match.end()
-        if lastpos < len(fmt):
-            regex += re.escape(fmt[lastpos:])
-        return regex
-
-    def run(self, info):
-        title = info['title']
-        match = re.match(self._titleregex, title)
-        if match is None:
-            self.to_screen('Could not interpret title of video as "%s"' % self._titleformat)
-            return [], info
-        for attribute, value in match.groupdict().items():
-            info[attribute] = value
-            self.to_screen('parsed %s: %s' % (attribute, value if value is not None else 'NA'))
-
-        return [], info
--- a/youtube_dlc/postprocessor/movefilesafterdownload.py
+++ b/youtube_dlc/postprocessor/movefilesafterdownload.py
@@ -28,14 +28,14 @@ class MoveFilesAfterDownloadPP(PostProcessor):
        self.files_to_move[info['filepath']] = finalpath

        for oldfile, newfile in self.files_to_move.items():
-            if not os.path.exists(encodeFilename(oldfile)):
-                self.report_warning('File "%s" cannot be found' % oldfile)
-                continue
            if not newfile:
                newfile = os.path.join(finaldir, os.path.basename(encodeFilename(oldfile)))
            oldfile, newfile = compat_str(oldfile), compat_str(newfile)
            if os.path.abspath(encodeFilename(oldfile)) == os.path.abspath(encodeFilename(newfile)):
                continue
+            if not os.path.exists(encodeFilename(oldfile)):
+                self.report_warning('File "%s" cannot be found' % oldfile)
+                continue
            if os.path.exists(encodeFilename(newfile)):
                if self.get_param('overwrites', True):
                    self.report_warning('Replacing existing file "%s"' % newfile)
--- a/youtube_dlc/utils.py
+++ b/youtube_dlc/utils.py
@@ -5934,3 +5934,14 @@ def load_plugins(name, type, namespace):
        if plugin_info[0] is not None:
            plugin_info[0].close()
    return classes
+
+
+def traverse_dict(dictn, keys, casesense=True):
+    if not isinstance(dictn, dict):
+        return None
+    first_key = keys[0]
+    if not casesense:
+        dictn = {key.lower(): val for key, val in dictn.items()}
+        first_key = first_key.lower()
+    value = dictn.get(first_key, None)
+    return value if len(keys) < 2 else traverse_dict(value, keys[1:], casesense)
--- a/youtube_dlc/version.py
+++ b/youtube_dlc/version.py
@@ -1,3 +1,3 @@
 from __future__ import unicode_literals

-__version__ = '2021.01.20'
+__version__ = '2021.01.24'
--- a/yt-dlp.sublime-project
+++ b/yt-dlp.sublime-project
Author	SHA1	Message	Date
pukkandan	29b6000e35	Release 2021.01.29	2021-01-29 23:25:18 +05:30
pukkandan	e38df8f9fa	Refactor `update-version`, `pyinst.py` and related files * Refactor update-version * Moved pyinst, update-version and icon into devscripts * pyinst doesn't bump version anymore * Merge pyinst and pyinst32. Usage: `pyinst.py [32\|64]` * Add mutagen as requirement * Remove make_win and related files	2021-01-29 23:16:00 +05:30
pukkandan	caa15a7b57	[Audius] Add extractor (Closes #40 ) Related: https://github.com/ytdl-org/youtube-dl/pull/27360 Related: https://github.com/ytdl-org/youtube-dl/issues/24216 Direct API URLs are not currently supported. See https://github.com/ytdl-org/youtube-dl/pull/27360#issuecomment-757123708 for details Co-authored by: qulas	2021-01-29 22:30:22 +05:30
pukkandan	105b0b700e	Populate "playlist_*" fields for setting playlist metadata filename Related: #36	2021-01-29 01:57:14 +05:30
pukkandan	66c935fb16	Linter and misc cleanup :ci skip dl	2021-01-29 01:03:32 +05:30
pukkandan	64c0d954e5	[youtube] Extract playlist description	2021-01-29 00:31:50 +05:30
pukkandan	bf330f5f29	[anvato] Workaround for anvato_token_generator import failing (Closes #35 ) :ci skip dl	2021-01-28 15:57:37 +05:30
pukkandan	f6d7624f57	Partial solution for detecting existing files correctly even when extracting audio * Does not work when audio format is 'best'	2021-01-28 15:50:03 +05:30
pukkandan	ece8a2a1b6	[embedthumbnail] Fix for missing output filename for ffmpeg call (Closes #38 )	2021-01-28 15:48:33 +05:30
Bepis	8d0ea5f955	[Youtube] Improve comment API requests co-authored by bbepis	2021-01-28 11:49:31 +05:30
pukkandan	0748b3317b	Seperate import of lazy_extractors from that of normal extractors This prevents "ModuleNotFoundError: No module named 'youtube_dl.extractor.lazy_extractors'" from appearing in the traceback Related: https://github.com/animelover1984/youtube-dl/issues/17#issuecomment-757945024	2021-01-28 11:25:42 +05:30
pukkandan	6b591b2925	Detect existing files correctly even when there is remux/recode :ci skip dl	2021-01-28 10:49:37 +05:30
pukkandan	179122495b	[ffmpeg] Document more formats that are supported for remux/recode	2021-01-28 10:36:34 +05:30
pukkandan	02fd60d305	Write playlist description to file (Closes #36 ) :ci skip dl	2021-01-28 06:25:18 +05:30
pukkandan	06167fbbd3	#31 Features from animelover1984/youtube-dl * Add `--get-comments` * [youtube] Extract comments * [billibilli] Added BiliBiliSearchIE, BilibiliChannelIE * [billibilli] Extract comments * [billibilli] Better video extraction * Write playlist data to infojson * [FFmpegMetadata] Embed infojson inside the video * [EmbedThumbnail] Try embedding in mp4 using ffprobe and `-disposition` * [EmbedThumbnail] Treat mka like mkv and mov like mp4 * [EmbedThumbnail] Embed in ogg/opus * [VideoRemuxer] Conditionally remux video * [VideoRemuxer] Add `-movflags +faststart` when remuxing from mp4 * [ffmpeg] Print entire stderr in verbose when there is error * [EmbedSubtitle] Warn when embedding ass in mp4 * [avanto] Use NFLTokenGenerator if possible	2021-01-27 20:32:51 +05:30
pukkandan	4ff5e98991	More badges :ci skip all	2021-01-27 20:16:34 +05:30
pukkandan	e4172ac903	Deprecate avconv/avprobe All current functionality is left untouched. But don't expect any new features to work with avconv :ci skip all	2021-01-26 23:27:32 +05:30
pukkandan	5bfa486205	Add option `--parse-metadata` * The fields extracted by this can be used in `--output` * Deprecated `--metadata-from-title` :ci skip dl	2021-01-26 16:14:31 +05:30
pukkandan	9882064024	[movefiles] Don't give "cant find" warning when move is unnecessary	2021-01-26 15:53:32 +05:30
pukkandan	2d6921210d	[postprocessor] fix write_debug when no _downloader	2021-01-26 15:53:22 +05:30
pukkandan	f137c99e9f	Fix some fields not sorting correctly bug introduced by: `63be1aab2f`	2021-01-25 19:28:39 +05:30
pukkandan	6b8eb0c024	Report error message from youtube as error (Closes #33 ) :ci skip dl	2021-01-25 10:26:51 +05:30
pukkandan	5b328c97d7	Changed revision number to use '.' instead of '-' and refactor it :ci skip dl	2021-01-25 02:25:05 +05:30
pukkandan	b5d265633d	Fix wrong user config (Closes #32 ) :ci skip dl	2021-01-25 01:52:47 +05:30
pukkandan	a392adf56c	[version] update :ci skip dl	2021-01-24 21:51:50 +05:30
pukkandan	0bc0a32290	Release 2021.01.24	2021-01-24 21:39:55 +05:30
				`@@ -1 +0,0 @@`
				`py -m PyInstaller youtube_dlc\__main__.py --onefile --name youtube-dlc --version-file win\ver.txt --icon win\icon\cloud.ico --upx-exclude=vcruntime140.dll --exclude-module ytdlp_plugins`