livestreamer-1.12.2/ 0000755 0001750 0001750 00000000000 12521217500 015370 5 ustar chrippa chrippa 0000000 0000000 livestreamer-1.12.2/setup.cfg 0000644 0001750 0001750 00000000122 12521217500 017204 0 ustar chrippa chrippa 0000000 0000000 [wheel]
universal = 1
[egg_info]
tag_svn_revision = 0
tag_date = 0
tag_build =
livestreamer-1.12.2/PKG-INFO 0000644 0001750 0001750 00000001575 12521217500 016475 0 ustar chrippa chrippa 0000000 0000000 Metadata-Version: 1.1
Name: livestreamer
Version: 1.12.2
Summary: Livestreamer is command-line utility that extracts streams from various services and pipes them into a video player of choice.
Home-page: http://livestreamer.io/
Author: Christopher Rosell
Author-email: chrippa@tanuki.se
License: Simplified BSD
Description: UNKNOWN
Platform: UNKNOWN
Classifier: Development Status :: 5 - Production/Stable
Classifier: Environment :: Console
Classifier: Operating System :: POSIX
Classifier: Operating System :: Microsoft :: Windows
Classifier: Programming Language :: Python :: 2.6
Classifier: Programming Language :: Python :: 2.7
Classifier: Programming Language :: Python :: 3.3
Classifier: Programming Language :: Python :: 3.4
Classifier: Topic :: Internet :: WWW/HTTP
Classifier: Topic :: Multimedia :: Sound/Audio
Classifier: Topic :: Multimedia :: Video
Classifier: Topic :: Utilities
livestreamer-1.12.2/setup.py 0000644 0001750 0001750 00000004771 12521217321 017114 0 ustar chrippa chrippa 0000000 0000000 #!/usr/bin/env python
from os import environ
from os.path import abspath, dirname, join
from setuptools import setup
from sys import version_info, path as sys_path
deps = []
packages = [
"livestreamer",
"livestreamer.stream",
"livestreamer.plugin",
"livestreamer.plugin.api",
"livestreamer.plugins",
"livestreamer.packages",
"livestreamer.packages.flashmedia",
"livestreamer_cli",
"livestreamer_cli.packages",
"livestreamer_cli.utils"
]
if version_info[0] == 2:
# Require backport of concurrent.futures on Python 2
deps.append("futures")
# Require backport of argparse on Python 2.6
if version_info[1] == 6:
deps.append("argparse")
# Require singledispatch on Python <3.4
if version_info[0] == 2 or (version_info[0] == 3 and version_info[1] < 4):
deps.append("singledispatch")
# requests 2.0 does not work correctly on Python <2.6.3
if (version_info[0] == 2 and version_info[1] == 6 and version_info[2] < 3):
deps.append("requests>=1.0,<2.0")
else:
deps.append("requests>=1.0,<3.0")
# When we build an egg for the Win32 bootstrap we don't want dependency
# information built into it.
if environ.get("NO_DEPS"):
deps = []
srcdir = join(dirname(abspath(__file__)), "src/")
sys_path.insert(0, srcdir)
setup(name="livestreamer",
version="1.12.2",
description="Livestreamer is command-line utility that extracts streams "
"from various services and pipes them into a video player of "
"choice.",
url="http://livestreamer.io/",
author="Christopher Rosell",
author_email="chrippa@tanuki.se",
license="Simplified BSD",
packages=packages,
package_dir={ "": "src" },
entry_points={
"console_scripts": ["livestreamer=livestreamer_cli.main:main"]
},
install_requires=deps,
test_suite="tests",
classifiers=["Development Status :: 5 - Production/Stable",
"Environment :: Console",
"Operating System :: POSIX",
"Operating System :: Microsoft :: Windows",
"Programming Language :: Python :: 2.6",
"Programming Language :: Python :: 2.7",
"Programming Language :: Python :: 3.3",
"Programming Language :: Python :: 3.4",
"Topic :: Internet :: WWW/HTTP",
"Topic :: Multimedia :: Sound/Audio",
"Topic :: Multimedia :: Video",
"Topic :: Utilities"]
)
livestreamer-1.12.2/requirements-docs.txt 0000644 0001750 0001750 00000000007 12521217321 021600 0 ustar chrippa chrippa 0000000 0000000 sphinx
livestreamer-1.12.2/README.rst 0000644 0001750 0001750 00000005073 12521217321 017065 0 ustar chrippa chrippa 0000000 0000000 Livestreamer
============
.. image:: http://img.shields.io/pypi/v/livestreamer.svg?style=flat-square
:target: https://pypi.python.org/pypi/livestreamer
.. image:: http://img.shields.io/pypi/dm/livestreamer.svg?style=flat-square
:target: https://pypi.python.org/pypi/livestreamer
.. image:: http://img.shields.io/travis/chrippa/livestreamer.svg?style=flat-square
:target: http://travis-ci.org/chrippa/livestreamer
Overview
--------
Livestreamer is a `command-line utility`_ that pipes video streams
from various services into a video player, such as `VLC `_.
The main purpose of Livestreamer is to allow the user to avoid buggy and CPU
heavy flash plugins but still be able to enjoy various streamed content.
There is also an `API`_ available for developers who want access
to the video stream data.
- Documentation: http://docs.livestreamer.io/
- Issue tracker: https://github.com/chrippa/livestreamer/issues
- PyPI: https://pypi.python.org/pypi/livestreamer
- Discussions: https://groups.google.com/forum/#!forum/livestreamer
- IRC: #livestreamer @ Freenode
- Free software: Simplified BSD license
.. _command-line utility: http://docs.livestreamer.io/cli.html
.. _API: http://docs.livestreamer.io/api_guide.html
Features
--------
Livestreamer is built upon a plugin system which allows support for new services
to be easily added. Currently most of the big streaming services are supported,
such as:
- `Dailymotion `_
- `Livestream `_
- `Twitch `_
- `UStream `_
- `YouTube Live `_
... and many more. A full list of plugins currently included can be found
on the `Plugins`_ page.
.. _Plugins: http://docs.livestreamer.io/plugin_matrix.html
Quickstart
-----------
The default behaviour of Livestreamer is to playback a stream in the default
player (`VLC `_).
.. sourcecode:: console
# pip install livestreamer
$ livestreamer twitch.tv/day9tv best
[cli][info] Found matching plugin twitch for URL twitch.tv/day9tv
[cli][info] Opening stream: source
[cli][info] Starting player: vlc
For more in-depth usage and install instructions see the `User guide`_.
.. _User guide: http://docs.livestreamer.io/index.html#user-guide
Related software
----------------
Feel free to add any Livestreamer related things to
the `wiki `_.
Contributing
------------
If you wish to report a bug or contribute code, please take a look
at `CONTRIBUTING.rst `_ first.
livestreamer-1.12.2/MANIFEST.in 0000644 0001750 0001750 00000000324 12521217321 017126 0 ustar chrippa chrippa 0000000 0000000 include AUTHORS
include CHANGELOG.rst
include CONTRIBUTING.rst
include README.rst
include LICENSE*
include requirements-docs.txt
recursive-include docs *
recursive-include examples *
recursive-include tests *py
livestreamer-1.12.2/LICENSE.pbs 0000644 0001750 0001750 00000002052 12521217321 017160 0 ustar chrippa chrippa 0000000 0000000 Copyright (C) 2011-2012 by Andrew Moffat
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
livestreamer-1.12.2/LICENSE.flashmedia 0000644 0001750 0001750 00000002436 12521217321 020477 0 ustar chrippa chrippa 0000000 0000000 Copyright (c) 2011-2013, Christopher Rosell
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
1. Redistributions of source code must retain the above copyright notice, this
list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
livestreamer-1.12.2/LICENSE 0000644 0001750 0001750 00000002436 12521217321 016403 0 ustar chrippa chrippa 0000000 0000000 Copyright (c) 2011-2015, Christopher Rosell
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
1. Redistributions of source code must retain the above copyright notice, this
list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
livestreamer-1.12.2/CONTRIBUTING.rst 0000644 0001750 0001750 00000006566 12521217321 020047 0 ustar chrippa chrippa 0000000 0000000 ============
Contributing
============
Contributions are welcome, and they are greatly appreciated! Every
little bit helps, and credit will always be given.
You can contribute in many ways:
Types of Contributions
----------------------
Report Bugs
~~~~~~~~~~~
Report bugs at https://github.com/chrippa/livestreamer/issues.
If you are reporting a bug, please include:
* Your operating system name and version.
* Any details about your local setup that might be helpful in troubleshooting.
* Detailed steps to reproduce the bug.
Fix Bugs
~~~~~~~~
Look through the GitHub issues for bugs. Anything tagged with "bug"
is open to whoever wants to implement it.
Implement Features
~~~~~~~~~~~~~~~~~~
Look through the GitHub issues for features. Anything tagged with "feature"
is open to whoever wants to implement it.
Adding Plugins
~~~~~~~~~~~~~~
Livestreamer can always use more plugins. Look through the GitHub issues
if you are looking for something to implement.
There is no plugin documentation at the moment, but look at the existing
plugins to get an idea of how it works.
Write Documentation
~~~~~~~~~~~~~~~~~~~
Livestreamer could always use more documentation, whether as part of the
official Livestreamer docs, in docstrings, or even on the web in blog posts,
articles, and such.
Submit Feedback
~~~~~~~~~~~~~~~
The best way to send feedback is to file an issue at https://github.com/chrippa/livestreamer/issues.
If you are proposing a feature:
* Explain in detail how it would work.
* Keep the scope as narrow as possible, to make it easier to implement.
* Remember that this is a volunteer-driven project, and that contributions
are welcome :)
Get Started!
------------
Ready to contribute? Here's how to set up `livestreamer` for local development.
1. Fork the `livestreamer` repo on GitHub.
2. Clone your fork locally::
$ git clone git@github.com:your_name_here/livestreamer.git
3. Install your local copy into a virtualenv. Assuming you have virtualenvwrapper installed, this is how you set up your fork for local development::
$ mkvirtualenv livestreamer
$ cd livestreamer/
$ python setup.py develop
4. Create a branch for local development::
$ git checkout -b name-of-your-bugfix-or-feature
Now you can make your changes locally.
5. When you're done making changes, check that your changes pass the
tests, including testing other Python versions with tox::
$ python setup.py test
$ tox
To get tox, just pip install it into your virtualenv.
6. Commit your changes and push your branch to GitHub::
$ git add .
$ git commit -m "Your detailed description of your changes."
$ git push origin name-of-your-bugfix-or-feature
7. Submit a pull request through the GitHub website.
Pull Request Guidelines
-----------------------
Before you submit a pull request, check that it meets these guidelines:
1. The pull request should include tests if it's a core feature.
2. If the pull request adds functionality, the docs should be updated.
3. When creating a pull request, make sure it's on the correct branch.
These branches are currently used:
- master: Only critical fixes that needs to be released ASAP.
- develop: Everything else.
4. The pull request should work for Python 2.6, 2.7, and 3.3, and for PyPy. Check
https://travis-ci.org/chrippa/livestreamer/pull_requests
and make sure that the tests pass for all supported Python versions.
livestreamer-1.12.2/CHANGELOG.rst 0000644 0001750 0001750 00000064415 12521217321 017424 0 ustar chrippa chrippa 0000000 0000000 Version 1.12.2 (2015-05-02)
---------------------------
Bug fixes:
- hds: Don't modify request params when handling PVSWF. (#842)
- hls: Handle unpadded encryption IV's.
- Fixed regression in redirect resolver. (#816)
Plugins:
- Added plugin for media.ccc.de (media_ccc_de), patch by @meise.
- Added plugin for Kanal 5/9/11 (sbsdiscovery), patch by @tboss. (#815)
- Added plugin for Periscope (periscope).
- Added plugin for SSH101 (ssh101), patch by @Razier-23. (#869)
- artetv: Updated for service changes.
- crunchyroll: Updated for service changes. (#864, #865)
- hitbox: Fixed VOD support. (#856)
- livestream: Updated for service changes.
- viasat: Added support for juicyplay.se.
- viasat: Fixed missing streams. (#822)
- youtube: Added support for /channel URLs. (#825)
Version 1.12.1 (2015-03-22)
---------------------------
Bug fixes:
- Don't crash when failing to look up listening ports. (#790)
Plugins:
- Added plugin for ITV Player, patch by @blxd. (#776)
- Added plugin for tv3.cat, patch by @blxd. (#784)
- Added plugin for TV Catchup, patch by @blxd. (#775)
- connectcast: Fixed crash, patch by @mammothb. (#779)
- dailymotion: Added support for HDS VODs. (#731)
- gaminglive: Added support for VODs, patches by @kasper93 and @chhe. (#789, #808)
- picarto: Updated for service changes, patch by @FireDart. (#803)
- tv4play: Work around bad SSL implementation on Python 2. (#785)
- twitch: Use correct OAuth scopes, patch by @josephglanville. (#778)
- ustreamtv: Updated for service changes, patch by @trUSTssc. (#799)
- viasat: Fixed missing streams. (#750)
- viasat: Added play.tv3.lt to supported URLs. (#773)
Streams:
- hds: Fixed issue with query parameters when building fragment URLs. (#786)
Version 1.12.0 (2015-03-01)
---------------------------
Bug fixes:
- Made HTTP modes more strict to avoid issues with `mpv --yt-dl`.
- Fixed :option:`--http-cookie` option crash.
CLI:
- Added :option:`--can-handle-url` option, useful for scripting.
- Added :option:`--version-check` option to force a version check.
- Added a passive HTTP server mode (:option:`--player-external-http`), patch by @danielkza. (#699)
Plugins:
- Added plugin for Disney Channel Germany, patch by @boekkooi. (#698)
- Added plugin for NOS (Nederlandse Omroep Stichting), patch by @boekkooi. (#697)
- Added plugin for tga.plu.cn, patch by @wolftankk. (#669)
- Added plugin for Wat.tv, patch by @boekkooi. (#701)
- Added plugin for afreeca.tv. (The old afreecatv plugin has been renamed to afreeca)
- chaturbate: Added support for subdomain URLs, patch by @GameWalker. (#676)
- connectcast: Updated for service changes, patch by @darvelo. (#722)
- dailymotion: Added support for games.dailymotion.com, patch by @daslicious. (#684)
- dommune: Fixed Youtube redirect URL.
- gaminglive: Updated for service changes, patch by @chhe. (#721)
- mlgtv: Updated for service changes, patch by @daslicious. (#686)
- hitbox: Updated for services changes. (#648)
- streamlive: Updated for service changes, patch by @daslicious. (#667)
- ustreamtv: Updated for service changes. (#707)
- youtube: Now handles more URL types.
Version 1.11.1 (2014-12-12)
---------------------------
Plugins:
- twitch: Updated for API changes. (#633)
Version 1.11.0 (2014-12-10)
---------------------------
Bugfixes:
- cli: Only apply the backslash magic on player paths on Windows.
CLI:
- Added :option:`--http-cookie` option.
- Added :option:`--http-header` option.
- Added :option:`--http-query-param` option.
- Deprecated the :option:`--http-cookies` option.
- Deprecated the :option:`--http-headers` option.
- Deprecated the :option:`--http-query-params` option.
- Changed the continuous HTTP mode to always fetch streams.
Should fix segmented streams repeating at the end for most
services.
Plugins:
- Added plugin for NPO, patch by @monkeyphysics. (#599)
- afreecatv: Updated for service changes. (#568)
- beattv: Updated validation schema to include float offsets, patch by @suhailpatel. (#555)
- douyutv: Added support for transcodes.
- gaminglive: Fixed quality names, patch by @chhe. (#545)
- goodgame: Updated for service changes, patch by @JaxxC. (#554)
- oldlivestream: Check that streams don't return 404. (#560)
- ilive: Updated for service changes and renamed to streamlive. (#563)
- livestation: Updated for service changes. (#581)
- twitch: Added support for the new video streams.
- vaughnlive: Updated for service changes. (#611)
- veetle: Fixed shortcut URLs, patch by @monkeyphysics. (#601)
- viasat/viagame: Updated for service changes (#564, #566, #617)
Plugin API:
- Added a class to simplify mapping data to stream objects.
Version 1.10.2 (2014-09-05)
---------------------------
Plugins:
- Added plugin for Arte.tv (artetv). (#457)
- Added plugin for RTVE.es (rtve), patch by @jaimeMF. (#509)
- Added plugin for Seemeplay.ru (seemeplay). (#510)
- euronews: Updated for service changes.
- filmon: Updated for service changes. (#514)
- gaminglive: Updated for service changes, patch by @chhe. (#524)
- twitch: Now handles videos with chunks that are missing URLs.
- vaughnlive: Added support for breakers.tv, instagib.tv and vapers.tv. (#521)
- youtube: Added support for audio-only streams. (#522)
Version 1.10.1 (2014-08-22)
---------------------------
Bug fixes:
- Fixed strange read error caused by double buffering in FLV playlists.
Plugins:
- Added plugin for Vaughn Live (vaughnlive). (#478)
Version 1.10.0 (2014-08-18)
---------------------------
Bug fixes:
- The HDS options added in 1.8.0 where never actually applied when
used via the CLI, oops.
- Fixed default player paths not expanding ~, patch by @medina. (#484)
CLI:
- Added :option:`--hds-segment-threads` option.
- Added :option:`--hls-segment-threads` option.
- Added :option:`--stream-segment-attempts` option.
- Added :option:`--stream-segment-threads` option.
- Added :option:`--stream-segment-timeout` option.
- Added :option:`--stream-timeout` option.
- Deprecated the :option:`--jtv-cookie` option.
- Deprecated the :option:`--jtv-password` option.
- Significantly improved the status line printed while writing a
stream to a file. (#462)
Plugins:
- Added plugin for goodgame.ru (goodgame), patch by @eltiren. (#466)
- Added plugin for gaminglive.tv (gaminglive), patch by @chhe. (#468)
- Added plugin for douyutv.com (douyutv), patch by @nixxquality. (#469)
- Added plugin for NHK World (nhkworld).
- Added plugin for Let On TV (letontv), patch by @cheah. (#500)
- Removed plugin: justintv.
- afreecatv: Updated for service changes. (#488)
- hitbox: Added support for HLS videos.
- twitch: Fixed some Twitch broadcasts being unplayable. (#490)
- ustreamtv: Fixed regression that caused channels using RTMP streams to fail.
Streams:
- akamaihd: Now supports background buffering.
- http: Now supports background buffering.
API:
- Added new session option: ``hds-segment-threads``.
- Added new session option: ``hls-segment-threads``.
- Added new session option: ``stream-segment-attempts``.
- Added new session option: ``stream-segment-threads``.
- Added new session option: ``stream-segment-timeout``.
- Added new session option: ``stream-timeout``.
Version 1.9.0 (2014-07-22)
--------------------------
General:
- **Dropped support for Python 3.2.** This is due to missing features
which are necessary for this projects progression.
- `singledispatch `_ is now a
dependency on Python <3.4.
Bug fixes:
- Handle bad input data better in parse_json/xml. (#440)
- Handle bad input data in config files. (#432)
- Fixed regression causing rtmpdump proxies to have no effect.
CLI:
- Improved :option:`--help` significantly, more readable and more content.
- Added :option:`--config` option.
- Added :option:`--stream-url` option. (#281)
- Added support for K and M suffixes to the :option:`--ringbuffer-size` option.
- Added support for loading config files based on plugin.
- Added ~/Applications to the search path for VLC on Mac OS X, patch by @maxnordlund. (#454)
- Deprecated :option:`--best-stream-default` and added :option:`--default-stream`
as a more flexible replacement. (#381)
- Will now only warn about newer versions available every 6 hours.
Plugins:
- Many plugins have been refactored to use the validation API and better coding standards.
- Added plugin for Aftonbladet (aftonbladet).
- Added plugin for ARD Live (ard_live), patch by @MasterofJOKers. (#419)
- Added plugin for ARD Mediathek (ard_mediathek), patch by @yeeeargh. (#421)
- Added plugin for Connect Cast (connectcast). (#423)
- Added plugin for Danmarks Radio (drdk).
- Added plugin for DOMMUNE (dommune).
- Added plugin for TV4 Play (tv4play).
- Added plugin for VGTV (vgtv), patch by @jantore. (#435)
- Removed plugin: cast3d
- Removed plugin: freedocast
- Removed plugin: hashd
- Removed plugin: ongamenet
- afreecatv: Updated for service changes. (#412, #413)
- dailymotion: Added support for source streams, patch by @kasper93. (#428)
- euronews: Added support for videos.
- nrk: Added support for radio.nrk.no, patch by @jantore. (#433)
- picarto: Updated for service changes. (#431)
- twitch: Added support for audio only streams, patch by @CommanderRoot. (#411)
- viasat: Added support for HDS streams.
- viasat: Added support for viagame.com.
API:
- Added :func:`Livestreamer.streams` method.
- Added :func:`livestreamer.streams` function.
- Renamed :func:`Plugin.get_streams` to :func:`Plugin.streams`.
Plugin API:
- Added a validation API to make validating data easier and safer.
Version 1.8.2 (2014-05-30)
--------------------------
Bug fixes:
- Fixed regression in loading config from non-ascii paths on Python 2.
Plugins:
- azubutv: Update for service changes, patch by Gapato. (#399)
- dailymotion: Added support for VODs, patch by Gapato. (#402)
- hitbox: Fixed a issue where the correct streaming server was not used.
Streams:
- hls: Handle playlists that redirect. (#405)
Version 1.8.1 (2014-05-18)
--------------------------
General:
- Added a wheel package to PyPi for speedier installation via pip.
Bug fixes:
- hls: Handle encrypted segments that are invalid length (not multiple by 16). (#365)
Plugins:
- Added plugin for Furstream, patch by Pascal Romahn. (#360)
- Added plugin for Viasat's play sites (tv6play.se, etc). (#378)
- Added plugin for ZDFmediathek, patch by Pascal Romahn. (#360)
- azubutv: Updated for service changes. (#373)
- crunchyroll: Correctly handle unicode errors, patch by Agustin Carrasco. (#387, #388)
- filmon: Updated for service changes, patch by Athanasios Oikonomou. (#375)
- hitbox: Updated for service changes.
- ilive: Updated for service changes, patch by Athanasios Oikonomou. (#376)
- svtplay: Added support for SVT Flow.
- twitch: Now uses the beta API on beta.twitch.tv URLs. (#391)
- ustream: Correctly handle UHS streams containing only video or audio.
Version 1.8.0 (2014-04-21)
--------------------------
CLI:
- Added option: ``--no-version-check``
- Added HTTP options: ``--http-cookies``,
``--http-headers``,
``--http-query-params``,
``--http-ignore-env``,
``--http-no-ssl-verify``,
``--http-ssl-cert``,
``--http-ssl-cert-crt-key`` and
``--http-timeout``
- Added HTTP stream option: ``--http-stream-timeout``
- Added HDS stream options: ``--hds-segment-attempts``,
``--hds-segment-timeout``
``--hds-timeout``
- Added HLS stream options: ``--hls-live-edge``,
``--hls-segment-attempts``,
``--hls-segment-timeout`` and
``--hls-timeout``
- Added RTMP stream option: ``--rtmp-timeout``
- Added plugin options: ``--livestation-email`` and ``--livestation-password``
- Added stream options: ``--retry-streams``,
``--retry-open`` and
``--best-stream-default``
- Deprecated option: ``--hds-fragment-buffer``
Plugins:
- Added plugin for Bambuser, patch by Athanasios Oikonomou. (#327)
- Added plugin for Be-at.tv, patch by Athanasios Oikonomou. (#342)
- Added plugin for Chaturbate, patch by papplampe. (#337)
- Added plugin for Cybergame.tv, patch by Athanasios Oikonomou. (#324)
- Added plugin for Picarto, patch by papplampe. (#352)
- Added plugin for SpeedRunsLive, patch by Stefan Breunig. (#335)
- Removed plugins for dead services: Owncast.me and YYCast.
- azubutv: Added support for beta.azubu.tv.
- crunchyroll: Added workaround for SSL verification issue.
- dailymotion: Added support for HDS streams. (#348)
- gomexp: Fixed encoding issue on Python 2.
- livestation: Added support for logging in, patch by Sunaga Takahiro. (#344)
- mlgtv: Removed the ``mobile_`` prefix from the HLS streams.
- twitch: Added workaround for SSL verification issue. (#255)
- ustreamtv: Improved UHS stream stability.
- ustreamtv: Added support for RTMP VODs.
- youtube: Updated for service changes.
- youtube: Added support for embed URLs, patch by Athanasios Oikonomou.
- youtube: Now only picks up live streams from channel pages.
General:
- Now attempts to resolve URL redirects such as URL shorterners.
Bug fixes:
- Added workaround for HTTP streams not applying read timeout on some requests versions.
API:
- Added new options: ``hds-segment-attempts``,
``hds-segment-timeout``,
``hds-timeout``,
``hls-live-edge``,
``hls-segment-attempts``,
``hls-segment-timeout``,
``hls-timeout``,
``http-proxy``,
``https-proxy``,
``http-cookies``,
``http-headers``,
``http-query-params``,
``http-trust-env``,
``http-ssl-verify``,
``http-ssl-cert``,
``http-timeout``,
``http-stream-timeout`` and
``rtmp-timeout``
- Renamed option ``errorlog`` to ``subprocess-errorlog``.
- Renamed option ``rtmpdump-proxy`` to ``rtmp-proxy``.
- Renamed option ``rtmpdump`` to ``rtmp-rtmpdump``.
Version 1.7.5 (2014-03-07)
--------------------------
Plugins:
- filmon: Added VOD support, patch by Athanasios Oikonomou.
- ilive: Added support for HLS streams, patch by Athanasios Oikonomou.
- mlgtv: Updated for service changes.
- veetle: Now handles shortened URLs, patch by Athanasios Oikonomou.
- youtube: Updated for service changes.
Bug fixes:
- Fixed gzip not getting decoded in streams.
Other:
- Added scripts to automatically create Windows builds via Travis CI.
Builds are available here: http://livestreamer-builds.s3.amazonaws.com/builds.html
Version 1.7.4 (2014-02-28)
--------------------------
Plugins:
- Added plugin for MLG.tv. (#275)
- Added plugin for DMCloud, patch by Athanasios Oikonomou. (#297)
- Added plugin for NRK TV, patch by Jon Bergli Heier. (#309)
- Added plugin for GOMeXP.com.
- Removed GOMTV.net plugin as the service no longer exists.
- mips: Fixed issue with case sensitive playpath. (#306)
- ilive: Added missing app parameter. (#293)
- ustreamtv: Added support for password protected streams via ``--ustream-password``.
- youtube: Now handles youtu.be shortcuts, patch by Andy Mikhailenko. (#288)
- youtube: Use first available stream found on channel pages, patch by "unintended". (#291)
Streams:
- hds: Fixed segmented streams logic, patch by Moritz Blanke.
Bug fixes:
- Fixed buffer overwriting issue when passing a memoryview, patch by Martin Panter. (#295)
- Avoid a ResourceWarning when using ``--player-continuous-http``, patch by Martin Panter. (#296)
Version 1.7.3 (2014-01-31)
--------------------------
Plugins:
- Added plugin for hitbox.tv, patch by t0mm0. (#248)
- Added plugin for Crunchyroll, patch by Agustín Carrasco. (#262)
- twitch: Added support for hours in ?t=... on VODs.
- twitch: Added support for ?t=... on VOD highlights.
Streams:
- hls: Now allows retries on failed segment fetch.
Bug fixes:
- cli: Don't pass our proxy settings to the player. (#260)
- hds: Now uses global height as stream name if needed when parsing manifests.
- hls: Always use first stream for each quality in variant playlists. (#256)
- hls: Now returns correct exception on playlist parser errors.
- hls: Now remembers cookies set by variant playlist response. (#258)
Version 1.7.2 (2013-12-17)
--------------------------
CLI:
- The ``--twitch-legacy-names`` option is now deprecated.
- Added ``--twitch-oauth-authenticate`` and ``--twitch-oauth-token`` options.
Plugins:
- filmon: Added quality weights. (#239)
- filmon_us: Added support for VODs, patch by John Peterson. (#237)
- twitch: Updated for service changes. No more RTMP streams, only HLS.
- twitch: Removed mobile streams since they are the same as the new desktop streams.
- twitch: Removed the legacy names option.
- twitch: Added support for OAuth2 authentication.
- twitch: Added support for the t=00m0s parameter in VOD URLs.
Bug fixes:
- Always wait for the player process to exit, patch by Martin Panter. (#234)
- Fixed potential deadlocking when using named pipe, patch by Martin Panter. (#236)
- Fixed issue with spaces in default player path, patch by John Peterson. (#237)
Version 1.7.1 (2013-12-07)
--------------------------
Plugins:
- Added FilmOn Social TV plugin by John Peterson. (#225)
- twitch: Support mobile_source quality, patch by Andrew Bashore.
Streams:
- hds: Will now use video height as stream names if available.
- hds: Removed the use of movie identifier in the fragment URLs.
- hds: Added support for player verification, patch by Martin Panter. (#222)
Bug fixes:
- Fixed various Python warnings, patch by Martin Panter. (#221)
- cli: Fixed back-slash issue in ``--player-args``. (#218)
- hds: Fixed some streams complaining about the hardcoded hdcore parameter.
- hls: Fixed live streams that keep all previous segments in the playlists. (#224)
- setup.py now forces requests 1.x on Python <2.6.3. (#219)
Version 1.7.0 (2013-11-07)
--------------------------
CLI:
- Added a ``--player-no-close`` option.
- Added options to use HTTP proxies with ``--http-proxy`` and ``--https-proxy``.
- It's now possible to specify multiple streams as a comma-separated
list. If a stream is not available the next one in the list will be tried.
- Now only resolves synonyms once when using ``--player-continuous-http``.
- Removed the ``-u`` shortcut for ``--plugins``. This is a response to someone
spreading the misinformation that ``-url`` is a sane parameter to use.
It's technically valid, but due to the ``-u`` shortcut it would be
interpreted by Python's argparse as ``--plugins --rtmpdump l`` which
would cause livestreamer to look for a non-existing rtmpdump executable,
thus disabling any RTMP streams. (#193)
Plugins:
- Added Afreeca.tv plugin.
- dailymotion: Fixed incorrect RTMP parameters. (#201)
- filmon: Updated after service changes. Patch by Athanasios Oikonomou. (#205)
- ilive: Updated after service changes. (#200)
- livestream: Added support for HLS streams.
- livestream: Updated after service changes. (#195)
- mips: Updated after service changes. (#200)
- svtplay: Fixed some broken HDS streams. (#200)
- twitch: Updated to use the new HLS API.
- weeb: Updated after service changes. Patch by Athanasios Oikonomou. (#207)
- youtube: Now handles 3D streams properly. (#202)
Streams:
- hds: Added support for global bootstraps.
- hls: Rewrote the playlist parser from scratch to be more solid and correct
in accordance to the latest M3U8 spec.
- hls: Now supports playlists using EXT-X-BYTERANGE.
- hls: Now supports playlists using multiple EXT-X-KEY tags.
- hls: Now accepts extra requests parameters to be used when doing
HTTP requests.
Bug fixes:
- Fixed bytes-serialization when using ``--json``.
Version 1.6.1 (2013-10-07)
--------------------------
Bug fixes:
- CLI: Fixed broken ``--player-http`` and ``--player-continuous-http`` on Windows.
- CLI: Fixed un-quoted player paths containing backslashes being broken.
Version 1.6.0 (2013-09-29)
--------------------------
General:
- All stream names are now forced to lowercase to avoid issues with
services renaming streams. (#179)
- Updated requests compatibility to 2.0. (#183)
Plugins:
- Added plugin for Hashd.tv by kasper93. (#184)
- Azubu.tv: Updated after service changes. (#170)
- ILive.to: Updated after service changes. (#182)
- Twitch/Justin.tv: Refactored and split into separate plugins.
- Added support for archived streams (VOD). (#70)
- Added a option to force legacy stream names (720p, 1080p+, etc).
- Added a option to access password protected streams.
- UStream.tv: Refactored plugin and added support for their RTMP API and
special streaming technology (UHS). (#144)
CLI:
- Added some more player options: ``--player-args``, ``--player-http``,
``--player-continuous-http`` and ``--player-passthrough``. (#131)
- Expanded ``--stream-sorting-excludes`` to support more advanced
filtering. (#159)
- Now notifies the user if a new version of Livestreamer is available.
- Now allows case-insensitive stream name lookup.
API:
- Added a new exception (``LivestreamerError``) that all other exceptions
inherit from.
- The ``sorting_excludes`` parameter in ``Plugin.get_streams``
now supports more advanced filtering. (#159)
Bug fixes:
- Fixed HTTPStream with headers breaking ``--json`` on Python 3.
Version 1.5.2 (2013-08-27)
--------------------------
Plugins:
- Twitch/Justin.tv: Fix stream names.
Version 1.5.1 (2013-08-13)
--------------------------
Plugins:
- Added plugin for Filmon.
- Twitch/Justin.tv: Safer cookie and SWF URL handling.
- Youtube: Enable VOD support.
Bug fixes:
- Fixed potential crash when invalid UTF-8 is passed as arguments
to subprocesses.
Version 1.5.0 (2013-07-18)
--------------------------
CLI:
- Handle SIGTERM as SIGINT.
- Improved default player (VLC) detection.
- --stream-priority renamed to --stream-types and now excludes
any stream types not specified.
- Added --stream-sorting-excludes which excludes streams
from the internal sorting used by best/worst synonyms.
- Now returns exit code 1 on errors.
API:
- plugin.get_streams(): Renamed priority parameter to stream_types
and changed behaviour slightly.
- plugin.get_streams(): Added the parameter sorting_excludes.
Plugins:
- Added plugin for Aliez.tv.
- Added plugin for Weeb.tv.
- Added plugin for Veetle.
- Added plugin for Euronews.
- Dailymotion: Updated for JSON result changes.
- Livestream: Added SWF verification.
- Stream: Added httpstream://.
- Stream: Now evaluates parameters as Python values.
- Twitch/Justin.tv: Fixed HLS stream names.
- Youtube Live: Improved stream names.
Version 1.4.5 (2013-05-11)
--------------------------
Plugins:
- Twitch/Justin.tv: Fixed mobile transcode request never happening.
- GOMTV.net: Fixed issue causing disabled streams to be picked up.
- Azubu.tv: Updated for HTML change.
Streams:
- HLS: Fixed potential crash when getting a invalid playlist.
Version 1.4.4 (2013-05-03)
--------------------------
Plugins:
- Twitch/Justin.tv: Fixed possible crash on Python 3.
- Ilive.to: HTML parsing fixes by Sam Edwards.
Version 1.4.3 (2013-05-01)
--------------------------
CLI:
- Major refactoring of the code base.
- Now respects the XDG Base Directory Specification.
Will attempt to load config and plugins from the following paths:
- $XDG_CONFIG_HOME/livestreamer/config
- $XDG_CONFIG_HOME/livestreamer/plugins/
- The option --quiet-player is now deprecated since
it is now the default behaviour. A new option --verbose-player
was added to show the player's console output.
- The option --cmdline now prints arguments in quotes.
- Print error message if the player fails to start.
Plugins:
- Added a cache plugins can use to store data
that does not need to be generated on every run.
- Added Azubu.tv plugin.
- Added owncast.me plugin by Athanasios Oikonomou.
- Youtube: Updated for HTML changes.
- GOMTV.net:
- Fixed incorrect cookie names
- Stream names are now more consistent
- Added support for Limelight streams
- Twitch/Justin.tv:
- Fixed SWF verification issues
- The HLS streams available are now higher quality
Streams:
- Minor improvements and fixes to HDS.
Bug fixes:
- Properly fixed named pipe support on Windows.
Version 1.4.2 (2013-03-01)
--------------------------
CLI:
- Attempt to find VLC locations on OS X and Windows.
- Added --stream-priority parameter.
- Added --json parameter which makes livestreamer output JSON,
useful for scripting in other languages.
- Handle player exit cleaner by using SIGPIPE.
Plugins:
- UStream: Now falls back on alternative CDNs when neccessary and added
support for embed URLs.
- Added ilive.to plugin by Athanasios Oikonomou.
- Added cast3d.tv plugin by Athanasios Oikonomou.
- streamingvideoprovider.co.uk: Added support for RTMP streams.
- GOMTV.net: Major refactoring and also added support Adobe HDS streams.
- SVTPlay: Added support for Adobe HDS streams.
- Twitch/Justin.tv: Some minor tweaks and fixes.
- Ongamenet: Update to URL and HTML changes.
- Livestream.com: Update for HTML changes.
Streams:
- Minor improvements and fixes to HLS.
- Added support for Adobe HDS streams.
General:
- Removed cache parameter from default player, since they do not work
on older versions of VLC.
- Added meta-stream "worst".
- Removed sh dependancy and embeded pbs instead.
Bug fixes:
- Fix named pipes on Windows x64.
API:
- Added optional priority argument to Plugin.get_streams.
- Improved docstrings.
Version 1.4.1 (2012-12-20)
--------------------------
CLI:
- Added --ringbuffer-size option.
Plugins:
- Fixed problem with UStream plugin and latest RTMPDump.
- Added freedocast.com plugin by Athanasios Oikonomou.
- Added livestation.com plugin by Athanasios Oikonomou.
- Added mips.tv plugin by Athanasios Oikonomou.
- Added streamingvideoprovider.co.uk plugin by Athanasios Oikonomou.
- Added stream plugin that handles URLs such as hls://, rtmp://, etc.
- Added yycast.com plugin by Athanasios Oikonomou.
Streams:
- Refactored the HLS stream support.
General:
- Bumped requests version requirement to 1.0.
- Bumped sh version requirement to 1.07.
Version 1.4 (2012-11-23)
------------------------
CLI:
- Added --rtmpdump-proxy option.
- Added --plugin-dirs option.
- Now automatically attempts to use secondary stream CDNs when primary fails.
Plugins:
- Added Dailymotion plugin by Gaspard Jankowiak.
- Added livestream.com plugin.
- Added VOD support to GOMTV plugin.
- Twitch plugin now finds HLS streams.
- own3D.tv plugin now finds more CDNs.
- Fixed bugs in Youtube and GOMTV plugin.
- Refactored UStream plugin.
Streams:
- Added support for AkamaiHD HTTP streams.
General:
- Added unit tests, still fairly small coverage though.
- Added travis-ci integration.
- Now using python-sh on *nix since python-pbs is deprecated.
livestreamer-1.12.2/tests/ 0000755 0001750 0001750 00000000000 12521217500 016532 5 ustar chrippa chrippa 0000000 0000000 livestreamer-1.12.2/tests/test_stream_wrappers.py 0000644 0001750 0001750 00000001302 12521217321 023356 0 ustar chrippa chrippa 0000000 0000000 import unittest
from livestreamer.stream import StreamIOIterWrapper
class TestPluginStream(unittest.TestCase):
def test_iter(self):
def generator():
yield b"1" * 8192
yield b"2" * 4096
yield b"3" * 2048
fd = StreamIOIterWrapper(generator())
self.assertEqual(fd.read(4096), b"1" * 4096)
self.assertEqual(fd.read(2048), b"1" * 2048)
self.assertEqual(fd.read(2048), b"1" * 2048)
self.assertEqual(fd.read(1), b"2")
self.assertEqual(fd.read(4095), b"2" * 4095)
self.assertEqual(fd.read(1536), b"3" * 1536)
self.assertEqual(fd.read(), b"3" * 512)
if __name__ == "__main__":
unittest.main()
livestreamer-1.12.2/tests/test_session.py 0000644 0001750 0001750 00000007435 12521217321 021640 0 ustar chrippa chrippa 0000000 0000000 import os
import unittest
from livestreamer import Livestreamer, PluginError, NoPluginError
from livestreamer.plugins import Plugin
from livestreamer.stream import *
class TestSession(unittest.TestCase):
PluginPath = os.path.join(os.path.dirname(__file__), "plugins")
def setUp(self):
self.session = Livestreamer()
self.session.load_plugins(self.PluginPath)
def test_exceptions(self):
try:
self.session.resolve_url("invalid url")
self.assertTrue(False)
except NoPluginError:
self.assertTrue(True)
def test_load_plugins(self):
plugins = self.session.get_plugins()
self.assertTrue(plugins["testplugin"])
def test_builtin_plugins(self):
plugins = self.session.get_plugins()
self.assertTrue("twitch" in plugins)
def test_resolve_url(self):
plugins = self.session.get_plugins()
channel = self.session.resolve_url("http://test.se/channel")
self.assertTrue(isinstance(channel, Plugin))
self.assertTrue(isinstance(channel, plugins["testplugin"]))
def test_options(self):
self.session.set_option("test_option", "option")
self.assertEqual(self.session.get_option("test_option"), "option")
self.assertEqual(self.session.get_option("non_existing"), None)
self.assertEqual(self.session.get_plugin_option("testplugin", "a_option"), "default")
self.session.set_plugin_option("testplugin", "another_option", "test")
self.assertEqual(self.session.get_plugin_option("testplugin", "another_option"), "test")
self.assertEqual(self.session.get_plugin_option("non_existing", "non_existing"), None)
self.assertEqual(self.session.get_plugin_option("testplugin", "non_existing"), None)
def test_plugin(self):
channel = self.session.resolve_url("http://test.se/channel")
streams = channel.get_streams()
self.assertTrue("best" in streams)
self.assertTrue("worst" in streams)
self.assertTrue(streams["best"] is streams["1080p"])
self.assertTrue(streams["worst"] is streams["350k"])
self.assertTrue(isinstance(streams["rtmp"], RTMPStream))
self.assertTrue(isinstance(streams["http"], HTTPStream))
self.assertTrue(isinstance(streams["hls"], HLSStream))
self.assertTrue(isinstance(streams["akamaihd"], AkamaiHDStream))
def test_plugin_stream_types(self):
channel = self.session.resolve_url("http://test.se/channel")
streams = channel.get_streams(stream_types=["http", "rtmp"])
self.assertTrue(isinstance(streams["480p"], HTTPStream))
self.assertTrue(isinstance(streams["480p_rtmp"], RTMPStream))
streams = channel.get_streams(stream_types=["rtmp", "http"])
self.assertTrue(isinstance(streams["480p"], RTMPStream))
self.assertTrue(isinstance(streams["480p_http"], HTTPStream))
def test_plugin_stream_sorted_excludes(self):
channel = self.session.resolve_url("http://test.se/channel")
streams = channel.get_streams(sorting_excludes=["1080p", "3000k"])
self.assertTrue("best" in streams)
self.assertTrue("worst" in streams)
self.assertTrue(streams["best"] is streams["1500k"])
streams = channel.get_streams(sorting_excludes=[">=1080p", ">1500k"])
self.assertTrue(streams["best"] is streams["1500k"])
streams = channel.get_streams(sorting_excludes=lambda q: not q.endswith("p"))
self.assertTrue(streams["best"] is streams["3000k"])
def test_plugin_support(self):
channel = self.session.resolve_url("http://test.se/channel")
streams = channel.get_streams()
self.assertTrue("support" in streams)
self.assertTrue(isinstance(streams["support"], HTTPStream))
if __name__ == "__main__":
unittest.main()
livestreamer-1.12.2/tests/test_plugin_stream.py 0000644 0001750 0001750 00000006367 12521217321 023031 0 ustar chrippa chrippa 0000000 0000000 import os
import unittest
from livestreamer import Livestreamer, PluginError, NoPluginError
from livestreamer.plugins import Plugin
from livestreamer.stream import *
class TestPluginStream(unittest.TestCase):
def setUp(self):
self.session = Livestreamer()
def assertDictHas(self, a, b):
for key, value in a.items():
self.assertEqual(b[key], value)
def _test_akamaihd(self, surl, url):
channel = self.session.resolve_url(surl)
streams = channel.get_streams()
self.assertTrue("live" in streams)
stream = streams["live"]
self.assertTrue(isinstance(stream, AkamaiHDStream))
self.assertEqual(stream.url, url)
def _test_hls(self, surl, url):
channel = self.session.resolve_url(surl)
streams = channel.get_streams()
self.assertTrue("live" in streams)
stream = streams["live"]
self.assertTrue(isinstance(stream, HLSStream))
self.assertEqual(stream.url, url)
def _test_rtmp(self, surl, url, params):
channel = self.session.resolve_url(surl)
streams = channel.get_streams()
self.assertTrue("live" in streams)
stream = streams["live"]
self.assertTrue(isinstance(stream, RTMPStream))
self.assertEqual(stream.params["rtmp"], url)
self.assertDictHas(params, stream.params)
def _test_http(self, surl, url, params):
channel = self.session.resolve_url(surl)
streams = channel.get_streams()
self.assertTrue("live" in streams)
stream = streams["live"]
self.assertTrue(isinstance(stream, HTTPStream))
self.assertEqual(stream.url, url)
self.assertDictHas(params, stream.args)
def test_plugin(self):
self._test_rtmp("rtmp://hostname.se/stream",
"rtmp://hostname.se/stream", dict())
self._test_rtmp("rtmp://hostname.se/stream live=1 num=47",
"rtmp://hostname.se/stream", dict(live=True, num=47))
self._test_rtmp("rtmp://hostname.se/stream live=1 qarg='a \\'string' noq=test",
"rtmp://hostname.se/stream", dict(live=True, qarg='a \'string', noq="test"))
self._test_hls("hls://https://hostname.se/playlist.m3u8",
"https://hostname.se/playlist.m3u8")
self._test_hls("hls://hostname.se/playlist.m3u8",
"http://hostname.se/playlist.m3u8")
self._test_akamaihd("akamaihd://http://hostname.se/stream",
"http://hostname.se/stream")
self._test_akamaihd("akamaihd://hostname.se/stream",
"http://hostname.se/stream")
self._test_http("httpstream://http://hostname.se/auth.php auth=('test','test2')",
"http://hostname.se/auth.php", dict(auth=("test", "test2")))
self._test_http("httpstream://hostname.se/auth.php auth=('test','test2')",
"http://hostname.se/auth.php", dict(auth=("test", "test2")))
self._test_http("httpstream://https://hostname.se/auth.php verify=False params={'key': 'a value'}",
"https://hostname.se/auth.php?key=a+value", dict(verify=False, params=dict(key='a value')))
if __name__ == "__main__":
unittest.main()
livestreamer-1.12.2/tests/test_plugin_api_validate.py 0000644 0001750 0001750 00000012236 12521217321 024150 0 ustar chrippa chrippa 0000000 0000000 # coding: utf8
import re
import unittest
from xml.etree.ElementTree import Element
from livestreamer.plugin.api.validate import (
validate, all, any, optional, transform, text, filter, map, hasattr,
get, getattr, length, xml_element, xml_find, xml_findtext, xml_findall,
union, attr, url, startswith, endswith
)
class TestPluginAPIValidate(unittest.TestCase):
def test_basic(self):
assert validate(1, 1) == 1
assert validate(int, 1) == 1
assert validate(transform(int), "1") == 1
assert validate(text, "abc") == "abc"
assert validate(text, u"日本語") == u"日本語"
assert validate(transform(text), 1) == "1"
assert validate(list, ["a", 1]) == ["a", 1]
assert validate(dict, {"a": 1}) == {"a": 1}
assert validate(lambda n: 0 < n < 5, 3) == 3
def test_all(self):
assert validate(all(int, lambda n: 0 < n < 5), 3) == 3
assert validate(all(transform(int), lambda n: 0 < n < 5), 3.33) == 3
def test_any(self):
assert validate(any(int, dict), 5) == 5
assert validate(any(int, dict), {}) == {}
assert validate(any(int), 4) == 4
def test_union(self):
assert validate(union((get("foo"), get("bar"))),
{"foo": "alpha", "bar": "beta"}) == ("alpha", "beta")
def test_list(self):
assert validate([1, 0], [1, 0, 1, 1]) == [1, 0, 1, 1]
assert validate([1, 0], []) == []
assert validate(all([0, 1], lambda l: len(l) > 2), [0, 1, 0]) == [0, 1, 0]
def test_list_tuple_set_frozenset(self):
assert validate([int], [1, 2])
assert validate(set([int]), set([1, 2])) == set([1, 2])
assert validate(tuple([int]), tuple([1, 2])) == tuple([1, 2])
def test_dict(self):
assert validate({"key": 5}, {"key": 5}) == {"key": 5}
assert validate({"key": int}, {"key": 5}) == {"key": 5}
assert validate({"n": int, "f": float},
{"n": 5, "f": 3.14}) == {"n": 5, "f": 3.14}
def test_dict_keys(self):
assert validate({text: int},
{"a": 1, "b": 2}) == {"a": 1, "b": 2}
assert validate({transform(text): transform(int)},
{1: 3.14, 3.14: 1}) == {"1": 3, "3.14": 1}
def test_nested_dict_keys(self):
assert validate({text: {text: int}},
{"a": {"b": 1, "c": 2}}) == {"a": {"b": 1, "c": 2}}
def test_dict_optional_keys(self):
assert validate({"a": 1, optional("b"): 2}, {"a": 1}) == {"a": 1}
assert validate({"a": 1, optional("b"): 2},
{"a": 1, "b": 2}) == {"a": 1, "b": 2}
def test_filter(self):
assert validate(filter(lambda i: i > 5),
[10,5,4,6,7]) == [10,6,7]
def test_map(self):
assert validate(map(lambda v: v[0]), [(1, 2), (3, 4)]) == [1, 3]
def test_map_dict(self):
assert validate(map(lambda k, v: (v, k)), {"foo": "bar"}) == {"bar": "foo"}
def test_get(self):
assert validate(get("key"), {"key": "value"}) == "value"
assert validate(get("invalidkey", "default"), {"key": "value"}) == "default"
def test_get_re(self):
m = re.match("(\d+)p", "720p")
assert validate(get(1), m) == "720"
def test_getattr(self):
el = Element("foo")
assert validate(getattr("tag"), el) == "foo"
assert validate(getattr("invalid", "default"), el) == "default"
def test_hasattr(self):
el = Element("foo")
assert validate(hasattr("tag"), el) == el
def test_length(self):
assert validate(length(1), [1,2,3]) == [1,2,3]
def invalid_length():
validate(length(2), [1])
self.assertRaises(ValueError, invalid_length)
def test_xml_element(self):
el = Element("tag", attrib={"key": "value"})
el.text = "test"
assert validate(xml_element("tag"), el).tag == "tag"
assert validate(xml_element(text="test"), el).text == "test"
assert validate(xml_element(attrib={"key": text}), el).attrib == {"key": "value"}
def test_xml_find(self):
el = Element("parent")
el.append(Element("foo"))
el.append(Element("bar"))
assert validate(xml_find("bar"), el).tag == "bar"
def test_xml_findtext(self):
el = Element("foo")
el.text = "bar"
assert validate(xml_findtext("."), el) == "bar"
def test_xml_findall(self):
el = Element("parent")
children = [Element("child") for i in range(10)]
for child in children:
el.append(child)
assert validate(xml_findall("child"), el) == children
def test_attr(self):
el = Element("foo")
el.text = "bar"
assert validate(attr({"text": text}), el).text == "bar"
def test_url(self):
url_ = "https://google.se/path"
assert validate(url(), url_)
assert validate(url(scheme="http"), url_)
assert validate(url(path="/path"), url_)
def test_startswith(self):
assert validate(startswith("abc"), "abcedf")
def test_endswith(self):
assert validate(endswith(u"åäö"), u"xyzåäö")
if __name__ == "__main__":
unittest.main()
livestreamer-1.12.2/tests/test_plugin_api_http_session.py 0000644 0001750 0001750 00000001021 12521217321 025067 0 ustar chrippa chrippa 0000000 0000000 import unittest
from livestreamer.exceptions import PluginError
from livestreamer.plugin.api.http_session import HTTPSession
class TestPluginAPIHTTPSession(unittest.TestCase):
def test_read_timeout(self):
session = HTTPSession()
def stream_data():
res = session.get("http://httpbin.org/delay/6",
timeout=3, stream=True)
next(res.iter_content(8192))
self.assertRaises(PluginError, stream_data)
if __name__ == "__main__":
unittest.main()
livestreamer-1.12.2/tests/test_options.py 0000644 0001750 0001750 00000001010 12521217321 021627 0 ustar chrippa chrippa 0000000 0000000 import unittest
from livestreamer.options import Options
class TestOptions(unittest.TestCase):
def setUp(self):
self.options = Options({
"a_default": "default"
})
def test_options(self):
self.assertEqual(self.options.get("a_default"), "default")
self.assertEqual(self.options.get("non_existing"), None)
self.options.set("a_option", "option")
self.assertEqual(self.options.get("a_option"), "option")
if __name__ == "__main__":
unittest.main()
livestreamer-1.12.2/tests/test_log.py 0000644 0001750 0001750 00000001723 12521217321 020730 0 ustar chrippa chrippa 0000000 0000000 import unittest
from livestreamer.logger import Logger
from livestreamer.compat import is_py2
# Docs says StringIO is suppose to take non-unicode strings
# but it doesn't, so let's use BytesIO instead there...
if is_py2:
from io import BytesIO as StringIO
else:
from io import StringIO
class TestSession(unittest.TestCase):
def setUp(self):
self.output = StringIO()
self.manager = Logger()
self.manager.set_output(self.output)
self.logger = self.manager.new_module("test")
def test_level(self):
self.logger.debug("test")
self.assertEqual(self.output.tell(), 0)
self.manager.set_level("debug")
self.logger.debug("test")
self.assertNotEqual(self.output.tell(), 0)
def test_output(self):
self.manager.set_level("debug")
self.logger.debug("test")
self.assertEqual(self.output.getvalue(), "[test][debug] test\n")
if __name__ == "__main__":
unittest.main()
livestreamer-1.12.2/tests/test_buffer.py 0000644 0001750 0001750 00000004505 12521217321 021421 0 ustar chrippa chrippa 0000000 0000000 import unittest
from livestreamer.buffers import Buffer
class TestBuffer(unittest.TestCase):
def setUp(self):
self.buffer = Buffer()
def test_write(self):
self.buffer.write(b"1" * 8192)
self.buffer.write(b"2" * 4096)
self.assertEqual(self.buffer.length, 8192 + 4096)
def test_read(self):
self.buffer.write(b"1" * 8192)
self.buffer.write(b"2" * 4096)
self.assertEqual(self.buffer.length, 8192 + 4096)
self.assertEqual(self.buffer.read(4096), b"1" * 4096)
self.assertEqual(self.buffer.read(4096), b"1" * 4096)
self.assertEqual(self.buffer.read(), b"2" * 4096)
self.assertEqual(self.buffer.read(4096), b"")
self.assertEqual(self.buffer.read(), b"")
self.assertEqual(self.buffer.length, 0)
def test_readwrite(self):
self.buffer.write(b"1" * 8192)
self.assertEqual(self.buffer.length, 8192)
self.assertEqual(self.buffer.read(4096), b"1" * 4096)
self.assertEqual(self.buffer.length, 4096)
self.buffer.write(b"2" * 4096)
self.assertEqual(self.buffer.length, 8192)
self.assertEqual(self.buffer.read(1), b"1")
self.assertEqual(self.buffer.read(4095), b"1" * 4095)
self.assertEqual(self.buffer.read(8192), b"2" * 4096)
self.assertEqual(self.buffer.read(8192), b"")
self.assertEqual(self.buffer.read(), b"")
self.assertEqual(self.buffer.length, 0)
def test_close(self):
self.buffer.write(b"1" * 8192)
self.assertEqual(self.buffer.length, 8192)
self.buffer.close()
self.buffer.write(b"2" * 8192)
self.assertEqual(self.buffer.length, 8192)
def test_reuse_input(self):
"""Objects should be reusable after write()"""
original = b"original"
tests = [bytearray(original)]
try:
m = memoryview(bytearray(original))
except NameError: # Python 2.6 does not have "memoryview"
pass
else:
# Python 2.7 doesn't do bytes(memoryview) properly
if bytes(m) == original:
tests.append(m)
for data in tests:
self.buffer.write(data)
data[:] = b"reused!!"
self.assertEqual(self.buffer.read(), original)
if __name__ == "__main__":
unittest.main()
livestreamer-1.12.2/tests/__init__.py 0000644 0001750 0001750 00000000000 12521217321 020632 0 ustar chrippa chrippa 0000000 0000000 livestreamer-1.12.2/tests/plugins/ 0000755 0001750 0001750 00000000000 12521217500 020213 5 ustar chrippa chrippa 0000000 0000000 livestreamer-1.12.2/tests/plugins/testplugin_support.py 0000644 0001750 0001750 00000000215 12521217321 024556 0 ustar chrippa chrippa 0000000 0000000 from livestreamer.stream import HTTPStream
def get_streams(session):
return dict(support=HTTPStream(session, "http://test.se/support"))
livestreamer-1.12.2/tests/plugins/testplugin.py 0000644 0001750 0001750 00000003013 12521217321 022761 0 ustar chrippa chrippa 0000000 0000000 from livestreamer.plugins import Plugin
from livestreamer.options import Options
from livestreamer.stream import *
from livestreamer.plugin.api.support_plugin import testplugin_support
class TestPlugin(Plugin):
options = Options({
"a_option": "default"
})
@classmethod
def can_handle_url(self, url):
return "test.se" in url
def _get_streams(self):
streams = {}
streams["rtmp"] = RTMPStream(self.session, dict(rtmp="rtmp://test.se"))
streams["hls"] = HLSStream(self.session, "http://test.se/playlist.m3u8")
streams["http"] = HTTPStream(self.session, "http://test.se/stream")
streams["akamaihd"] = AkamaiHDStream(self.session, "http://test.se/stream")
streams["240p"] = HTTPStream(self.session, "http://test.se/stream")
streams["360p"] = HTTPStream(self.session, "http://test.se/stream")
streams["1080p"] = HTTPStream(self.session, "http://test.se/stream")
streams["350k"] = HTTPStream(self.session, "http://test.se/stream")
streams["800k"] = HTTPStream(self.session, "http://test.se/stream")
streams["1500k"] = HTTPStream(self.session, "http://test.se/stream")
streams["3000k"] = HTTPStream(self.session, "http://test.se/stream")
streams["480p"] = [HTTPStream(self.session, "http://test.se/stream"),
RTMPStream(self.session, dict(rtmp="rtmp://test.se"))]
streams.update(testplugin_support.get_streams(self.session))
return streams
__plugin__ = TestPlugin
livestreamer-1.12.2/tests/plugins/__init__.py 0000644 0001750 0001750 00000000000 12521217321 022313 0 ustar chrippa chrippa 0000000 0000000 livestreamer-1.12.2/src/ 0000755 0001750 0001750 00000000000 12521217500 016157 5 ustar chrippa chrippa 0000000 0000000 livestreamer-1.12.2/src/livestreamer_cli/ 0000755 0001750 0001750 00000000000 12521217500 021510 5 ustar chrippa chrippa 0000000 0000000 livestreamer-1.12.2/src/livestreamer_cli/output.py 0000644 0001750 0001750 00000011054 12521217321 023424 0 ustar chrippa chrippa 0000000 0000000 import os
import shlex
import subprocess
import sys
from time import sleep
from .compat import is_win32, stdout
from .constants import DEFAULT_PLAYER_ARGUMENTS
from .utils import ignored
if is_win32:
import msvcrt
class Output(object):
def __init__(self):
self.opened = False
def open(self):
self._open()
self.opened = True
def close(self):
if self.opened:
self._close()
self.opened = False
def write(self, data):
if not self.opened:
raise IOError("Output is not opened")
return self._write(data)
def _open(self):
pass
def _close(self):
pass
def _write(self, data):
pass
class FileOutput(Output):
def __init__(self, filename=None, fd=None):
self.filename = filename
self.fd = fd
def _open(self):
if self.filename:
self.fd = open(self.filename, "wb")
if is_win32:
msvcrt.setmode(self.fd.fileno(), os.O_BINARY)
def _close(self):
if self.fd is not stdout:
self.fd.close()
def _write(self, data):
self.fd.write(data)
class PlayerOutput(Output):
def __init__(self, cmd, args=DEFAULT_PLAYER_ARGUMENTS,
filename=None, quiet=True, kill=True,
call=False, http=False, namedpipe=None):
self.cmd = cmd
self.args = args
self.kill = kill
self.call = call
self.quiet = quiet
self.filename = filename
self.namedpipe = namedpipe
self.http = http
if self.namedpipe or self.filename or self.http:
self.stdin = sys.stdin
else:
self.stdin = subprocess.PIPE
if self.quiet:
self.stdout = open(os.devnull, "w")
self.stderr = open(os.devnull, "w")
else:
self.stdout = sys.stdout
self.stderr = sys.stderr
@property
def running(self):
sleep(0.5)
self.player.poll()
return self.player.returncode is None
def _create_arguments(self):
if self.namedpipe:
filename = self.namedpipe.path
elif self.filename:
filename = self.filename
elif self.http:
filename = self.http.url
else:
filename = "-"
args = self.args.format(filename=filename)
cmd = self.cmd
if is_win32:
# We want to keep the backslashes on Windows as forcing the user to
# escape backslashes for paths would be inconvenient.
cmd = cmd.replace("\\", "\\\\")
args = args.replace("\\", "\\\\")
return shlex.split(cmd) + shlex.split(args)
def _open(self):
try:
if self.call and self.filename:
self._open_call()
else:
self._open_subprocess()
finally:
if self.quiet:
# Output streams no longer needed in parent process
self.stdout.close()
self.stderr.close()
def _open_call(self):
subprocess.call(self._create_arguments(),
stdout=self.stdout,
stderr=self.stderr)
def _open_subprocess(self):
# Force bufsize=0 on all Python versions to avoid writing the
# unflushed buffer when closing a broken input pipe
self.player = subprocess.Popen(self._create_arguments(),
stdin=self.stdin, bufsize=0,
stdout=self.stdout,
stderr=self.stderr)
# Wait 0.5 seconds to see if program exited prematurely
if not self.running:
raise OSError("Process exited prematurely")
if self.namedpipe:
self.namedpipe.open("wb")
elif self.http:
self.http.open()
def _close(self):
# Close input to the player first to signal the end of the
# stream and allow the player to terminate of its own accord
if self.namedpipe:
self.namedpipe.close()
elif self.http:
self.http.close()
elif not self.filename:
self.player.stdin.close()
if self.kill:
with ignored(Exception):
self.player.kill()
self.player.wait()
def _write(self, data):
if self.namedpipe:
self.namedpipe.write(data)
elif self.http:
self.http.write(data)
else:
self.player.stdin.write(data)
__all__ = ["PlayerOutput", "FileOutput"]
livestreamer-1.12.2/src/livestreamer_cli/main.py 0000644 0001750 0001750 00000072571 12521217321 023023 0 ustar chrippa chrippa 0000000 0000000 import errno
import os
import requests
import sys
import signal
import webbrowser
from contextlib import closing
from distutils.version import StrictVersion
from functools import partial
from itertools import chain
from time import sleep
from livestreamer import (Livestreamer, StreamError, PluginError,
NoPluginError)
from livestreamer.cache import Cache
from livestreamer.stream import StreamProcess
from .argparser import parser
from .compat import stdout, is_win32
from .console import ConsoleOutput
from .constants import CONFIG_FILES, PLUGINS_DIR, STREAM_SYNONYMS
from .output import FileOutput, PlayerOutput
from .utils import NamedPipe, HTTPServer, ignored, progress, stream_to_url
ACCEPTABLE_ERRNO = (errno.EPIPE, errno.EINVAL, errno.ECONNRESET)
QUIET_OPTIONS = ("json", "stream_url", "subprocess_cmdline", "quiet")
args = console = livestreamer = plugin = stream_fd = None
def check_file_output(filename, force):
"""Checks if file already exists and ask the user if it should
be overwritten if it does."""
console.logger.debug("Checking file output")
if os.path.isfile(filename) and not force:
answer = console.ask("File {0} already exists! Overwrite it? [y/N] ",
filename)
if answer.lower() != "y":
sys.exit()
return FileOutput(filename)
def create_output():
"""Decides where to write the stream.
Depending on arguments it can be one of these:
- The stdout pipe
- A subprocess' stdin pipe
- A named pipe that the subprocess reads from
- A regular file
"""
if args.output:
if args.output == "-":
out = FileOutput(fd=stdout)
else:
out = check_file_output(args.output, args.force)
elif args.stdout:
out = FileOutput(fd=stdout)
else:
http = namedpipe = None
if not args.player:
console.exit("The default player (VLC) does not seem to be "
"installed. You must specify the path to a player "
"executable with --player.")
if args.player_fifo:
pipename = "livestreamerpipe-{0}".format(os.getpid())
console.logger.info("Creating pipe {0}", pipename)
try:
namedpipe = NamedPipe(pipename)
except IOError as err:
console.exit("Failed to create pipe: {0}", err)
elif args.player_http:
http = create_http_server()
console.logger.info("Starting player: {0}", args.player)
out = PlayerOutput(args.player, args=args.player_args,
quiet=not args.verbose_player,
kill=not args.player_no_close,
namedpipe=namedpipe, http=http)
return out
def create_http_server(host=None, port=0):
"""Creates a HTTP server listening on a given host and port.
If host is empty, listen on all available interfaces, and if port is 0,
listen on a random high port.
"""
try:
http = HTTPServer()
http.bind(host=host, port=port)
except OSError as err:
console.exit("Failed to create HTTP server: {0}", err)
return http
def iter_http_requests(server, player):
"""Repeatedly accept HTTP connections on a server.
Forever if the serving externally, or while a player is running if it is not
empty.
"""
while not player or player.running:
try:
yield server.open(timeout=2.5)
except OSError:
continue
def output_stream_http(plugin, initial_streams, external=False, port=0):
"""Continuously output the stream over HTTP."""
if not external:
if not args.player:
console.exit("The default player (VLC) does not seem to be "
"installed. You must specify the path to a player "
"executable with --player.")
server = create_http_server()
player = PlayerOutput(args.player, args=args.player_args,
filename=server.url,
quiet=not args.verbose_player)
try:
console.logger.info("Starting player: {0}", args.player)
if player:
player.open()
except OSError as err:
console.exit("Failed to start player: {0} ({1})",
args.player, err)
else:
server = create_http_server(host=None, port=port)
player = None
console.logger.info("Starting server, access with one of:")
for url in server.urls:
console.logger.info(" " + url)
for req in iter_http_requests(server, player):
user_agent = req.headers.get("User-Agent") or "unknown player"
console.logger.info("Got HTTP request from {0}".format(user_agent))
stream_fd = prebuffer = None
while not stream_fd and (not player or player.running):
try:
streams = initial_streams or fetch_streams(plugin)
initial_streams = None
for stream_name in (resolve_stream_name(streams, s) for s in args.stream):
if stream_name in streams:
stream = streams[stream_name]
break
else:
console.logger.info("Stream not available, will re-fetch "
"streams in 10 sec")
sleep(10)
continue
except PluginError as err:
console.logger.error(u"Unable to fetch new streams: {0}", err)
continue
try:
console.logger.info("Opening stream: {0} ({1})", stream_name,
type(stream).shortname())
stream_fd, prebuffer = open_stream(stream)
except StreamError as err:
console.logger.error("{0}", err)
if stream_fd and prebuffer:
console.logger.debug("Writing stream to player")
read_stream(stream_fd, server, prebuffer)
server.close(True)
player.close()
server.close()
def output_stream_passthrough(stream):
"""Prepares a filename to be passed to the player."""
filename = '"{0}"'.format(stream_to_url(stream))
out = PlayerOutput(args.player, args=args.player_args,
filename=filename, call=True,
quiet=not args.verbose_player)
try:
console.logger.info("Starting player: {0}", args.player)
out.open()
except OSError as err:
console.exit("Failed to start player: {0} ({1})", args.player, err)
return False
return True
def open_stream(stream):
"""Opens a stream and reads 8192 bytes from it.
This is useful to check if a stream actually has data
before opening the output.
"""
global stream_fd
# Attempts to open the stream
try:
stream_fd = stream.open()
except StreamError as err:
raise StreamError("Could not open stream: {0}".format(err))
# Read 8192 bytes before proceeding to check for errors.
# This is to avoid opening the output unnecessarily.
try:
console.logger.debug("Pre-buffering 8192 bytes")
prebuffer = stream_fd.read(8192)
except IOError as err:
raise StreamError("Failed to read data from stream: {0}".format(err))
if not prebuffer:
raise StreamError("No data returned from stream")
return stream_fd, prebuffer
def output_stream(stream):
"""Open stream, create output and finally write the stream to output."""
for i in range(args.retry_open):
try:
stream_fd, prebuffer = open_stream(stream)
break
except StreamError as err:
console.logger.error("{0}", err)
else:
return
output = create_output()
try:
output.open()
except (IOError, OSError) as err:
if isinstance(output, PlayerOutput):
console.exit("Failed to start player: {0} ({1})",
args.player, err)
else:
console.exit("Failed to open output: {0} ({1})",
args.output, err)
with closing(output):
console.logger.debug("Writing stream to output")
read_stream(stream_fd, output, prebuffer)
return True
def read_stream(stream, output, prebuffer, chunk_size=8192):
"""Reads data from stream and then writes it to the output."""
is_player = isinstance(output, PlayerOutput)
is_http = isinstance(output, HTTPServer)
is_fifo = is_player and output.namedpipe
show_progress = isinstance(output, FileOutput) and output.fd is not stdout
stream_iterator = chain(
[prebuffer],
iter(partial(stream.read, chunk_size), b"")
)
if show_progress:
stream_iterator = progress(stream_iterator,
prefix=os.path.basename(args.output))
try:
for data in stream_iterator:
# We need to check if the player process still exists when
# using named pipes on Windows since the named pipe is not
# automatically closed by the player.
if is_win32 and is_fifo:
output.player.poll()
if output.player.returncode is not None:
console.logger.info("Player closed")
break
try:
output.write(data)
except IOError as err:
if is_player and err.errno in ACCEPTABLE_ERRNO:
console.logger.info("Player closed")
elif is_http and err.errno in ACCEPTABLE_ERRNO:
console.logger.info("HTTP connection closed")
else:
console.logger.error("Error when writing to output: {0}", err)
break
except IOError as err:
console.logger.error("Error when reading from stream: {0}", err)
stream.close()
console.logger.info("Stream ended")
def handle_stream(plugin, streams, stream_name):
"""Decides what to do with the selected stream.
Depending on arguments it can be one of these:
- Output internal command-line
- Output JSON represenation
- Continuously output the stream over HTTP
- Output stream data to selected output
"""
stream_name = resolve_stream_name(streams, stream_name)
stream = streams[stream_name]
# Print internal command-line if this stream
# uses a subprocess.
if args.subprocess_cmdline:
if isinstance(stream, StreamProcess):
try:
cmdline = stream.cmdline()
except StreamError as err:
console.exit("{0}", err)
console.msg("{0}", cmdline)
else:
console.exit("The stream specified cannot be translated to a command")
# Print JSON representation of the stream
elif console.json:
console.msg_json(stream)
elif args.stream_url:
url = stream_to_url(stream)
if url:
console.msg("{0}", url)
else:
console.exit("The stream specified cannot be translated to a URL")
# Output the stream
else:
# Find any streams with a '_alt' suffix and attempt
# to use these in case the main stream is not usable.
alt_streams = list(filter(lambda k: stream_name + "_alt" in k,
sorted(streams.keys())))
file_output = args.output or args.stdout
for stream_name in [stream_name] + alt_streams:
stream = streams[stream_name]
stream_type = type(stream).shortname()
if stream_type in args.player_passthrough and not file_output:
console.logger.info("Opening stream: {0} ({1})", stream_name,
stream_type)
success = output_stream_passthrough(stream)
elif args.player_external_http:
return output_stream_http(plugin, streams, external=True,
port=args.player_external_http_port)
elif args.player_continuous_http and not file_output:
return output_stream_http(plugin, streams)
else:
console.logger.info("Opening stream: {0} ({1})", stream_name,
stream_type)
success = output_stream(stream)
if success:
break
def fetch_streams(plugin):
"""Fetches streams using correct parameters."""
return plugin.get_streams(stream_types=args.stream_types,
sorting_excludes=args.stream_sorting_excludes)
def fetch_streams_infinite(plugin, interval):
"""Attempts to fetch streams until some are returned."""
try:
streams = fetch_streams(plugin)
except PluginError as err:
console.logger.error(u"{0}", err)
streams = None
if not streams:
console.logger.info("Waiting for streams, retrying every {0} "
"second(s)", args.retry_streams)
while not streams:
sleep(args.retry_streams)
try:
streams = fetch_streams(plugin)
except PluginError as err:
console.logger.error(u"{0}", err)
return streams
def resolve_stream_name(streams, stream_name):
"""Returns the real stream name of a synonym."""
if stream_name in STREAM_SYNONYMS and stream_name in streams:
for name, stream in streams.items():
if stream is streams[stream_name] and name not in STREAM_SYNONYMS:
return name
return stream_name
def format_valid_streams(streams):
"""Formats a dict of streams.
Filters out synonyms and displays them next to
the stream they point to.
"""
delimiter = ", "
validstreams = []
for name, stream in sorted(streams.items()):
if name in STREAM_SYNONYMS:
continue
synonymfilter = lambda n: stream is streams[n] and n is not name
synonyms = list(filter(synonymfilter, streams.keys()))
if len(synonyms) > 0:
joined = delimiter.join(synonyms)
name = "{0} ({1})".format(name, joined)
validstreams.append(name)
return delimiter.join(validstreams)
def handle_url():
"""The URL handler.
Attempts to resolve the URL to a plugin and then attempts
to fetch a list of available streams.
Proceeds to handle stream if user specified a valid one,
otherwise output list of valid streams.
"""
try:
plugin = livestreamer.resolve_url(args.url)
console.logger.info("Found matching plugin {0} for URL {1}",
plugin.module, args.url)
if args.retry_streams:
streams = fetch_streams_infinite(plugin, args.retry_streams)
else:
streams = fetch_streams(plugin)
except NoPluginError:
console.exit("No plugin can handle URL: {0}", args.url)
except PluginError as err:
console.exit(u"{0}", err)
if not streams:
console.exit("No streams found on this URL: {0}", args.url)
if args.best_stream_default:
args.default_stream = ["best"]
if args.default_stream and not args.stream and not args.json:
args.stream = args.default_stream
if args.stream:
validstreams = format_valid_streams(streams)
for stream_name in args.stream:
if stream_name in streams:
console.logger.info("Available streams: {0}", validstreams)
handle_stream(plugin, streams, stream_name)
return
err = ("The specified stream(s) '{0}' could not be "
"found".format(", ".join(args.stream)))
if console.json:
console.msg_json(dict(streams=streams, plugin=plugin.module,
error=err))
else:
console.exit("{0}.\n Available streams: {1}",
err, validstreams)
else:
if console.json:
console.msg_json(dict(streams=streams, plugin=plugin.module))
else:
validstreams = format_valid_streams(streams)
console.msg("Available streams: {0}", validstreams)
def print_plugins():
"""Outputs a list of all plugins Livestreamer has loaded."""
pluginlist = list(livestreamer.get_plugins().keys())
pluginlist_formatted = ", ".join(sorted(pluginlist))
if console.json:
console.msg_json(pluginlist)
else:
console.msg("Loaded plugins: {0}", pluginlist_formatted)
def authenticate_twitch_oauth():
"""Opens a web browser to allow the user to grant Livestreamer
access to their Twitch account."""
client_id = "ewvlchtxgqq88ru9gmfp1gmyt6h2b93"
redirect_uri = "http://livestreamer.tanuki.se/en/develop/twitch_oauth.html"
url = ("https://api.twitch.tv/kraken/oauth2/authorize/"
"?response_type=token&client_id={0}&redirect_uri="
"{1}&scope=user_read+user_subscriptions").format(client_id, redirect_uri)
console.msg("Attempting to open a browser to let you authenticate "
"Livestreamer with Twitch")
try:
if not webbrowser.open_new_tab(url):
raise webbrowser.Error
except webbrowser.Error:
console.exit("Unable to open a web browser, try accessing this URL "
"manually instead:\n{0}".format(url))
def load_plugins(dirs):
"""Attempts to load plugins from a list of directories."""
dirs = [os.path.expanduser(d) for d in dirs]
for directory in dirs:
if os.path.isdir(directory):
livestreamer.load_plugins(directory)
else:
console.logger.warning("Plugin path {0} does not exist or is not "
"a directory!", directory)
def setup_args(config_files=[]):
"""Parses arguments."""
global args
arglist = sys.argv[1:]
# Load arguments from config files
for config_file in filter(os.path.isfile, config_files):
arglist.insert(0, "@" + config_file)
args = parser.parse_args(arglist)
# Force lowercase to allow case-insensitive lookup
if args.stream:
args.stream = [stream.lower() for stream in args.stream]
def setup_config_args():
config_files = []
if args.url:
with ignored(NoPluginError):
plugin = livestreamer.resolve_url(args.url)
config_files += ["{0}.{1}".format(fn, plugin.module) for fn in CONFIG_FILES]
if args.config:
# We want the config specified last to get highest priority
config_files += list(reversed(args.config))
else:
# Only load first available default config
for config_file in filter(os.path.isfile, CONFIG_FILES):
config_files.append(config_file)
break
if config_files:
setup_args(config_files)
def setup_console():
"""Console setup."""
global console
# All console related operations is handled via the ConsoleOutput class
console = ConsoleOutput(sys.stdout, livestreamer)
# Console output should be on stderr if we are outputting
# a stream to stdout.
if args.stdout or args.output == "-":
console.set_output(sys.stderr)
# We don't want log output when we are printing JSON or a command-line.
if not any(getattr(args, attr) for attr in QUIET_OPTIONS):
console.set_level(args.loglevel)
if args.quiet_player:
console.logger.warning("The option --quiet-player is deprecated since "
"version 1.4.3 as hiding player output is now "
"the default.")
if args.best_stream_default:
console.logger.warning("The option --best-stream-default is deprecated "
"since version 1.9.0, use '--default-stream best' "
"instead.")
console.json = args.json
# Handle SIGTERM just like SIGINT
signal.signal(signal.SIGTERM, signal.default_int_handler)
def setup_http_session():
"""Sets the global HTTP settings, such as proxy and headers."""
if args.http_proxy:
livestreamer.set_option("http-proxy", args.http_proxy)
if args.https_proxy:
livestreamer.set_option("https-proxy", args.https_proxy)
if args.http_cookie:
livestreamer.set_option("http-cookies", dict(args.http_cookie))
if args.http_header:
livestreamer.set_option("http-headers", dict(args.http_header))
if args.http_query_param:
livestreamer.set_option("http-query-params", dict(args.http_query_param))
if args.http_ignore_env:
livestreamer.set_option("http-trust-env", False)
if args.http_no_ssl_verify:
livestreamer.set_option("http-ssl-verify", False)
if args.http_ssl_cert:
livestreamer.set_option("http-ssl-cert", args.http_ssl_cert)
if args.http_ssl_cert_crt_key:
livestreamer.set_option("http-ssl-cert", tuple(args.http_ssl_cert_crt_key))
if args.http_timeout:
livestreamer.set_option("http-timeout", args.http_timeout)
if args.http_cookies:
console.logger.warning("The option --http-cookies is deprecated since "
"version 1.11.0, use --http-cookie instead.")
livestreamer.set_option("http-cookies", args.http_cookies)
if args.http_headers:
console.logger.warning("The option --http-headers is deprecated since "
"version 1.11.0, use --http-header instead.")
livestreamer.set_option("http-headers", args.http_headers)
if args.http_query_params:
console.logger.warning("The option --http-query-params is deprecated since "
"version 1.11.0, use --http-query-param instead.")
livestreamer.set_option("http-query-params", args.http_query_params)
def setup_plugins():
"""Loads any additional plugins."""
if os.path.isdir(PLUGINS_DIR):
load_plugins([PLUGINS_DIR])
if args.plugin_dirs:
load_plugins(args.plugin_dirs)
def setup_livestreamer():
"""Creates the Livestreamer session."""
global livestreamer
livestreamer = Livestreamer()
def setup_options():
"""Sets Livestreamer options."""
if args.hls_live_edge:
livestreamer.set_option("hls-live-edge", args.hls_live_edge)
if args.hls_segment_attempts:
livestreamer.set_option("hls-segment-attempts", args.hls_segment_attempts)
if args.hls_segment_threads:
livestreamer.set_option("hls-segment-threads", args.hls_segment_threads)
if args.hls_segment_timeout:
livestreamer.set_option("hls-segment-timeout", args.hls_segment_timeout)
if args.hls_timeout:
livestreamer.set_option("hls-timeout", args.hls_timeout)
if args.hds_live_edge:
livestreamer.set_option("hds-live-edge", args.hds_live_edge)
if args.hds_segment_attempts:
livestreamer.set_option("hds-segment-attempts", args.hds_segment_attempts)
if args.hds_segment_threads:
livestreamer.set_option("hds-segment-threads", args.hds_segment_threads)
if args.hds_segment_timeout:
livestreamer.set_option("hds-segment-timeout", args.hds_segment_timeout)
if args.hds_timeout:
livestreamer.set_option("hds-timeout", args.hds_timeout)
if args.http_stream_timeout:
livestreamer.set_option("http-stream-timeout", args.http_stream_timeout)
if args.ringbuffer_size:
livestreamer.set_option("ringbuffer-size", args.ringbuffer_size)
if args.rtmp_proxy:
livestreamer.set_option("rtmp-proxy", args.rtmp_proxy)
if args.rtmp_rtmpdump:
livestreamer.set_option("rtmp-rtmpdump", args.rtmp_rtmpdump)
if args.rtmp_timeout:
livestreamer.set_option("rtmp-timeout", args.rtmp_timeout)
if args.stream_segment_attempts:
livestreamer.set_option("stream-segment-attempts", args.stream_segment_attempts)
if args.stream_segment_threads:
livestreamer.set_option("stream-segment-threads", args.stream_segment_threads)
if args.stream_segment_timeout:
livestreamer.set_option("stream-segment-timeout", args.stream_segment_timeout)
if args.stream_timeout:
livestreamer.set_option("stream-timeout", args.stream_timeout)
livestreamer.set_option("subprocess-errorlog", args.subprocess_errorlog)
# Deprecated options
if args.hds_fragment_buffer:
console.logger.warning("The option --hds-fragment-buffer is deprecated "
"and will be removed in the future. Use "
"--ringbuffer-size instead")
def setup_plugin_options():
"""Sets Livestreamer plugin options."""
if args.twitch_cookie:
livestreamer.set_plugin_option("twitch", "cookie",
args.twitch_cookie)
if args.twitch_oauth_token:
livestreamer.set_plugin_option("twitch", "oauth_token",
args.twitch_oauth_token)
if args.ustream_password:
livestreamer.set_plugin_option("ustreamtv", "password",
args.ustream_password)
if args.crunchyroll_username:
livestreamer.set_plugin_option("crunchyroll", "username",
args.crunchyroll_username)
if args.crunchyroll_username and not args.crunchyroll_password:
crunchyroll_password = console.askpass("Enter Crunchyroll password: ")
else:
crunchyroll_password = args.crunchyroll_password
if crunchyroll_password:
livestreamer.set_plugin_option("crunchyroll", "password",
crunchyroll_password)
if args.crunchyroll_purge_credentials:
livestreamer.set_plugin_option("crunchyroll", "purge_credentials",
args.crunchyroll_purge_credentials)
if args.livestation_email:
livestreamer.set_plugin_option("livestation", "email",
args.livestation_email)
if args.livestation_password:
livestreamer.set_plugin_option("livestation", "password",
args.livestation_password)
# Deprecated options
if args.jtv_legacy_names:
console.logger.warning("The option --jtv/twitch-legacy-names is "
"deprecated and will be removed in the future.")
if args.jtv_cookie:
console.logger.warning("The option --jtv-cookie is deprecated and "
"will be removed in the future.")
if args.jtv_password:
console.logger.warning("The option --jtv-password is deprecated "
"and will be removed in the future.")
if args.gomtv_username:
console.logger.warning("The option --gomtv-username is deprecated "
"and will be removed in the future.")
if args.gomtv_password:
console.logger.warning("The option --gomtv-password is deprecated "
"and will be removed in the future.")
if args.gomtv_cookie:
console.logger.warning("The option --gomtv-cookie is deprecated "
"and will be removed in the future.")
def check_root():
if hasattr(os, "getuid"):
if os.geteuid() == 0 and not args.yes_run_as_root:
print("livestreamer is not supposed to be run as root. "
"If you really must you can do it by passing "
"--yes-run-as-root.")
sys.exit(1)
def check_version(force=False):
cache = Cache(filename="cli.json")
latest_version = cache.get("latest_version")
if force or not latest_version:
res = requests.get("https://pypi.python.org/pypi/livestreamer/json")
data = res.json()
latest_version = data.get("info").get("version")
cache.set("latest_version", latest_version, (60 * 60 * 24))
version_info_printed = cache.get("version_info_printed")
if not force and version_info_printed:
return
installed_version = StrictVersion(livestreamer.version)
latest_version = StrictVersion(latest_version)
if latest_version > installed_version:
console.logger.info("A new version of Livestreamer ({0}) is "
"available!".format(latest_version))
cache.set("version_info_printed", True, (60 * 60 * 6))
elif force:
console.logger.info("Your Livestreamer version ({0}) is up to date!",
installed_version)
if force:
sys.exit()
def main():
setup_args()
check_root()
setup_livestreamer()
setup_plugins()
setup_config_args()
setup_console()
setup_http_session()
if args.version_check or not args.no_version_check:
with ignored(Exception):
check_version(force=args.version_check)
if args.plugins:
print_plugins()
elif args.can_handle_url:
try:
livestreamer.resolve_url(args.can_handle_url)
except NoPluginError:
sys.exit(1)
else:
sys.exit(0)
elif args.url:
try:
setup_options()
setup_plugin_options()
handle_url()
except KeyboardInterrupt:
# Make sure current stream gets properly cleaned up
if stream_fd:
console.msg("Interrupted! Closing currently open stream...")
try:
stream_fd.close()
except KeyboardInterrupt:
sys.exit()
else:
console.msg("Interrupted! Exiting...")
elif args.twitch_oauth_authenticate:
authenticate_twitch_oauth()
else:
parser.print_help()
livestreamer-1.12.2/src/livestreamer_cli/constants.py 0000644 0001750 0001750 00000001541 12521217321 024100 0 ustar chrippa chrippa 0000000 0000000 import os
from livestreamer import __version__ as LIVESTREAMER_VERSION
from .compat import is_win32
DEFAULT_PLAYER_ARGUMENTS = "{filename}"
if is_win32:
APPDATA = os.environ["APPDATA"]
CONFIG_FILES = [os.path.join(APPDATA, "livestreamer", "livestreamerrc")]
PLUGINS_DIR = os.path.join(APPDATA, "livestreamer", "plugins")
else:
XDG_CONFIG_HOME = os.environ.get("XDG_CONFIG_HOME", "~/.config")
CONFIG_FILES = [
os.path.expanduser(XDG_CONFIG_HOME + "/livestreamer/config"),
os.path.expanduser("~/.livestreamerrc")
]
PLUGINS_DIR = os.path.expanduser(XDG_CONFIG_HOME + "/livestreamer/plugins")
STREAM_SYNONYMS = ["best", "worst"]
STREAM_PASSTHROUGH = ["hls", "http", "rtmp"]
__all__ = [
"CONFIG_FILES", "DEFAULT_PLAYER_ARGUMENTS", "LIVESTREAMER_VERSION",
"PLUGINS_DIR", "STREAM_SYNONYMS", "STREAM_PASSTHROUGH"
]
livestreamer-1.12.2/src/livestreamer_cli/console.py 0000644 0001750 0001750 00000003341 12521217321 023526 0 ustar chrippa chrippa 0000000 0000000 import json
import sys
from getpass import getpass
from .compat import input
from .utils import JSONEncoder
class ConsoleOutput(object):
def __init__(self, output, livestreamer, json=False):
self.livestreamer = livestreamer
self.logger = livestreamer.logger.new_module("cli")
self.json = json
self.set_output(output)
def set_level(self, level):
self.livestreamer.set_loglevel(level)
def set_output(self, output):
self.output = output
self.livestreamer.set_logoutput(output)
def ask(self, msg, *args, **kwargs):
formatted = msg.format(*args, **kwargs)
sys.stderr.write(formatted)
try:
answer = input()
except:
answer = ""
return answer.strip()
def askpass(self, msg, *args, **kwargs):
formatted = msg.format(*args, **kwargs)
return getpass(formatted)
def msg(self, msg, *args, **kwargs):
formatted = msg.format(*args, **kwargs)
formatted = "{0}\n".format(formatted)
self.output.write(formatted)
def msg_json(self, obj):
if not self.json:
return
if hasattr(obj, "__json__"):
obj = obj.__json__()
msg = json.dumps(obj, cls=JSONEncoder,
indent=2)
self.msg("{0}", msg)
if isinstance(obj, dict) and obj.get("error"):
sys.exit(1)
def exit(self, msg, *args, **kwargs):
formatted = msg.format(*args, **kwargs)
if self.json:
obj = dict(error=formatted)
self.msg_json(obj)
else:
msg = "error: {0}".format(formatted)
self.msg("{0}", msg)
sys.exit(1)
__all__ = ["ConsoleOutput"]
livestreamer-1.12.2/src/livestreamer_cli/compat.py 0000644 0001750 0001750 00000002024 12521217321 023344 0 ustar chrippa chrippa 0000000 0000000 import os
import re
import sys
is_py2 = (sys.version_info[0] == 2)
is_py3 = (sys.version_info[0] == 3)
is_win32 = os.name == "nt"
if is_py2:
input = raw_input
stdout = sys.stdout
file = file
_find_unsafe = re.compile(r"[^\w@%+=:,./-]").search
from .packages.shutil_backport import get_terminal_size
elif is_py3:
input = input
stdout = sys.stdout.buffer
from io import IOBase as file
from shutil import get_terminal_size
_find_unsafe = re.compile(r"[^\w@%+=:,./-]", re.ASCII).search
def shlex_quote(s):
"""Return a shell-escaped version of the string *s*.
Backported from Python 3.3 standard library module shlex.
"""
if not s:
return "''"
if _find_unsafe(s) is None:
return s
# use single quotes, and put single quotes into double quotes
# the string $'b is then quoted as '$'"'"'b'
return "'" + s.replace("'", "'\"'\"'") + "'"
__all__ = ["is_py2", "is_py3", "is_win32", "input", "stdout", "file",
"shlex_quote", "get_terminal_size"]
livestreamer-1.12.2/src/livestreamer_cli/argparser.py 0000644 0001750 0001750 00000061005 12521217321 024053 0 ustar chrippa chrippa 0000000 0000000 import argparse
import re
from string import printable
from textwrap import dedent
from .constants import (
LIVESTREAMER_VERSION, STREAM_PASSTHROUGH, DEFAULT_PLAYER_ARGUMENTS
)
from .utils import find_default_player
_filesize_re = re.compile("""
(?P\d+(\.\d+)?)
(?P[Kk]|[Mm])?
(?:[Bb])?
""", re.VERBOSE)
_keyvalue_re = re.compile("(?P[^=]+)\s*=\s*(?P.*)")
_printable_re = re.compile("[{0}]".format(printable))
_option_re = re.compile("""
(?P[A-z-]+) # A option name, valid characters are A to z and dash.
\s*
(?P=)? # Separating the option and the value with a equals sign is
# common, but optional.
\s*
(?P.*) # The value, anything goes.
""", re.VERBOSE)
class ArgumentParser(argparse.ArgumentParser):
def convert_arg_line_to_args(self, line):
# Strip any non-printable characters that might be in the
# beginning of the line (e.g. Unicode BOM marker).
match = _printable_re.search(line)
if not match:
return
line = line[match.start():].strip()
# Skip lines that do not start with a valid option (e.g. comments)
option = _option_re.match(line)
if not option:
return
name, value = option.group("name", "value")
if name and value:
yield "--{0}={1}".format(name, value)
elif name:
yield "--{0}".format(name)
class HelpFormatter(argparse.RawDescriptionHelpFormatter):
"""A nicer help formatter.
Help for arguments can be indented and contain new lines.
It will be de-dented and arguments in the help will be
separated by a blank line for better readability.
Originally written by Jakub Roztocil of the httpie project.
"""
def __init__(self, max_help_position=4, *args, **kwargs):
# A smaller indent for args help.
kwargs["max_help_position"] = max_help_position
argparse.RawDescriptionHelpFormatter.__init__(self, *args, **kwargs)
def _split_lines(self, text, width):
text = dedent(text).strip() + "\n\n"
return text.splitlines()
def comma_list(values):
return [val.strip() for val in values.split(",")]
def comma_list_filter(acceptable):
def func(p):
values = comma_list(p)
return list(filter(lambda v: v in acceptable, values))
return func
def num(type, min=None, max=None):
def func(value):
value = type(value)
if min is not None and not (value > min):
raise argparse.ArgumentTypeError(
"{0} value must be more than {1} but is {2}".format(
type.__name__, min, value
)
)
if max is not None and not (value <= max):
raise argparse.ArgumentTypeError(
"{0} value must be at most {1} but is {2}".format(
type.__name__, max, value
)
)
return value
func.__name__ = type.__name__
return func
def filesize(value):
match = _filesize_re.match(value)
if not match:
raise ValueError
size = float(match.group("size"))
if not size:
raise ValueError
modifier = match.group("modifier")
if modifier in ("M", "m"):
size *= 1024 * 1024
elif modifier in ("K", "k"):
size *= 1024
return num(int, min=0)(size)
def keyvalue(value):
match = _keyvalue_re.match(value)
if not match:
raise ValueError
return match.group("key", "value")
parser = ArgumentParser(
fromfile_prefix_chars="@",
formatter_class=HelpFormatter,
add_help=False,
usage="%(prog)s [OPTIONS] [URL] [STREAM]",
description=dedent("""
Livestreamer is command-line utility that extracts streams from
various services and pipes them into a video player of choice.
"""),
epilog=dedent("""
For more in-depth documention see:
http://docs.livestreamer.io/
Please report broken plugins or bugs to the issue tracker on Github:
https://github.com/chrippa/livestreamer/issues
""")
)
positional = parser.add_argument_group("Positional arguments")
positional.add_argument(
"url",
metavar="URL",
nargs="?",
help="""
A URL to attempt to extract streams from.
If it's a HTTP URL then "http://" can be omitted.
"""
)
positional.add_argument(
"stream",
metavar="STREAM",
nargs="?",
type=comma_list,
help="""
Stream to play.
Use "best" or "worst" for highest or lowest quality available.
Fallback streams can be specified by using a comma-separated list:
"720p,480p,best"
If no stream is specified and --default-stream is not used then a
list of available streams will be printed.
"""
)
general = parser.add_argument_group("General options")
general.add_argument(
"-h", "--help",
action="store_true",
help="""
Show this help message and exit.
"""
)
general.add_argument(
"-V", "--version",
action="version",
version="%(prog)s {0}".format(LIVESTREAMER_VERSION),
help="""
Show version number and exit.
"""
)
general.add_argument(
"--plugins",
action="store_true",
help="""
Print a list of all currently installed plugins.
"""
)
general.add_argument(
"--can-handle-url",
metavar="URL",
help="""
Check if Livestreamer has a plugin that can handle the specified URL.
Returns status code 1 for false and 0 for true.
Useful for external scripting.
"""
)
general.add_argument(
"--config",
action="append",
metavar="FILENAME",
help="""
Load options from this config file.
Can be repeated to load multiple files, in which case
the options are merged on top of each other where the
last config has highest priority.
"""
)
general.add_argument(
"-l", "--loglevel",
metavar="LEVEL",
default="info",
help="""
Set the log message threshold.
Valid levels are: none, error, warning, info, debug
"""
)
general.add_argument(
"-Q", "--quiet",
action="store_true",
help="""
Hide all log output.
Alias for "--loglevel none".
"""
)
general.add_argument(
"-j", "--json",
action="store_true",
help="""
Output JSON representations instead of the normal text output.
Useful for external scripting.
"""
)
general.add_argument(
"--no-version-check",
action="store_true",
help="""
Do not check for new Livestreamer releases.
"""
)
general.add_argument(
"--version-check",
action="store_true",
help="""
Runs a version check and exits.
"""
)
general.add_argument(
"--yes-run-as-root",
action="store_true",
help=argparse.SUPPRESS
)
player = parser.add_argument_group("Player options")
player.add_argument(
"-p", "--player",
metavar="COMMAND",
default=find_default_player(),
help="""
Player to feed stream data to. This is a shell-like syntax to
support passing options to the player. For example:
"vlc --file-caching=5000"
To use a player that is located in a path with spaces you must
quote the path:
"'/path/with spaces/vlc' --file-caching=5000"
By default VLC will be used if it can be found in its default
location.
"""
)
player.add_argument(
"-a", "--player-args",
metavar="ARGUMENTS",
default=DEFAULT_PLAYER_ARGUMENTS,
help="""
This option allows you to customize the default arguments which
are put together with the value of --player to create a command
to execute.
This value can contain formatting variables surrounded by curly
braces, {{ and }}. If you need to include a brace character, it
can be escaped by doubling, e.g. {{{{ and }}}}.
Formatting variables available:
filename
This is the filename that the player will use.
It's usually "-" (stdin), but can also be a URL or a file
depending on the options used.
It's usually enough to use --player instead of this unless you
need to add arguments after the filename.
Default is "{0}".
""".format(DEFAULT_PLAYER_ARGUMENTS)
)
player.add_argument(
"-v", "--verbose-player",
action="store_true",
help="""
Allow the player to display its console output.
"""
)
player.add_argument(
"-n", "--player-fifo", "--fifo",
action="store_true",
help="""
Make the player read the stream through a named pipe instead of
the stdin pipe.
"""
)
player.add_argument(
"--player-http",
action="store_true",
help="""
Make the player read the stream through HTTP instead of
the stdin pipe.
"""
)
player.add_argument(
"--player-continuous-http",
action="store_true",
help="""
Make the player read the stream through HTTP, but unlike
--player-http it will continuously try to open the stream if the
player requests it.
This makes it possible to handle stream disconnects if your player
is capable of reconnecting to a HTTP stream. This is usually
done by setting your player to a "repeat mode".
"""
)
player.add_argument(
"--player-external-http",
action="store_true",
help="""
Serve stream data through HTTP without running any player. This is useful
to allow external devices like smartphones or streaming boxes to watch
streams they wouldn't be able to otherwise.
Behavior will be similar to the continuous HTTP option, but no player
program will be started, and the server will listen on all available
connections instead of just in the local (loopback) interface.
The URLs that can be used to access the stream will be printed to the
console, and the server can be interrupted using CTRL-C.
"""
)
player.add_argument(
"--player-external-http-port",
metavar="PORT",
type=num(int, min=0, max=65535),
default=0,
help="""
A fixed port to use for the external HTTP server if that mode is enabled.
Omit or set to 0 to use a random high (>1024) port.
"""
)
player.add_argument(
"--player-passthrough",
metavar="TYPES",
type=comma_list_filter(STREAM_PASSTHROUGH),
default=[],
help="""
A comma-delimited list of stream types to pass to the player as a
URL to let it handle the transport of the stream instead.
Stream types that can be converted into a playable URL are:
- {0}
Make sure your player can handle the stream type when using this.
""".format("\n - ".join(STREAM_PASSTHROUGH))
)
player.add_argument(
"--player-no-close",
action="store_true",
help="""
By default Livestreamer will close the player when the stream ends.
This is to avoid "dead" GUI players lingering after a stream ends.
It does however have the side-effect of sometimes closing a player
before it has played back all of its cached data.
This option will instead let the player decide when to exit.
"""
)
output = parser.add_argument_group("File output options")
output.add_argument(
"-o", "--output",
metavar="FILENAME",
help="""
Write stream data to FILENAME instead of playing it.
You will be prompted if the file already exists.
"""
)
output.add_argument(
"-f", "--force",
action="store_true",
help="""
When using -o, always write to file even if it already exists.
"""
)
output.add_argument(
"-O", "--stdout",
action="store_true",
help="""
Write stream data to stdout instead of playing it.
"""
)
stream = parser.add_argument_group("Stream options")
stream.add_argument(
"--default-stream",
type=comma_list,
metavar="STREAM",
help="""
Open this stream when no stream argument is specified, e.g. "best".
"""
)
stream.add_argument(
"--retry-streams",
metavar="DELAY",
type=num(float, min=0),
help="""
Will retry fetching streams until streams are found while
waiting DELAY (seconds) between each attempt.
"""
)
stream.add_argument(
"--retry-open",
metavar="ATTEMPTS",
type=num(int, min=0),
default=1,
help="""
Will try ATTEMPTS times to open the stream until giving up.
Default is 1.
"""
)
stream.add_argument(
"--stream-types", "--stream-priority",
metavar="TYPES",
type=comma_list,
help="""
A comma-delimited list of stream types to allow.
The order will be used to separate streams when there are multiple
streams with the same name but different stream types.
Default is "rtmp,hls,hds,http,akamaihd".
"""
)
stream.add_argument(
"--stream-sorting-excludes",
metavar="STREAMS",
type=comma_list,
help="""
Fine tune best/worst synonyms by excluding unwanted streams.
Uses a filter expression in the format:
[operator]
Valid operators are >, >=, < and <=. If no operator is specified
then equality is tested.
For example this will exclude streams ranked higher than "480p":
">480p"
Multiple filters can be used by separating each expression with
a comma.
For example this will exclude streams from two quality types:
">480p,>medium"
"""
)
transport = parser.add_argument_group("Stream transport options")
transport.add_argument(
"--hds-live-edge",
type=num(float, min=0),
metavar="SECONDS",
help="""
The time live HDS streams will start from the edge of stream.
Default is 10.0.
"""
)
transport.add_argument(
"--hds-segment-attempts",
type=num(int, min=0),
metavar="ATTEMPTS",
help="""
How many attempts should be done to download each HDS segment
before giving up.
Default is 3.
"""
)
transport.add_argument(
"--hds-segment-threads",
type=num(int, max=10),
metavar="THREADS",
help="""
The size of the thread pool used to download HDS segments.
Minimum value is 1 and maximum is 10.
Default is 1.
"""
)
transport.add_argument(
"--hds-segment-timeout",
type=num(float, min=0),
metavar="TIMEOUT",
help="""
HDS segment connect and read timeout.
Default is 10.0.
"""
)
transport.add_argument(
"--hds-timeout",
type=num(float, min=0),
metavar="TIMEOUT",
help="""
Timeout for reading data from HDS streams.
Default is 60.0.
"""
)
transport.add_argument(
"--hls-live-edge",
type=num(int, min=0),
metavar="SEGMENTS",
help="""
How many segments from the end to start live HLS streams on.
The lower the value the lower latency from the source you will be,
but also increases the chance of buffering.
Default is 3.
"""
)
transport.add_argument(
"--hls-segment-attempts",
type=num(int, min=0),
metavar="ATTEMPTS",
help="""
How many attempts should be done to download each HLS segment
before giving up.
Default is 3.
"""
)
transport.add_argument(
"--hls-segment-threads",
type=num(int, max=10),
metavar="THREADS",
help="""
The size of the thread pool used to download HLS segments.
Minimum value is 1 and maximum is 10.
Default is 1.
"""
)
transport.add_argument(
"--hls-segment-timeout",
type=num(float, min=0),
metavar="TIMEOUT",
help="""
HLS segment connect and read timeout.
Default is 10.0.
""")
transport.add_argument(
"--hls-timeout",
type=num(float, min=0),
metavar="TIMEOUT",
help="""
Timeout for reading data from HLS streams.
Default is 60.0.
""")
transport.add_argument(
"--http-stream-timeout",
type=num(float, min=0),
metavar="TIMEOUT",
help="""
Timeout for reading data from HTTP streams.
Default is 60.0.
"""
)
transport.add_argument(
"--ringbuffer-size",
metavar="SIZE",
type=filesize,
help="""
The maximum size of ringbuffer. Add a M or K suffix to specify mega
or kilo bytes instead of bytes.
The ringbuffer is used as a temporary storage between the stream
and the player. This is to allows us to download the stream faster
than the player wants to read it.
The smaller the size, the higher chance of the player buffering
if there are download speed dips and the higher size the more data
we can use as a storage to catch up from speed dips.
It also allows you to temporary pause as long as the ringbuffer
doesn't get full since we continue to download the stream in the
background.
Note: A smaller size is recommended on lower end systems (such as
Raspberry Pi) when playing stream types that require some extra
processing (such as HDS) to avoid unnecessary background
processing.
Default is "16M".
""")
transport.add_argument(
"--rtmp-proxy", "--rtmpdump-proxy",
metavar="PROXY",
help="""
A SOCKS proxy that RTMP streams will use.
Example: 127.0.0.1:9050
"""
)
transport.add_argument(
"--rtmp-rtmpdump", "--rtmpdump", "-r",
metavar="FILENAME",
help="""
RTMPDump is used to access RTMP streams. You can specify the
location of the rtmpdump executable if it is not in your PATH.
Example: "/usr/local/bin/rtmpdump"
"""
)
transport.add_argument(
"--rtmp-timeout",
type=num(float, min=0),
metavar="TIMEOUT",
help="""
Timeout for reading data from RTMP streams.
Default is 60.0.
"""
)
transport.add_argument(
"--stream-segment-attempts",
type=num(int, min=0),
metavar="ATTEMPTS",
help="""
How many attempts should be done to download each segment before giving up.
This is generic option used by streams not covered by other options,
such as stream protocols specific to plugins, e.g. UStream.
Default is 3.
"""
)
transport.add_argument(
"--stream-segment-threads",
type=num(int, max=10),
metavar="THREADS",
help="""
The size of the thread pool used to download segments.
Minimum value is 1 and maximum is 10.
This is generic option used by streams not covered by other options,
such as stream protocols specific to plugins, e.g. UStream.
Default is 1.
"""
)
transport.add_argument(
"--stream-segment-timeout",
type=num(float, min=0),
metavar="TIMEOUT",
help="""
Segment connect and read timeout.
This is generic option used by streams not covered by other options,
such as stream protocols specific to plugins, e.g. UStream.
Default is 10.0.
""")
transport.add_argument(
"--stream-timeout",
type=num(float, min=0),
metavar="TIMEOUT",
help="""
Timeout for reading data from streams.
This is generic option used by streams not covered by other options,
such as stream protocols specific to plugins, e.g. UStream.
Default is 60.0.
""")
transport.add_argument(
"--stream-url",
action="store_true",
help="""
If possible, translate the stream to a URL and print it.
"""
)
transport.add_argument(
"--subprocess-cmdline", "--cmdline", "-c",
action="store_true",
help="""
Print command-line used internally to play stream.
This is only available on RTMP streams.
"""
)
transport.add_argument(
"--subprocess-errorlog", "--errorlog", "-e",
action="store_true",
help="""
Log possible errors from internal subprocesses to a temporary file.
The file will be saved in your systems temporary directory.
Useful when debugging rtmpdump related issues.
"""
)
http = parser.add_argument_group("HTTP options")
http.add_argument(
"--http-proxy",
metavar="HTTP_PROXY",
help="""
A HTTP proxy to use for all HTTP requests.
Example: http://hostname:port/
"""
)
http.add_argument(
"--https-proxy",
metavar="HTTPS_PROXY",
help="""
A HTTPS capable proxy to use for all HTTPS requests.
Example: http://hostname:port/
"""
)
http.add_argument(
"--http-cookie",
metavar="KEY=VALUE",
type=keyvalue,
action="append",
help="""
A cookie to add to each HTTP request.
Can be repeated to add multiple cookies.
"""
)
http.add_argument(
"--http-header",
metavar="KEY=VALUE",
type=keyvalue,
action="append",
help="""
A header to add to each HTTP request.
Can be repeated to add multiple headers.
"""
)
http.add_argument(
"--http-query-param",
metavar="KEY=VALUE",
type=keyvalue,
action="append",
help="""
A query parameter to add to each HTTP request.
Can be repeated to add multiple query parameters.
"""
)
http.add_argument(
"--http-ignore-env",
action="store_true",
help="""
Ignore HTTP settings set in the environment such as environment
variables (HTTP_PROXY, etc) or ~/.netrc authentication.
"""
)
http.add_argument(
"--http-no-ssl-verify",
action="store_true",
help="""
Don't attempt to verify SSL certificates.
Usually a bad idea, only use this if you know what you're doing.
"""
)
http.add_argument(
"--http-ssl-cert",
metavar="FILENAME",
help="""
SSL certificate to use.
Expects a .pem file.
"""
)
http.add_argument(
"--http-ssl-cert-crt-key",
metavar=("CRT_FILENAME", "KEY_FILENAME"),
nargs=2,
help="""
SSL certificate to use.
Expects a .crt and a .key file.
"""
)
http.add_argument(
"--http-timeout",
metavar="TIMEOUT",
type=num(float, min=0),
help="""
General timeout used by all HTTP requests except the ones covered
by other options.
Default is 20.0.
"""
)
plugin = parser.add_argument_group("Plugin options")
plugin.add_argument(
"--plugin-dirs",
metavar="DIRECTORY",
type=comma_list,
help="""
Attempts to load plugins from these directories.
Multiple directories can be used by separating them with a
semi-colon.
"""
)
plugin.add_argument(
"--twitch-oauth-token",
metavar="TOKEN",
help="""
An OAuth token to use for Twitch authentication.
Use --twitch-oauth-authenticate to create a token.
"""
)
plugin.add_argument(
"--twitch-oauth-authenticate",
action="store_true",
help="""
Open a web browser where you can grant Livestreamer access
to your Twitch account which creates a token for use with
--twitch-oauth-token.
"""
)
plugin.add_argument(
"--twitch-cookie",
metavar="COOKIES",
help="""
Twitch cookies to authenticate to allow access to subscription channels.
Example:
"_twitch_session_id=xxxxxx; persistent=xxxxx"
Note: This method is the old and clunky way of authenticating with
Twitch, using --twitch-oauth-authenticate is the recommended and
simpler way of doing it now.
"""
)
plugin.add_argument(
"--ustream-password",
metavar="PASSWORD",
help="""
A password to access password protected UStream.tv channels.
"""
)
plugin.add_argument(
"--crunchyroll-username",
metavar="USERNAME",
help="""
A Crunchyroll username to allow access to restricted streams.
"""
)
plugin.add_argument(
"--crunchyroll-password",
metavar="PASSWORD",
nargs="?",
const=True,
default=None,
help="""
A Crunchyroll password for use with --crunchyroll-username.
If left blank you will be prompted.
"""
)
plugin.add_argument(
"--crunchyroll-purge-credentials",
action="store_true",
help="""
Purge cached Crunchyroll credentials to initiate a new session
and reauthenticate.
"""
)
plugin.add_argument(
"--livestation-email",
metavar="EMAIL",
help="""
A Livestation account email to access restricted or premium
quality streams.
"""
)
plugin.add_argument(
"--livestation-password",
metavar="PASSWORD",
help="""
A Livestation account password to use with --livestation-email.
"""
)
# Deprecated options
stream.add_argument(
"--best-stream-default",
action="store_true",
help=argparse.SUPPRESS
)
player.add_argument(
"-q", "--quiet-player",
action="store_true",
help=argparse.SUPPRESS
)
transport.add_argument(
"--hds-fragment-buffer",
type=int,
metavar="fragments",
help=argparse.SUPPRESS
)
plugin.add_argument(
"--jtv-legacy-names", "--twitch-legacy-names",
action="store_true",
help=argparse.SUPPRESS
)
plugin.add_argument(
"--gomtv-cookie",
metavar="cookie",
help=argparse.SUPPRESS
)
plugin.add_argument(
"--gomtv-username",
metavar="username",
help=argparse.SUPPRESS
)
plugin.add_argument(
"--gomtv-password",
metavar="password",
nargs="?",
const=True,
default=None,
help=argparse.SUPPRESS
)
plugin.add_argument(
"--jtv-cookie",
help=argparse.SUPPRESS
)
plugin.add_argument(
"--jtv-password", "--twitch-password",
help=argparse.SUPPRESS
)
http.add_argument(
"--http-cookies",
metavar="COOKIES",
help=argparse.SUPPRESS
)
http.add_argument(
"--http-headers",
metavar="HEADERS",
help=argparse.SUPPRESS
)
http.add_argument(
"--http-query-params",
metavar="PARAMS",
help=argparse.SUPPRESS
)
__all__ = ["parser"]
livestreamer-1.12.2/src/livestreamer_cli/__init__.py 0000644 0001750 0001750 00000000000 12521217321 023610 0 ustar chrippa chrippa 0000000 0000000 livestreamer-1.12.2/src/livestreamer_cli/utils/ 0000755 0001750 0001750 00000000000 12521217500 022650 5 ustar chrippa chrippa 0000000 0000000 livestreamer-1.12.2/src/livestreamer_cli/utils/stream.py 0000644 0001750 0001750 00000002032 12521217321 024513 0 ustar chrippa chrippa 0000000 0000000 def stream_to_url(stream):
stream_type = type(stream).shortname()
if stream_type in ("hls", "http"):
url = stream.url
elif stream_type == "rtmp":
params = [stream.params.pop("rtmp", "")]
stream_params = dict(stream.params)
if "swfVfy" in stream.params:
stream_params["swfUrl"] = stream.params["swfVfy"]
stream_params["swfVfy"] = True
if "swfhash" in stream.params:
stream_params["swfVfy"] = True
stream_params.pop("swfhash", None)
stream_params.pop("swfsize", None)
for key, value in stream_params.items():
if isinstance(value, bool):
value = str(int(value))
# librtmp expects some characters to be escaped
value = value.replace("\\", "\\5c")
value = value.replace(" ", "\\20")
value = value.replace('"', "\\22")
params.append("{0}={1}".format(key, value))
url = " ".join(params)
else:
url = None
return url
livestreamer-1.12.2/src/livestreamer_cli/utils/progress.py 0000644 0001750 0001750 00000006523 12521217321 025075 0 ustar chrippa chrippa 0000000 0000000 import sys
from collections import deque
from time import time
from ..compat import is_win32, get_terminal_size
PROGRESS_FORMATS = (
"[download][{prefix}] Written {written} ({elapsed} @ {speed}/s)",
"[download] Written {written} ({elapsed} @ {speed}/s)",
"[download] {written} ({elapsed} @ {speed}/s)",
"[download] {written} ({elapsed})",
"[download] {written}"
)
def terminal_len(value):
"""Returns the length of the string it would be when displayed.
Attempts to decode the string as UTF-8 first if it's a bytestring.
"""
if isinstance(value, bytes):
value = value.decode("utf8", "ignore")
return len(value)
def print_inplace(msg):
"""Clears out the previous line and prints a new one."""
term_width = get_terminal_size().columns
spacing = term_width - terminal_len(msg)
# On windows we need one less space or we overflow the line for some reason.
if is_win32:
spacing -= 1
sys.stderr.write("\r{0}".format(msg))
sys.stderr.write(" " * max(0, spacing))
sys.stderr.flush()
def format_filesize(size):
"""Formats the file size into a human readable format."""
for suffix in ("bytes", "KB", "MB", "GB", "TB"):
if size < 1024.0:
if suffix in ("GB", "TB"):
return "{0:3.2f} {1}".format(size, suffix)
else:
return "{0:3.1f} {1}".format(size, suffix)
size /= 1024.0
def format_time(elapsed):
"""Formats elapsed seconds into a human readable format."""
hours = int(elapsed / (60 * 60))
minutes = int((elapsed % (60 * 60)) / 60)
seconds = int(elapsed % 60)
rval = ""
if hours:
rval += "{0}h".format(hours)
if elapsed > 60:
rval += "{0}m".format(minutes)
rval += "{0}s".format(seconds)
return rval
def create_status_line(**params):
"""Creates a status line with appropriate size."""
max_size = get_terminal_size().columns - 1
for fmt in PROGRESS_FORMATS:
status = fmt.format(**params)
if len(status) <= max_size:
break
return status
def progress(iterator, prefix):
"""Progress an iterator and updates a pretty status line to the terminal.
The status line contains:
- Amount of data read from the iterator
- Time elapsed
- Average speed, based on the last few seconds.
"""
prefix = (".." + prefix[-23:]) if len(prefix) > 25 else prefix
speed_updated = start = time()
speed_written = written = 0
speed_history = deque(maxlen=5)
for data in iterator:
yield data
now = time()
elapsed = now - start
written += len(data)
speed_elapsed = now - speed_updated
if speed_elapsed >= 0.5:
speed_history.appendleft((
written - speed_written,
speed_updated,
))
speed_updated = now
speed_written = written
speed_history_written = sum(h[0] for h in speed_history)
speed_history_elapsed = now - speed_history[-1][1]
speed = speed_history_written / speed_history_elapsed
status = create_status_line(
prefix=prefix,
written=format_filesize(written),
elapsed=format_time(elapsed),
speed=format_filesize(speed)
)
print_inplace(status)
livestreamer-1.12.2/src/livestreamer_cli/utils/player.py 0000644 0001750 0001750 00000002334 12521217321 024521 0 ustar chrippa chrippa 0000000 0000000 import os
import sys
from ..compat import shlex_quote
def check_paths(exes, paths):
for path in paths:
for exe in exes:
path = os.path.expanduser(os.path.join(path, exe))
if os.path.isfile(path):
return path
def find_default_player():
if "darwin" in sys.platform:
paths = os.environ.get("PATH", "").split(":")
paths += ["/Applications/VLC.app/Contents/MacOS/"]
paths += ["~/Applications/VLC.app/Contents/MacOS/"]
path = check_paths(("VLC", "vlc"), paths)
elif "win32" in sys.platform:
exename = "vlc.exe"
paths = os.environ.get("PATH", "").split(";")
path = check_paths((exename,), paths)
if not path:
subpath = "VideoLAN\\VLC\\"
envvars = ("PROGRAMFILES", "PROGRAMFILES(X86)", "PROGRAMW6432")
paths = filter(None, (os.environ.get(var) for var in envvars))
paths = (os.path.join(p, subpath) for p in paths)
path = check_paths((exename,), paths)
else:
paths = os.environ.get("PATH", "").split(":")
path = check_paths(("vlc",), paths)
if path:
# Quote command because it can contain space
return shlex_quote(path)
livestreamer-1.12.2/src/livestreamer_cli/utils/named_pipe.py 0000644 0001750 0001750 00000004175 12521217321 025333 0 ustar chrippa chrippa 0000000 0000000 import os
import tempfile
from ..compat import is_win32, is_py3
if is_win32:
from ctypes import windll, cast, c_ulong, c_void_p, byref
PIPE_ACCESS_OUTBOUND = 0x00000002
PIPE_TYPE_BYTE = 0x00000000
PIPE_READMODE_BYTE = 0x00000000
PIPE_WAIT = 0x00000000
PIPE_UNLIMITED_INSTANCES = 255
INVALID_HANDLE_VALUE = -1
class NamedPipe(object):
def __init__(self, name):
self.fifo = None
self.pipe = None
if is_win32:
self.path = os.path.join("\\\\.\\pipe", name)
self.pipe = self._create_named_pipe(self.path)
else:
self.path = os.path.join(tempfile.gettempdir(), name)
self._create_fifo(self.path)
def _create_fifo(self, name):
os.mkfifo(name, 0o660)
def _create_named_pipe(self, path):
bufsize = 8192
if is_py3:
create_named_pipe = windll.kernel32.CreateNamedPipeW
else:
create_named_pipe = windll.kernel32.CreateNamedPipeA
pipe = create_named_pipe(path, PIPE_ACCESS_OUTBOUND,
PIPE_TYPE_BYTE | PIPE_READMODE_BYTE | PIPE_WAIT,
PIPE_UNLIMITED_INSTANCES,
bufsize, bufsize,
0, None)
if pipe == INVALID_HANDLE_VALUE:
error_code = windll.kernel32.GetLastError()
raise IOError("Error code 0x{0:08X}".format(error_code))
return pipe
def open(self, mode):
if not self.pipe:
self.fifo = open(self.path, mode)
def write(self, data):
if self.pipe:
windll.kernel32.ConnectNamedPipe(self.pipe, None)
written = c_ulong(0)
windll.kernel32.WriteFile(self.pipe, cast(data, c_void_p),
len(data), byref(written),
None)
return written
else:
return self.fifo.write(data)
def close(self):
if self.pipe:
windll.kernel32.DisconnectNamedPipe(self.pipe)
else:
self.fifo.close()
os.unlink(self.path)
livestreamer-1.12.2/src/livestreamer_cli/utils/http_server.py 0000644 0001750 0001750 00000005661 12521217321 025600 0 ustar chrippa chrippa 0000000 0000000 import socket
from io import BytesIO
try:
from BaseHTTPServer import BaseHTTPRequestHandler
except ImportError:
from http.server import BaseHTTPRequestHandler
class HTTPRequest(BaseHTTPRequestHandler):
def __init__(self, request_text):
self.rfile = BytesIO(request_text)
self.raw_requestline = self.rfile.readline()
self.error_code = self.error_message = None
self.parse_request()
def send_error(self, code, message):
self.error_code = code
self.error_message = message
class HTTPServer(object):
def __init__(self):
self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.conn = self.host = self.port = None
self.bound = False
@property
def addresses(self):
if self.host:
return [self.host]
addrs = set()
try:
for info in socket.getaddrinfo(socket.gethostname(), self.port,
socket.AF_INET):
addrs.add(info[4][0])
except socket.gaierror:
pass
addrs.add("127.0.0.1")
return sorted(addrs)
@property
def urls(self):
for addr in self.addresses:
yield "http://{0}:{1}/".format(addr, self.port)
@property
def url(self):
return next(self.urls, None)
def bind(self, host="127.0.0.1", port=0):
try:
self.socket.bind((host or "", port))
except socket.error as err:
raise OSError(err)
self.socket.listen(1)
self.bound = True
self.host, self.port = self.socket.getsockname()
if self.host == "0.0.0.0":
self.host = None
def open(self, timeout=30):
self.socket.settimeout(timeout)
try:
conn, addr = self.socket.accept()
conn.settimeout(None)
except socket.timeout:
raise OSError("Socket accept timed out")
try:
req_data = conn.recv(1024)
except socket.error:
raise OSError("Failed to read data from socket")
req = HTTPRequest(req_data)
if req.command not in ("GET", "HEAD"):
conn.send(b"HTTP/1.1 501 Not Implemented\r\n")
conn.close()
raise OSError("Invalid request method: {0}".format(req.command))
conn.send(b"HTTP/1.1 200 OK\r\n")
conn.send(b"Server: Livestreamer\r\n")
conn.send(b"Content-Type: video/unknown\r\n")
conn.send(b"\r\n")
# We don't want to send any data on HEAD requests.
if req.command == "HEAD":
conn.close()
raise OSError
self.conn = conn
return req
def write(self, data):
if not self.conn:
raise IOError("No connection")
self.conn.sendall(data)
def close(self, client_only=False):
if self.conn:
self.conn.close()
if not client_only:
self.socket.close()
livestreamer-1.12.2/src/livestreamer_cli/utils/__init__.py 0000644 0001750 0001750 00000001361 12521217321 024763 0 ustar chrippa chrippa 0000000 0000000 import json
from contextlib import contextmanager
from .http_server import HTTPServer
from .named_pipe import NamedPipe
from .progress import progress
from .player import find_default_player
from .stream import stream_to_url
__all__ = [
"NamedPipe", "HTTPServer", "JSONEncoder",
"find_default_player", "ignored", "progress", "stream_to_url"
]
class JSONEncoder(json.JSONEncoder):
def default(self, obj):
if hasattr(obj, "__json__"):
return obj.__json__()
elif isinstance(obj, bytes):
return obj.decode("utf8", "ignore")
else:
return json.JSONEncoder.default(self, obj)
@contextmanager
def ignored(*exceptions):
try:
yield
except exceptions:
pass
livestreamer-1.12.2/src/livestreamer_cli/packages/ 0000755 0001750 0001750 00000000000 12521217500 023266 5 ustar chrippa chrippa 0000000 0000000 livestreamer-1.12.2/src/livestreamer_cli/packages/shutil_backport.py 0000644 0001750 0001750 00000005420 12521217321 027037 0 ustar chrippa chrippa 0000000 0000000 """This is a backport of shutil.get_terminal_size from Python 3.
The original implementation is in C, but here we use the ctypes and
fcntl modules to create a pure Python version of os.get_terminal_size.
"""
import os
import struct
import sys
from collections import namedtuple
terminal_size = namedtuple("terminal_size", "columns lines")
try:
from ctypes import windll, create_string_buffer
_handles = {
0: windll.kernel32.GetStdHandle(-10),
1: windll.kernel32.GetStdHandle(-11),
2: windll.kernel32.GetStdHandle(-12),
}
def _get_terminal_size(fd):
columns = lines = 0
try:
handle = _handles[fd]
csbi = create_string_buffer(22)
res = windll.kernel32.GetConsoleScreenBufferInfo(handle, csbi)
if res:
res = struct.unpack("hhhhHhhhhhh", csbi.raw)
left, top, right, bottom = res[5:9]
columns = right - left + 1
lines = bottom - top + 1
except Exception:
pass
return columns, lines
except ImportError:
import fcntl
import termios
def _get_terminal_size(fd):
try:
res = fcntl.ioctl(fd, termios.TIOCGWINSZ, b"\x00" * 4)
lines, columns = struct.unpack("hh", res)
except Exception:
columns = lines = 0
return columns, lines
def get_terminal_size(fallback=(80, 24)):
"""Get the size of the terminal window.
For each of the two dimensions, the environment variable, COLUMNS
and LINES respectively, is checked. If the variable is defined and
the value is a positive integer, it is used.
When COLUMNS or LINES is not defined, which is the common case,
the terminal connected to sys.__stdout__ is queried
by invoking os.get_terminal_size.
If the terminal size cannot be successfully queried, either because
the system doesn't support querying, or because we are not
connected to a terminal, the value given in fallback parameter
is used. Fallback defaults to (80, 24) which is the default
size used by many terminal emulators.
The value returned is a named tuple of type os.terminal_size.
"""
# Attempt to use the environment first
try:
columns = int(os.environ["COLUMNS"])
except (KeyError, ValueError):
columns = 0
try:
lines = int(os.environ["LINES"])
except (KeyError, ValueError):
lines = 0
# Only query if necessary
if columns <= 0 or lines <= 0:
try:
columns, lines = _get_terminal_size(sys.__stdout__.fileno())
except (NameError, OSError):
pass
# Use fallback as last resort
if columns <= 0 and lines <= 0:
columns, lines = fallback
return terminal_size(columns, lines)
livestreamer-1.12.2/src/livestreamer_cli/packages/__init__.py 0000644 0001750 0001750 00000000000 12521217321 025366 0 ustar chrippa chrippa 0000000 0000000 livestreamer-1.12.2/src/livestreamer.egg-info/ 0000755 0001750 0001750 00000000000 12521217500 022353 5 ustar chrippa chrippa 0000000 0000000 livestreamer-1.12.2/src/livestreamer.egg-info/top_level.txt 0000644 0001750 0001750 00000000036 12521217500 025104 0 ustar chrippa chrippa 0000000 0000000 livestreamer
livestreamer_cli
livestreamer-1.12.2/src/livestreamer.egg-info/requires.txt 0000644 0001750 0001750 00000000023 12521217500 024746 0 ustar chrippa chrippa 0000000 0000000 requests>=1.0,<3.0
livestreamer-1.12.2/src/livestreamer.egg-info/entry_points.txt 0000644 0001750 0001750 00000000075 12521217500 025653 0 ustar chrippa chrippa 0000000 0000000 [console_scripts]
livestreamer = livestreamer_cli.main:main
livestreamer-1.12.2/src/livestreamer.egg-info/dependency_links.txt 0000644 0001750 0001750 00000000001 12521217500 026421 0 ustar chrippa chrippa 0000000 0000000
livestreamer-1.12.2/src/livestreamer.egg-info/SOURCES.txt 0000644 0001750 0001750 00000015600 12521217500 024241 0 ustar chrippa chrippa 0000000 0000000 CHANGELOG.rst
CONTRIBUTING.rst
LICENSE
LICENSE.flashmedia
LICENSE.pbs
MANIFEST.in
README.rst
requirements-docs.txt
setup.cfg
setup.py
docs/Makefile
docs/api.rst
docs/api_guide.rst
docs/changelog.rst
docs/cli.rst
docs/conf.py
docs/ext_argparse.py
docs/ext_github.py
docs/ext_releaseref.py
docs/index.rst
docs/install.rst
docs/issues.rst
docs/players.rst
docs/plugin_matrix.rst
docs/twitch_oauth.rst
docs/_static/flattr-badge.png
docs/_themes/.gitignore
docs/_themes/sphinx_rtd_theme_violet/LICENSE
docs/_themes/sphinx_rtd_theme_violet/__init__.py
docs/_themes/sphinx_rtd_theme_violet/breadcrumbs.html
docs/_themes/sphinx_rtd_theme_violet/footer.html
docs/_themes/sphinx_rtd_theme_violet/layout.html
docs/_themes/sphinx_rtd_theme_violet/layout_old.html
docs/_themes/sphinx_rtd_theme_violet/search.html
docs/_themes/sphinx_rtd_theme_violet/searchbox.html
docs/_themes/sphinx_rtd_theme_violet/theme.conf
docs/_themes/sphinx_rtd_theme_violet/versions.html
docs/_themes/sphinx_rtd_theme_violet/static/css/badge_only.css
docs/_themes/sphinx_rtd_theme_violet/static/css/theme.css
docs/_themes/sphinx_rtd_theme_violet/static/fonts/FontAwesome.otf
docs/_themes/sphinx_rtd_theme_violet/static/fonts/fontawesome-webfont.eot
docs/_themes/sphinx_rtd_theme_violet/static/fonts/fontawesome-webfont.svg
docs/_themes/sphinx_rtd_theme_violet/static/fonts/fontawesome-webfont.ttf
docs/_themes/sphinx_rtd_theme_violet/static/fonts/fontawesome-webfont.woff
docs/_themes/sphinx_rtd_theme_violet/static/js/scrollspy.js
docs/_themes/sphinx_rtd_theme_violet/static/js/theme.js
examples/gst-player.py
src/livestreamer/__init__.py
src/livestreamer/api.py
src/livestreamer/buffers.py
src/livestreamer/cache.py
src/livestreamer/compat.py
src/livestreamer/exceptions.py
src/livestreamer/logger.py
src/livestreamer/options.py
src/livestreamer/session.py
src/livestreamer/utils.py
src/livestreamer.egg-info/PKG-INFO
src/livestreamer.egg-info/SOURCES.txt
src/livestreamer.egg-info/dependency_links.txt
src/livestreamer.egg-info/entry_points.txt
src/livestreamer.egg-info/requires.txt
src/livestreamer.egg-info/top_level.txt
src/livestreamer/packages/__init__.py
src/livestreamer/packages/pbs.py
src/livestreamer/packages/flashmedia/__init__.py
src/livestreamer/packages/flashmedia/amf.py
src/livestreamer/packages/flashmedia/box.py
src/livestreamer/packages/flashmedia/compat.py
src/livestreamer/packages/flashmedia/error.py
src/livestreamer/packages/flashmedia/f4v.py
src/livestreamer/packages/flashmedia/flv.py
src/livestreamer/packages/flashmedia/ordereddict.py
src/livestreamer/packages/flashmedia/packet.py
src/livestreamer/packages/flashmedia/tag.py
src/livestreamer/packages/flashmedia/types.py
src/livestreamer/packages/flashmedia/util.py
src/livestreamer/plugin/__init__.py
src/livestreamer/plugin/plugin.py
src/livestreamer/plugin/api/__init__.py
src/livestreamer/plugin/api/http_session.py
src/livestreamer/plugin/api/mapper.py
src/livestreamer/plugin/api/support_plugin.py
src/livestreamer/plugin/api/utils.py
src/livestreamer/plugin/api/validate.py
src/livestreamer/plugins/__init__.py
src/livestreamer/plugins/afreeca.py
src/livestreamer/plugins/afreecatv.py
src/livestreamer/plugins/aftonbladet.py
src/livestreamer/plugins/alieztv.py
src/livestreamer/plugins/ard_live.py
src/livestreamer/plugins/ard_mediathek.py
src/livestreamer/plugins/artetv.py
src/livestreamer/plugins/azubutv.py
src/livestreamer/plugins/bambuser.py
src/livestreamer/plugins/beattv.py
src/livestreamer/plugins/chaturbate.py
src/livestreamer/plugins/common_jwplayer.py
src/livestreamer/plugins/common_swf.py
src/livestreamer/plugins/connectcast.py
src/livestreamer/plugins/crunchyroll.py
src/livestreamer/plugins/cybergame.py
src/livestreamer/plugins/dailymotion.py
src/livestreamer/plugins/disney_de.py
src/livestreamer/plugins/dmcloud.py
src/livestreamer/plugins/dmcloud_embed.py
src/livestreamer/plugins/dommune.py
src/livestreamer/plugins/douyutv.py
src/livestreamer/plugins/drdk.py
src/livestreamer/plugins/euronews.py
src/livestreamer/plugins/filmon.py
src/livestreamer/plugins/filmon_us.py
src/livestreamer/plugins/furstream.py
src/livestreamer/plugins/gaminglive.py
src/livestreamer/plugins/gomexp.py
src/livestreamer/plugins/goodgame.py
src/livestreamer/plugins/hitbox.py
src/livestreamer/plugins/itvplayer.py
src/livestreamer/plugins/letontv.py
src/livestreamer/plugins/livestation.py
src/livestreamer/plugins/livestream.py
src/livestreamer/plugins/media_ccc_de.py
src/livestreamer/plugins/mips.py
src/livestreamer/plugins/mlgtv.py
src/livestreamer/plugins/nhkworld.py
src/livestreamer/plugins/nos.py
src/livestreamer/plugins/npo.py
src/livestreamer/plugins/nrk.py
src/livestreamer/plugins/oldlivestream.py
src/livestreamer/plugins/periscope.py
src/livestreamer/plugins/picarto.py
src/livestreamer/plugins/rtve.py
src/livestreamer/plugins/sbsdiscovery.py
src/livestreamer/plugins/seemeplay.py
src/livestreamer/plugins/speedrunslive.py
src/livestreamer/plugins/ssh101.py
src/livestreamer/plugins/stream.py
src/livestreamer/plugins/streamingvideoprovider.py
src/livestreamer/plugins/streamlive.py
src/livestreamer/plugins/svtplay.py
src/livestreamer/plugins/tga.py
src/livestreamer/plugins/tv3cat.py
src/livestreamer/plugins/tv4play.py
src/livestreamer/plugins/tvcatchup.py
src/livestreamer/plugins/tvplayer.py
src/livestreamer/plugins/twitch.py
src/livestreamer/plugins/ustreamtv.py
src/livestreamer/plugins/vaughnlive.py
src/livestreamer/plugins/veetle.py
src/livestreamer/plugins/vgtv.py
src/livestreamer/plugins/viagame.py
src/livestreamer/plugins/viasat.py
src/livestreamer/plugins/viasat_embed.py
src/livestreamer/plugins/wattv.py
src/livestreamer/plugins/weeb.py
src/livestreamer/plugins/youtube.py
src/livestreamer/plugins/zdf_mediathek.py
src/livestreamer/stream/__init__.py
src/livestreamer/stream/akamaihd.py
src/livestreamer/stream/flvconcat.py
src/livestreamer/stream/hds.py
src/livestreamer/stream/hls.py
src/livestreamer/stream/hls_playlist.py
src/livestreamer/stream/http.py
src/livestreamer/stream/playlist.py
src/livestreamer/stream/rtmpdump.py
src/livestreamer/stream/segmented.py
src/livestreamer/stream/stream.py
src/livestreamer/stream/streamprocess.py
src/livestreamer/stream/wrappers.py
src/livestreamer_cli/__init__.py
src/livestreamer_cli/argparser.py
src/livestreamer_cli/compat.py
src/livestreamer_cli/console.py
src/livestreamer_cli/constants.py
src/livestreamer_cli/main.py
src/livestreamer_cli/output.py
src/livestreamer_cli/packages/__init__.py
src/livestreamer_cli/packages/shutil_backport.py
src/livestreamer_cli/utils/__init__.py
src/livestreamer_cli/utils/http_server.py
src/livestreamer_cli/utils/named_pipe.py
src/livestreamer_cli/utils/player.py
src/livestreamer_cli/utils/progress.py
src/livestreamer_cli/utils/stream.py
tests/__init__.py
tests/test_buffer.py
tests/test_log.py
tests/test_options.py
tests/test_plugin_api_http_session.py
tests/test_plugin_api_validate.py
tests/test_plugin_stream.py
tests/test_session.py
tests/test_stream_wrappers.py
tests/plugins/__init__.py
tests/plugins/testplugin.py
tests/plugins/testplugin_support.py livestreamer-1.12.2/src/livestreamer.egg-info/PKG-INFO 0000644 0001750 0001750 00000001575 12521217500 023460 0 ustar chrippa chrippa 0000000 0000000 Metadata-Version: 1.1
Name: livestreamer
Version: 1.12.2
Summary: Livestreamer is command-line utility that extracts streams from various services and pipes them into a video player of choice.
Home-page: http://livestreamer.io/
Author: Christopher Rosell
Author-email: chrippa@tanuki.se
License: Simplified BSD
Description: UNKNOWN
Platform: UNKNOWN
Classifier: Development Status :: 5 - Production/Stable
Classifier: Environment :: Console
Classifier: Operating System :: POSIX
Classifier: Operating System :: Microsoft :: Windows
Classifier: Programming Language :: Python :: 2.6
Classifier: Programming Language :: Python :: 2.7
Classifier: Programming Language :: Python :: 3.3
Classifier: Programming Language :: Python :: 3.4
Classifier: Topic :: Internet :: WWW/HTTP
Classifier: Topic :: Multimedia :: Sound/Audio
Classifier: Topic :: Multimedia :: Video
Classifier: Topic :: Utilities
livestreamer-1.12.2/src/livestreamer/ 0000755 0001750 0001750 00000000000 12521217500 020661 5 ustar chrippa chrippa 0000000 0000000 livestreamer-1.12.2/src/livestreamer/utils.py 0000644 0001750 0001750 00000013600 12521217321 022374 0 ustar chrippa chrippa 0000000 0000000 import json
import re
import zlib
try:
import xml.etree.cElementTree as ET
except ImportError:
import xml.etree.ElementTree as ET
from .compat import urljoin, urlparse, parse_qsl, is_py2
from .exceptions import PluginError
def swfdecompress(data):
if data[:3] == b"CWS":
data = b"F" + data[1:8] + zlib.decompress(data[8:])
return data
def verifyjson(json, key):
if not isinstance(json, dict):
raise PluginError("JSON result is not a dict")
if not key in json:
raise PluginError("Missing '{0}' key in JSON".format(key))
return json[key]
def absolute_url(baseurl, url):
if not url.startswith("http"):
return urljoin(baseurl, url)
else:
return url
def prepend_www(url):
"""Changes google.com to www.google.com"""
parsed = urlparse(url)
if parsed.netloc.split(".")[0] != "www":
return parsed.scheme + "://www." + parsed.netloc + parsed.path
else:
return url
def parse_json(data, name="JSON", exception=PluginError, schema=None):
"""Wrapper around json.loads.
Wraps errors in custom exception with a snippet of the data in the message.
"""
try:
json_data = json.loads(data)
except ValueError as err:
snippet = repr(data)
if len(snippet) > 35:
snippet = snippet[:35] + " ..."
else:
snippet = data
raise exception("Unable to parse {0}: {1} ({2})".format(name, err, snippet))
if schema:
json_data = schema.validate(json_data, name=name, exception=exception)
return json_data
def parse_xml(data, name="XML", ignore_ns=False, exception=PluginError, schema=None):
"""Wrapper around ElementTree.fromstring with some extras.
Provides these extra features:
- Handles incorrectly encoded XML
- Allows stripping namespace information
- Wraps errors in custom exception with a snippet of the data in the message
"""
if is_py2 and isinstance(data, unicode):
data = data.encode("utf8")
if ignore_ns:
data = re.sub(" xmlns=\"(.+?)\"", "", data)
try:
tree = ET.fromstring(data)
except Exception as err:
snippet = repr(data)
if len(snippet) > 35:
snippet = snippet[:35] + " ..."
raise exception("Unable to parse {0}: {1} ({2})".format(name, err, snippet))
if schema:
tree = schema.validate(tree, name=name, exception=exception)
return tree
def parse_qsd(data, name="query string", exception=PluginError, schema=None, **params):
"""Parses a query string into a dict.
Unlike parse_qs and parse_qsl, duplicate keys are not preserved in
favor of a simpler return value.
"""
value = dict(parse_qsl(data, **params))
if schema:
value = schema.validate(value, name=name, exception=exception)
return value
def rtmpparse(url):
parse = urlparse(url)
netloc = "{hostname}:{port}".format(hostname=parse.hostname,
port=parse.port or 1935)
split = list(filter(None, parse.path.split("/")))
if len(split) > 2:
app = "/".join(split[:2])
playpath = "/".join(split[2:])
elif len(split) == 2:
app, playpath = split
else:
app = split[0]
if len(parse.query) > 0:
playpath += "?{parse.query}".format(parse=parse)
tcurl = "{scheme}://{netloc}/{app}".format(scheme=parse.scheme,
netloc=netloc,
app=app)
return (tcurl, playpath)
#####################################
# Deprecated functions, do not use. #
#####################################
import requests
def urlget(url, *args, **kwargs):
"""This function is deprecated."""
data = kwargs.pop("data", None)
exception = kwargs.pop("exception", PluginError)
method = kwargs.pop("method", "GET")
session = kwargs.pop("session", None)
timeout = kwargs.pop("timeout", 20)
if data is not None:
method = "POST"
try:
if session:
res = session.request(method, url, timeout=timeout, data=data,
*args, **kwargs)
else:
res = requests.request(method, url, timeout=timeout, data=data,
*args, **kwargs)
res.raise_for_status()
except (requests.exceptions.RequestException, IOError) as rerr:
err = exception("Unable to open URL: {url} ({err})".format(url=url,
err=rerr))
err.err = rerr
raise err
return res
urlopen = urlget
def urlresolve(url):
"""This function is deprecated."""
res = urlget(url, stream=True, allow_redirects=False)
if res.status_code == 302 and "location" in res.headers:
return res.headers["location"]
else:
return url
def res_xml(res, *args, **kw):
"""This function is deprecated."""
return parse_xml(res.text, *args, **kw)
def res_json(res, jsontype="JSON", exception=PluginError):
"""This function is deprecated."""
try:
jsondata = res.json()
except ValueError as err:
if len(res.text) > 35:
snippet = res.text[:35] + "..."
else:
snippet = res.text
raise exception("Unable to parse {0}: {1} ({2})".format(jsontype, err,
snippet))
return jsondata
import hmac
import hashlib
SWF_KEY = b"Genuine Adobe Flash Player 001"
def swfverify(url):
"""This function is deprecated."""
res = urlopen(url)
swf = swfdecompress(res.content)
h = hmac.new(SWF_KEY, swf, hashlib.sha256)
return h.hexdigest(), len(swf)
__all__ = ["urlopen", "urlget", "urlresolve", "swfdecompress", "swfverify",
"verifyjson", "absolute_url", "parse_qsd", "parse_json", "res_json",
"parse_xml", "res_xml", "rtmpparse", "prepend_www"]
livestreamer-1.12.2/src/livestreamer/session.py 0000644 0001750 0001750 00000033220 12521217321 022717 0 ustar chrippa chrippa 0000000 0000000 import imp
import pkgutil
import re
import sys
import traceback
from . import plugins, __version__
from .compat import urlparse, is_win32
from .exceptions import NoPluginError, PluginError
from .logger import Logger
from .options import Options
from .plugin import api
def print_small_exception(start_after):
type, value, traceback_ = sys.exc_info()
tb = traceback.extract_tb(traceback_)
index = 0
for i, trace in enumerate(tb):
if trace[2] == start_after:
index = i+1
break
lines = traceback.format_list(tb[index:])
lines += traceback.format_exception_only(type, value)
for line in lines:
sys.stderr.write(line)
sys.stderr.write("\n")
class Livestreamer(object):
"""A Livestreamer session is used to keep track of plugins,
options and log settings."""
def __init__(self):
self.http = api.HTTPSession()
self.options = Options({
"hds-live-edge": 10.0,
"hds-segment-attempts": 3,
"hds-segment-threads": 1,
"hds-segment-timeout": 10.0,
"hds-timeout": 60.0,
"hls-live-edge": 3,
"hls-segment-attempts": 3,
"hls-segment-threads": 1,
"hls-segment-timeout": 10.0,
"hls-timeout": 60.0,
"http-stream-timeout": 60.0,
"ringbuffer-size": 1024 * 1024 * 16, # 16 MB
"rtmp-timeout": 60.0,
"rtmp-rtmpdump": is_win32 and "rtmpdump.exe" or "rtmpdump",
"rtmp-proxy": None,
"stream-segment-attempts": 3,
"stream-segment-threads": 1,
"stream-segment-timeout": 10.0,
"stream-timeout": 60.0,
"subprocess-errorlog": False
})
self.plugins = {}
self.logger = Logger()
self.load_builtin_plugins()
def set_option(self, key, value):
"""Sets general options used by plugins and streams originating
from this session object.
:param key: key of the option
:param value: value to set the option to
**Available options**:
======================= =========================================
hds-live-edge (float) Specify the time live HDS
streams will start from the edge of
stream, default: ``10.0``
hds-segment-attempts (int) How many attempts should be done
to download each HDS segment, default: ``3``
hds-segment-threads (int) The size of the thread pool used
to download segments, default: ``1``
hds-segment-timeout (float) HDS segment connect and read
timeout, default: ``10.0``
hds-timeout (float) Timeout for reading data from
HDS streams, default: ``60.0``
hls-live-edge (int) How many segments from the end
to start live streams on, default: ``3``
hls-segment-attempts (int) How many attempts should be done
to download each HLS segment, default: ``3``
hls-segment-threads (int) The size of the thread pool used
to download segments, default: ``1``
hls-segment-timeout (float) HLS segment connect and read
timeout, default: ``10.0``
hls-timeout (float) Timeout for reading data from
HLS streams, default: ``60.0``
http-proxy (str) Specify a HTTP proxy to use for
all HTTP requests
https-proxy (str) Specify a HTTPS proxy to use for
all HTTPS requests
http-cookies (dict or str) A dict or a semi-colon (;)
delimited str of cookies to add to each
HTTP request, e.g. ``foo=bar;baz=qux``
http-headers (dict or str) A dict or semi-colon (;)
delimited str of headers to add to each
HTTP request, e.g. ``foo=bar;baz=qux``
http-query-params (dict or str) A dict or a ampersand (&)
delimited string of query parameters to
add to each HTTP request,
e.g. ``foo=bar&baz=qux``
http-trust-env (bool) Trust HTTP settings set in the
environment, such as environment
variables (HTTP_PROXY, etc) and
~/.netrc authentication
http-ssl-verify (bool) Verify SSL certificates,
default: ``True``
http-ssl-cert (str or tuple) SSL certificate to use,
can be either a .pem file (str) or a
.crt/.key pair (tuple)
http-timeout (float) General timeout used by all HTTP
requests except the ones covered by
other options, default: ``20.0``
http-stream-timeout (float) Timeout for reading data from
HTTP streams, default: ``60.0``
subprocess-errorlog (bool) Log errors from subprocesses to
a file located in the temp directory
ringbuffer-size (int) The size of the internal ring
buffer used by most stream types,
default: ``16777216`` (16MB)
rtmp-proxy (str) Specify a proxy (SOCKS) that RTMP
streams will use
rtmp-rtmpdump (str) Specify the location of the
rtmpdump executable used by RTMP streams,
e.g. ``/usr/local/bin/rtmpdump``
rtmp-timeout (float) Timeout for reading data from
RTMP streams, default: ``60.0``
stream-segment-attempts (int) How many attempts should be done
to download each segment, default: ``3``.
General option used by streams not
covered by other options.
stream-segment-threads (int) The size of the thread pool used
to download segments, default: ``1``.
General option used by streams not
covered by other options.
stream-segment-timeout (float) Segment connect and read
timeout, default: ``10.0``.
General option used by streams not
covered by other options.
stream-timeout (float) Timeout for reading data from
stream, default: ``60.0``.
General option used by streams not
covered by other options.
======================= =========================================
"""
# Backwards compatibility
if key == "rtmpdump":
key = "rtmp-rtmpdump"
elif key == "rtmpdump-proxy":
key = "rtmp-proxy"
elif key == "errorlog":
key = "subprocess-errorlog"
if key == "http-proxy":
if not re.match("^http(s)?://", value):
value = "http://" + value
self.http.proxies["http"] = value
elif key == "https-proxy":
if not re.match("^http(s)?://", value):
value = "https://" + value
self.http.proxies["https"] = value
elif key == "http-cookies":
if isinstance(value, dict):
self.http.cookies.update(value)
else:
self.http.parse_cookies(value)
elif key == "http-headers":
if isinstance(value, dict):
self.http.headers.update(value)
else:
self.http.parse_headers(value)
elif key == "http-query-params":
if isinstance(value, dict):
self.http.params.update(value)
else:
self.http.parse_query_params(value)
elif key == "http-trust-env":
self.http.trust_env = value
elif key == "http-ssl-verify":
self.http.verify = value
elif key == "http-ssl-cert":
self.http.cert = value
elif key == "http-timeout":
self.http.timeout = value
else:
self.options.set(key, value)
def get_option(self, key):
"""Returns current value of specified option.
:param key: key of the option
"""
# Backwards compatibility
if key == "rtmpdump":
key = "rtmp-rtmpdump"
elif key == "rtmpdump-proxy":
key = "rtmp-proxy"
elif key == "errorlog":
key = "subprocess-errorlog"
if key == "http-proxy":
return self.http.proxies.get("http")
elif key == "https-proxy":
return self.http.proxies.get("https")
elif key == "http-cookies":
return self.http.cookies
elif key == "http-headers":
return self.http.headers
elif key == "http-query-params":
return self.http.params
elif key == "http-trust-env":
return self.http.trust_env
elif key == "http-ssl-verify":
return self.http.verify
elif key == "http-ssl-cert":
return self.http.cert
elif key == "http-timeout":
return self.http.timeout
else:
return self.options.get(key)
def set_plugin_option(self, plugin, key, value):
"""Sets plugin specific options used by plugins originating
from this session object.
:param plugin: name of the plugin
:param key: key of the option
:param value: value to set the option to
"""
if plugin in self.plugins:
plugin = self.plugins[plugin]
plugin.set_option(key, value)
def get_plugin_option(self, plugin, key):
"""Returns current value of plugin specific option.
:param plugin: name of the plugin
:param key: key of the option
"""
if plugin in self.plugins:
plugin = self.plugins[plugin]
return plugin.get_option(key)
def set_loglevel(self, level):
"""Sets the log level used by this session.
Valid levels are: "none", "error", "warning", "info"
and "debug".
:param level: level of logging to output
"""
self.logger.set_level(level)
def set_logoutput(self, output):
"""Sets the log output used by this session.
:param output: a file-like object with a write method
"""
self.logger.set_output(output)
def resolve_url(self, url):
"""Attempts to find a plugin that can use this URL.
The default protocol (http) will be prefixed to the URL if
not specified.
Raises :exc:`NoPluginError` on failure.
:param url: a URL to match against loaded plugins
"""
parsed = urlparse(url)
if len(parsed.scheme) == 0:
url = "http://" + url
for name, plugin in self.plugins.items():
if plugin.can_handle_url(url):
obj = plugin(url)
return obj
# Attempt to handle a redirect URL
try:
res = self.http.head(url, allow_redirects=True, acceptable_status=[501])
# Fall back to GET request if server doesn't handle HEAD.
if res.status_code == 501:
res = self.http.get(url, stream=True)
if res.url != url:
return self.resolve_url(res.url)
except PluginError:
pass
raise NoPluginError
def streams(self, url, **params):
"""Attempts to find a plugin and extract streams from the *url*.
*params* are passed to :func:`Plugin.streams`.
Raises :exc:`NoPluginError` if no plugin is found.
"""
plugin = self.resolve_url(url)
return plugin.streams(**params)
def get_plugins(self):
"""Returns the loaded plugins for the session."""
return self.plugins
def load_builtin_plugins(self):
self.load_plugins(plugins.__path__[0])
def load_plugins(self, path):
"""Attempt to load plugins from the path specified.
:param path: full path to a directory where to look for plugins
"""
for loader, name, ispkg in pkgutil.iter_modules([path]):
file, pathname, desc = imp.find_module(name, [path])
try:
self.load_plugin(name, file, pathname, desc)
except Exception:
sys.stderr.write("Failed to load plugin {0}:\n".format(name))
print_small_exception("load_plugin")
continue
def load_plugin(self, name, file, pathname, desc):
# Set the global http session for this plugin
api.http = self.http
module = imp.load_module(name, file, pathname, desc)
if hasattr(module, "__plugin__"):
module_name = getattr(module, "__name__")
plugin = getattr(module, "__plugin__")
plugin.bind(self, module_name)
self.plugins[plugin.module] = plugin
if file:
file.close()
@property
def version(self):
return __version__
__all__ = ["Livestreamer"]
livestreamer-1.12.2/src/livestreamer/options.py 0000644 0001750 0001750 00000000561 12521217321 022731 0 ustar chrippa chrippa 0000000 0000000 class Options(object):
def __init__(self, defaults=None):
if not defaults:
defaults = {}
self.defaults = defaults
self.options = defaults.copy()
def set(self, key, value):
self.options[key] = value
def get(self, key):
if key in self.options:
return self.options[key]
__all__ = ["Options"]
livestreamer-1.12.2/src/livestreamer/logger.py 0000644 0001750 0001750 00000003170 12521217321 022514 0 ustar chrippa chrippa 0000000 0000000 import sys
from threading import Lock
class Logger(object):
Levels = ["none", "error", "warning", "info", "debug"]
Format = "[{module}][{level}] {msg}\n"
def __init__(self):
self.output = sys.stdout
self.level = 0
self.lock = Lock()
def new_module(self, module):
return LoggerModule(self, module)
def set_level(self, level):
try:
index = Logger.Levels.index(level)
except ValueError:
return
self.level = index
def set_output(self, output):
self.output = output
def msg(self, module, level, msg, *args, **kwargs):
if self.level < level or level > len(Logger.Levels):
return
msg = msg.format(*args, **kwargs)
with self.lock:
self.output.write(Logger.Format.format(module=module,
level=Logger.Levels[level],
msg=msg))
if hasattr(self.output, "flush"):
self.output.flush()
class LoggerModule(object):
def __init__(self, manager, module):
self.manager = manager
self.module = module
def error(self, msg, *args, **kwargs):
self.manager.msg(self.module, 1, msg, *args, **kwargs)
def warning(self, msg, *args, **kwargs):
self.manager.msg(self.module, 2, msg, *args, **kwargs)
def info(self, msg, *args, **kwargs):
self.manager.msg(self.module, 3, msg, *args, **kwargs)
def debug(self, msg, *args, **kwargs):
self.manager.msg(self.module, 4, msg, *args, **kwargs)
__all__ = ["Logger"]
livestreamer-1.12.2/src/livestreamer/exceptions.py 0000644 0001750 0001750 00000001215 12521217321 023414 0 ustar chrippa chrippa 0000000 0000000 class LivestreamerError(Exception):
"""Any error caused by Livestreamer will be caught
with this exception."""
class PluginError(LivestreamerError):
"""Plugin related error."""
class NoStreamsError(LivestreamerError):
def __init__(self, url):
self.url = url
err = "No streams found on this URL: {0}".format(url)
Exception.__init__(self, err)
class NoPluginError(PluginError):
"""No relevant plugin has been loaded."""
class StreamError(LivestreamerError):
"""Stream related error."""
__all__ = ["LivestreamerError", "PluginError", "NoPluginError",
"NoStreamsError", "StreamError"]
livestreamer-1.12.2/src/livestreamer/compat.py 0000644 0001750 0001750 00000001472 12521217321 022523 0 ustar chrippa chrippa 0000000 0000000 import os
import sys
is_py2 = (sys.version_info[0] == 2)
is_py3 = (sys.version_info[0] == 3)
is_py33 = (sys.version_info[0] == 3 and sys.version_info[1] == 3)
is_win32 = os.name == "nt"
if is_py2:
_str = str
str = unicode
range = xrange
def bytes(b, enc="ascii"):
return _str(b)
elif is_py3:
bytes = bytes
str = str
range = range
try:
from urllib.parse import (
urlparse, urlunparse, urljoin, quote, unquote, parse_qsl
)
import queue
except ImportError:
from urlparse import urlparse, urlunparse, urljoin, parse_qsl
from urllib import quote, unquote
import Queue as queue
__all__ = ["is_py2", "is_py3", "is_py33", "is_win32", "str", "bytes",
"urlparse", "urlunparse", "urljoin", "parse_qsl", "quote",
"unquote", "queue", "range"]
livestreamer-1.12.2/src/livestreamer/cache.py 0000644 0001750 0001750 00000004534 12521217321 022305 0 ustar chrippa chrippa 0000000 0000000 import json
import os
import shutil
import tempfile
from time import time
from .compat import is_win32
if is_win32:
xdg_cache = os.environ.get("APPDATA",
os.path.expanduser("~"))
else:
xdg_cache = os.environ.get("XDG_CACHE_HOME",
os.path.expanduser("~/.cache"))
cache_dir = os.path.join(xdg_cache, "livestreamer")
class Cache(object):
"""Caches Python values as JSON and prunes expired entries."""
def __init__(self, filename, key_prefix=""):
self.key_prefix = key_prefix
self.filename = os.path.join(cache_dir, filename)
self._cache = {}
def _load(self):
if os.path.exists(self.filename):
try:
with open(self.filename, "r") as fd:
self._cache = json.load(fd)
except:
self._cache = {}
else:
self._cache = {}
def _prune(self):
now = time()
pruned = []
for key, value in self._cache.items():
expires = value.get("expires", time())
if expires <= now:
pruned.append(key)
for key in pruned:
self._cache.pop(key, None)
return len(pruned) > 0
def _save(self):
fd, tempname = tempfile.mkstemp()
fd = os.fdopen(fd, "w")
json.dump(self._cache, fd, indent=2, separators=(",", ": "))
fd.close()
# Silently ignore errors
try:
if not os.path.exists(os.path.dirname(self.filename)):
os.makedirs(os.path.dirname(self.filename))
shutil.move(tempname, self.filename)
except (IOError, OSError):
os.remove(tempname)
def set(self, key, value, expires=60 * 60 * 24 * 7):
self._load()
self._prune()
if self.key_prefix:
key = "{0}:{1}".format(self.key_prefix, key)
expires += time()
self._cache[key] = dict(value=value, expires=expires)
self._save()
def get(self, key, default=None):
self._load()
if self._prune():
self._save()
if self.key_prefix:
key = "{0}:{1}".format(self.key_prefix, key)
if key in self._cache and "value" in self._cache[key]:
return self._cache[key]["value"]
else:
return default
__all__ = ["Cache"]
livestreamer-1.12.2/src/livestreamer/buffers.py 0000644 0001750 0001750 00000007620 12521217321 022675 0 ustar chrippa chrippa 0000000 0000000 from collections import deque
from io import BytesIO
from threading import Event, Lock
class Chunk(BytesIO):
"""A single chunk, part of the buffer."""
def __init__(self, buf):
self.length = len(buf)
BytesIO.__init__(self, buf)
@property
def empty(self):
return self.tell() == self.length
class Buffer(object):
"""Simple buffer for use in single-threaded consumer/filler.
Stores chunks in a deque to avoid inefficient reallocating
of large buffers.
"""
def __init__(self):
self.chunks = deque()
self.current_chunk = None
self.closed = False
self.length = 0
def _iterate_chunks(self, size):
bytes_left = size
while bytes_left:
try:
current_chunk = (self.current_chunk or
Chunk(self.chunks.popleft()))
except IndexError:
break
data = current_chunk.read(bytes_left)
bytes_left -= len(data)
if current_chunk.empty:
self.current_chunk = None
else:
self.current_chunk = current_chunk
yield data
def write(self, data):
if not self.closed:
data = bytes(data) # Copy so that original buffer may be reused
self.chunks.append(data)
self.length += len(data)
def read(self, size=-1):
if size < 0 or size > self.length:
size = self.length
if not size:
return b""
data = b"".join(self._iterate_chunks(size))
self.length -= len(data)
return data
def close(self):
self.closed = True
class RingBuffer(Buffer):
"""Circular buffer for use in multi-threaded consumer/filler."""
def __init__(self, size=8192*4):
Buffer.__init__(self)
self.buffer_size = size
self.buffer_lock = Lock()
self.event_free = Event()
self.event_free.set()
self.event_used = Event()
def _check_events(self):
if self.length > 0:
self.event_used.set()
else:
self.event_used.clear()
if self.is_full:
self.event_free.clear()
else:
self.event_free.set()
def _read(self, size=-1):
with self.buffer_lock:
data = Buffer.read(self, size)
self._check_events()
return data
def read(self, size=-1, block=True, timeout=None):
if block and not self.closed:
self.event_used.wait(timeout)
# If the event is still not set it's a timeout
if not self.event_used.is_set() and self.length == 0:
raise IOError("Read timeout")
return self._read(size)
def write(self, data):
if self.closed:
return
data_left = len(data)
data_total = len(data)
while data_left > 0:
self.event_free.wait()
if self.closed:
return
with self.buffer_lock:
write_len = min(self.free, data_left)
written = data_total - data_left
Buffer.write(self, data[written:written+write_len])
data_left -= write_len
self._check_events()
def resize(self, size):
with self.buffer_lock:
self.buffer_size = size
self._check_events()
def wait_free(self, timeout=None):
self.event_free.wait(timeout)
def wait_used(self, timeout=None):
self.event_used.wait(timeout)
def close(self):
Buffer.close(self)
# Make sure we don't let a .write() and .read() block forever
self.event_free.set()
self.event_used.set()
@property
def free(self):
return max(self.buffer_size - self.length, 0)
@property
def is_full(self):
return self.free == 0
__all__ = ["Buffer", "RingBuffer"]
livestreamer-1.12.2/src/livestreamer/api.py 0000644 0001750 0001750 00000000500 12521217321 022000 0 ustar chrippa chrippa 0000000 0000000 from .session import Livestreamer
def streams(url, **params):
"""Attempts to find a plugin and extract streams from the *url*.
*params* are passed to :func:`Plugin.streams`.
Raises :exc:`NoPluginError` if no plugin is found.
"""
session = Livestreamer()
return session.streams(url, **params)
livestreamer-1.12.2/src/livestreamer/__init__.py 0000644 0001750 0001750 00000004151 12521217321 022774 0 ustar chrippa chrippa 0000000 0000000 # coding: utf8
"""Livestreamer extracts streams from various services.
The main compontent of Livestreamer is a command-line utility that
launches the streams in a video player.
An API is also provided that allows direct access to stream data.
Full documentation is available at http://docs.livestreamer.io/.
"""
__title__ = "livestreamer"
__version__ = "1.12.2"
__license__ = "Simplified BSD"
__author__ = "Christopher Rosell"
__copyright__ = "Copyright 2011-2015 Christopher Rosell"
__credits__ = [
"Agustín Carrasco (@asermax)",
"Andrew Bashore (@bashtech)",
"Andy Mikhailenko (@neithere)",
"Athanasios Oikonomou (@athoik)",
"Brian Callahan (@ibara)",
"Che (@chhe)",
"Christopher Rosell (@chrippa)",
"Daniel Meißner (@meise)",
"Daniel Miranda (@danielkza)",
"Daniel Wallace (@gtmanfred)",
"David Arvelo (@darvelo)",
"Dominik Dabrowski (@doda)",
"Erik G (@tboss)",
"Eric J (@wormeyman)",
"Ethan Jones (@jonesz)",
"Gaspard Jankowiak (@gapato)",
"Jaime Marquínez Ferrándiz (@jaimeMF)",
"Jan Tore Morken (@jantore)",
"John Peterson (@john-peterson)",
"Jon Bergli Heier (@sn4kebite)",
"Joseph Glanville (@josephglanville)",
"Julian Richen (@FireDart)",
"Kacper (@kasper93)",
"Martin Panter (@vadmium)",
"Max Nordlund (@maxnordlund)",
"Michael Cheah (@cheah)",
"Moritz Blanke",
"Niall McAndrew (@niallm90)",
"Niels Kräupl (@Gamewalker)",
"Pascal Romahn (@skulblakka)",
"Sam Edwards (@dotsam)",
"Stefan Breunig (@breunigs)",
"Suhail Patel (@suhailpatel)",
"Sunaga Takahiro (@sunaga720)",
"Vitaly Evtushenko (@eltiren)",
"Warnar Boekkooi (@boekkooi)",
"@blxd",
"@btiom",
"@daslicious",
"@MasterofJOKers",
"@mammothb",
"@medina",
"@monkeyphysics",
"@nixxquality",
"@papplampe",
"@Raziel-23",
"@t0mm0",
"@ToadKing",
"@unintended",
"@wolftankk",
"@yeeeargh"
]
from .api import streams
from .exceptions import (LivestreamerError, PluginError, NoStreamsError,
NoPluginError, StreamError)
from .session import Livestreamer
livestreamer-1.12.2/src/livestreamer/stream/ 0000755 0001750 0001750 00000000000 12521217500 022154 5 ustar chrippa chrippa 0000000 0000000 livestreamer-1.12.2/src/livestreamer/stream/wrappers.py 0000644 0001750 0001750 00000005324 12521217321 024376 0 ustar chrippa chrippa 0000000 0000000 from ..buffers import Buffer, RingBuffer
from threading import Thread
import io
class StreamIOWrapper(io.IOBase):
"""Wraps file-like objects that are not inheriting from IOBase"""
def __init__(self, fd):
self.fd = fd
def read(self, size=-1):
return self.fd.read(size)
def close(self):
if hasattr(self.fd, "close"):
self.fd.close()
class StreamIOIterWrapper(io.IOBase):
"""Wraps a iterator and turn it into a file-like object"""
def __init__(self, iterator):
self.iterator = iterator
self.buffer = Buffer()
def read(self, size=-1):
if size < 0:
size = self.buffer.length
while self.buffer.length < size:
try:
chunk = next(self.iterator)
self.buffer.write(chunk)
except StopIteration:
break
return self.buffer.read(size)
def close(self):
pass
class StreamIOThreadWrapper(io.IOBase):
"""Wraps a file-like object in a thread.
Useful for getting control over read timeout where
timeout handling is missing or out of our control.
"""
class Filler(Thread):
def __init__(self, fd, buffer):
Thread.__init__(self)
self.error = None
self.fd = fd
self.buffer = buffer
self.daemon = True
self.running = False
def run(self):
self.running = True
while self.running:
try:
data = self.fd.read(8192)
except IOError as error:
self.error = error
break
if len(data) == 0:
break
self.buffer.write(data)
self.stop()
def stop(self):
self.running = False
self.buffer.close()
if hasattr(self.fd, "close"):
try:
self.fd.close()
except Exception:
pass
def __init__(self, session, fd, timeout=30):
self.buffer = RingBuffer(session.get_option("ringbuffer-size"))
self.fd = fd
self.timeout = timeout
self.filler = StreamIOThreadWrapper.Filler(self.fd, self.buffer)
self.filler.start()
def read(self, size=-1):
if self.filler.error and self.buffer.length == 0:
raise self.filler.error
return self.buffer.read(size, block=self.filler.is_alive(),
timeout=self.timeout)
def close(self):
self.filler.stop()
if self.filler.is_alive():
self.filler.join()
__all__ = ["StreamIOWrapper", "StreamIOIterWrapper", "StreamIOThreadWrapper"]
livestreamer-1.12.2/src/livestreamer/stream/streamprocess.py 0000644 0001750 0001750 00000004740 12521217321 025426 0 ustar chrippa chrippa 0000000 0000000 from .stream import Stream
from .wrappers import StreamIOThreadWrapper
from ..compat import str
from ..exceptions import StreamError
from ..packages import pbs as sh
import os
import time
import tempfile
class StreamProcessIO(StreamIOThreadWrapper):
def __init__(self, session, process, **kwargs):
self.process = process
StreamIOThreadWrapper.__init__(self, session,
process.stdout,
**kwargs)
def close(self):
try:
self.process.kill()
except Exception:
pass
StreamIOThreadWrapper.close(self)
class StreamProcess(Stream):
def __init__(self, session, params=None, timeout=60.0):
Stream.__init__(self, session)
if not params:
params = {}
self.params = params
self.errorlog = self.session.options.get("subprocess-errorlog")
self.timeout = timeout
def open(self):
cmd = self._check_cmd()
params = self.params.copy()
params["_bg"] = True
if self.errorlog:
tmpfile = tempfile.NamedTemporaryFile(prefix="livestreamer",
suffix=".err", delete=False)
params["_err"] = tmpfile
else:
params["_err"] = open(os.devnull, "wb")
with params["_err"]:
stream = cmd(**params)
# Wait 0.5 seconds to see if program exited prematurely
time.sleep(0.5)
process_alive = stream.process.returncode is None
if not process_alive:
if self.errorlog:
raise StreamError(("Error while executing subprocess, "
"error output logged to: {0}").format(tmpfile.name))
else:
raise StreamError("Error while executing subprocess")
return StreamProcessIO(self.session, stream.process,
timeout=self.timeout)
def _check_cmd(self):
try:
cmd = sh.create_command(self.cmd)
except sh.CommandNotFound as err:
raise StreamError("Unable to find {0} command".format(err))
return cmd
def cmdline(self):
cmd = self._check_cmd()
return str(cmd.bake(**self.params))
@classmethod
def is_usable(cls, cmd):
try:
cmd = sh.create_command(cmd)
except sh.CommandNotFound:
return False
return True
__all__ = ["StreamProcess"]
livestreamer-1.12.2/src/livestreamer/stream/stream.py 0000644 0001750 0001750 00000001623 12521217321 024024 0 ustar chrippa chrippa 0000000 0000000 import io
import json
class Stream(object):
__shortname__ = "stream"
"""
This is a base class that should be inherited when implementing
different stream types. Should only be created by plugins.
"""
def __init__(self, session):
self.session = session
def __repr__(self):
return ""
def __json__(self):
return dict(type=type(self).shortname())
def open(self):
"""
Attempts to open a connection to the stream.
Returns a file-like object that can be used to read the stream data.
Raises :exc:`StreamError` on failure.
"""
raise NotImplementedError
@property
def json(self):
obj = self.__json__()
return json.dumps(obj)
@classmethod
def shortname(cls):
return cls.__shortname__
class StreamIO(io.IOBase):
pass
__all__ = ["Stream", "StreamIO"]
livestreamer-1.12.2/src/livestreamer/stream/segmented.py 0000644 0001750 0001750 00000012615 12521217321 024507 0 ustar chrippa chrippa 0000000 0000000 from concurrent import futures
from threading import Thread, Event
from .stream import StreamIO
from ..buffers import RingBuffer
from ..compat import queue
class SegmentedStreamWorker(Thread):
"""The general worker thread.
This thread is responsible for queueing up segments in the
writer thread.
"""
def __init__(self, reader):
self.closed = False
self.reader = reader
self.writer = reader.writer
self.stream = reader.stream
self.session = reader.stream.session
self.logger = reader.logger
self._wait = None
Thread.__init__(self)
self.daemon = True
def close(self):
"""Shuts down the thread."""
if not self.closed:
self.logger.debug("Closing worker thread")
self.closed = True
if self._wait:
self._wait.set()
def wait(self, time):
"""Pauses the thread for a specified time.
Returns False if interrupted by another thread and True if the
time runs out normally.
"""
self._wait = Event()
return not self._wait.wait(time)
def iter_segments(self):
"""The iterator that generates segments for the worker thread.
Should be overridden by the inheriting class.
"""
return
yield
def run(self):
for segment in self.iter_segments():
self.writer.put(segment)
# End of stream, tells the writer to exit
self.writer.put(None)
self.close()
class SegmentedStreamWriter(Thread):
"""The writer thread.
This thread is responsible for fetching segments, processing them
and finally writing the data to the buffer.
"""
def __init__(self, reader, size=20, retries=None, threads=None, timeout=None):
self.closed = False
self.reader = reader
self.stream = reader.stream
self.session = reader.stream.session
self.logger = reader.logger
if not retries:
retries = self.session.options.get("stream-segment-attempts")
if not threads:
threads = self.session.options.get("stream-segment-threads")
if not timeout:
timeout = self.session.options.get("stream-segment-timeout")
self.retries = retries
self.timeout = timeout
self.executor = futures.ThreadPoolExecutor(max_workers=threads)
self.futures = queue.Queue(size)
Thread.__init__(self)
self.daemon = True
def close(self):
"""Shuts down the thread."""
if not self.closed:
self.logger.debug("Closing writer thread")
self.closed = True
self.reader.buffer.close()
self.executor.shutdown(wait=True)
def put(self, segment):
"""Adds a segment to the download pool and write queue."""
if self.closed:
return
if segment is not None:
future = self.executor.submit(self.fetch, segment,
retries=self.retries)
else:
future = None
self.queue(self.futures, (segment, future))
def queue(self, queue_, value):
"""Puts a value into a queue but aborts if this thread is closed."""
while not self.closed:
try:
queue_.put(value, block=True, timeout=1)
break
except queue.Full:
continue
def fetch(self, segment):
"""Fetches a segment.
Should be overridden by the inheriting class.
"""
pass
def write(self, segment, result):
"""Writes a segment to the buffer.
Should be overridden by the inheriting class.
"""
pass
def run(self):
while not self.closed:
try:
segment, future = self.futures.get(block=True, timeout=0.5)
except queue.Empty:
continue
# End of stream
if future is None:
break
while not self.closed:
try:
result = future.result(timeout=0.5)
except futures.TimeoutError:
continue
except futures.CancelledError:
break
if result is not None:
self.write(segment, result)
break
self.close()
class SegmentedStreamReader(StreamIO):
__worker__ = SegmentedStreamWorker
__writer__ = SegmentedStreamWriter
def __init__(self, stream, timeout=None):
StreamIO.__init__(self)
self.session = stream.session
self.stream = stream
if not timeout:
timeout = self.session.options.get("stream-timeout")
self.timeout = timeout
def open(self):
buffer_size = self.session.get_option("ringbuffer-size")
self.buffer = RingBuffer(buffer_size)
self.writer = self.__writer__(self)
self.worker = self.__worker__(self)
self.writer.start()
self.worker.start()
def close(self):
self.worker.close()
self.writer.close()
for thread in (self.worker, self.writer):
if thread.is_alive():
thread.join()
self.buffer.close()
def read(self, size):
if not self.buffer:
return b""
return self.buffer.read(size, block=self.writer.is_alive(),
timeout=self.timeout)
livestreamer-1.12.2/src/livestreamer/stream/rtmpdump.py 0000644 0001750 0001750 00000007473 12521217321 024412 0 ustar chrippa chrippa 0000000 0000000 import re
from time import sleep
from .streamprocess import StreamProcess
from ..compat import str
from ..exceptions import StreamError
from ..packages import pbs as sh
from ..utils import rtmpparse
class RTMPStream(StreamProcess):
"""RTMP stream using rtmpdump.
*Attributes:*
- :attr:`params` A :class:`dict` containing parameters passed to rtmpdump
"""
__shortname__ = "rtmp"
def __init__(self, session, params, redirect=False):
StreamProcess.__init__(self, session, params)
self.cmd = self.session.options.get("rtmp-rtmpdump")
self.timeout = self.session.options.get("rtmp-timeout")
self.redirect = redirect
self.logger = session.logger.new_module("stream.rtmp")
def __repr__(self):
return ("").format(self.params,
self.redirect)
def __json__(self):
return dict(type=RTMPStream.shortname(), params=self.params)
def open(self):
if self.session.options.get("rtmp-proxy"):
if not self._supports_param("socks"):
raise StreamError("Installed rtmpdump does not support --socks argument")
self.params["socks"] = self.session.options.get("rtmp-proxy")
if "jtv" in self.params and not self._supports_param("jtv"):
raise StreamError("Installed rtmpdump does not support --jtv argument")
if "weeb" in self.params and not self._supports_param("weeb"):
raise StreamError("Installed rtmpdump does not support --weeb argument")
if self.redirect:
self._check_redirect()
self.params["flv"] = "-"
return StreamProcess.open(self)
def _check_redirect(self, timeout=20):
cmd = self._check_cmd()
params = self.params.copy()
params["verbose"] = True
params["_bg"] = True
self.logger.debug("Attempting to find tcURL redirect")
stream = cmd(**params)
elapsed = 0
process_alive = True
while elapsed < timeout and process_alive:
stream.process.poll()
process_alive = stream.process.returncode is None
sleep(0.25)
elapsed += 0.25
if process_alive:
try:
stream.process.kill()
except Exception:
pass
stream.process.wait()
try:
stderr = stream.stderr()
except sh.ErrorReturnCode as err:
self._update_redirect(err.stderr)
def _update_redirect(self, stderr):
tcurl, redirect = None, None
stderr = str(stderr, "utf8")
m = re.search("DEBUG: Property: ", stderr)
if m:
redirect = m.group(1)
if redirect:
self.logger.debug("Found redirect tcUrl: {0}", redirect)
if "rtmp" in self.params:
tcurl, playpath = rtmpparse(self.params["rtmp"])
rtmp = "{redirect}/{playpath}".format(**locals())
self.params["rtmp"] = rtmp
if "tcUrl" in self.params:
self.params["tcUrl"] = redirect
def _supports_param(self, param):
cmd = self._check_cmd()
try:
help = cmd(help=True, _err_to_out=True)
except sh.ErrorReturnCode as err:
err = str(err.stdout, "ascii")
raise StreamError("Error while checking rtmpdump compatibility: {0}".format(err))
for line in help.splitlines():
m = re.match("^--(\w+)", line)
if not m:
continue
if m.group(1) == param:
return True
return False
@classmethod
def is_usable(cls, session):
cmd = session.options.get("rtmp-rtmpdump")
return StreamProcess.is_usable(cmd)
livestreamer-1.12.2/src/livestreamer/stream/playlist.py 0000644 0001750 0001750 00000003714 12521217321 024375 0 ustar chrippa chrippa 0000000 0000000 from .flvconcat import FLVTagConcatIO
from .stream import Stream
from ..exceptions import StreamError
__all__ = ["Playlist", "FLVPlaylist"]
class Playlist(Stream):
"""Abstract base class for playlist type streams."""
__shortname__ = "playlist"
def __init__(self, session, streams, duration=None):
Stream.__init__(self, session)
self.streams = streams
self.duration = duration
def open(self):
raise NotImplementedError
def __json__(self):
return dict(streams=self.streams, duration=self.duration,
**Stream.__json__(self))
class FLVPlaylistIO(FLVTagConcatIO):
__log_name__ = "stream.flv_playlist"
def open(self, streams):
def generator():
for stream in streams:
self.logger.debug("Opening substream: {0}", stream)
# No need for multiple ringbuffers
if hasattr(stream, "buffered"):
stream.buffered = False
try:
fd = stream.open()
except StreamError as err:
self.logger.error("Failed to open stream: {0}", err)
continue
yield fd
return FLVTagConcatIO.open(self, generator())
class FLVPlaylist(Playlist):
__shortname__ = "flv_playlist"
def __init__(self, session, streams, duration=None, tags=None,
skip_header=None, **concater_params):
Playlist.__init__(self, session, streams, duration)
if not tags:
tags = []
self.tags = tags
self.skip_header = skip_header
self.concater_params = concater_params
def open(self):
fd = FLVPlaylistIO(self.session,
tags=self.tags,
duration=self.duration,
skip_header=self.skip_header,
**self.concater_params)
fd.open(self.streams)
return fd
livestreamer-1.12.2/src/livestreamer/stream/http.py 0000644 0001750 0001750 00000004574 12521217321 023520 0 ustar chrippa chrippa 0000000 0000000 import inspect
import requests
from .stream import Stream
from .wrappers import StreamIOThreadWrapper, StreamIOIterWrapper
from ..exceptions import StreamError
def normalize_key(keyval):
key, val = keyval
key = hasattr(key, "decode") and key.decode("utf8", "ignore") or key
return key, val
def valid_args(args):
argspec = inspect.getargspec(requests.Request.__init__)
return dict(filter(lambda kv: kv[0] in argspec.args, args.items()))
class HTTPStream(Stream):
"""A HTTP stream using the requests library.
*Attributes:*
- :attr:`url` The URL to the stream, prepared by requests.
- :attr:`args` A :class:`dict` containing keyword arguments passed
to :meth:`requests.request`, such as headers and cookies.
"""
__shortname__ = "http"
def __init__(self, session_, url, buffered=True, **args):
Stream.__init__(self, session_)
self.args = dict(url=url, **args)
self.buffered = buffered
def __repr__(self):
return "".format(self.url)
def __json__(self):
method = self.args.get("method", "GET")
req = requests.Request(method=method, **valid_args(self.args))
# prepare_request is only available in requests 2.0+
if hasattr(self.session.http, "prepare_request"):
req = self.session.http.prepare_request(req)
else:
req = req.prepare()
headers = dict(map(normalize_key, req.headers.items()))
return dict(type=type(self).shortname(), url=req.url,
method=req.method, headers=headers,
body=req.body)
@property
def url(self):
method = self.args.get("method", "GET")
return requests.Request(method=method,
**valid_args(self.args)).prepare().url
def open(self):
method = self.args.get("method", "GET")
timeout = self.session.options.get("http-timeout")
res = self.session.http.request(method=method,
stream=True,
exception=StreamError,
timeout=timeout,
**self.args)
fd = StreamIOIterWrapper(res.iter_content(8192))
if self.buffered:
fd = StreamIOThreadWrapper(self.session, fd, timeout=timeout)
return fd
livestreamer-1.12.2/src/livestreamer/stream/hls_playlist.py 0000644 0001750 0001750 00000024345 12521217321 025246 0 ustar chrippa chrippa 0000000 0000000 import re
from binascii import unhexlify
from collections import namedtuple
from itertools import starmap
try:
from urlparse import urljoin
except ImportError:
from urllib.parse import urljoin
__all__ = ["load", "M3U8Parser"]
# EXT-X-BYTERANGE
ByteRange = namedtuple("ByteRange", "range offset")
# EXT-X-KEY
Key = namedtuple("Key", "method uri iv key_format key_format_versions")
# EXT-X-MAP
Map = namedtuple("Map", "uri byterange")
# EXT-X-MEDIA
Media = namedtuple("Media", "uri type group_id language name default "
"autoselect forced characteristics")
# EXT-X-START
Start = namedtuple("Start", "time_offset precise")
# EXT-X-STREAM-INF
StreamInfo = namedtuple("StreamInfo", "bandwidth program_id codecs resolution "
"audio video subtitles")
# EXT-X-I-FRAME-STREAM-INF
IFrameStreamInfo = namedtuple("IFrameStreamInfo", "bandwidth program_id "
"codecs resolution video")
Playlist = namedtuple("Playlist", "uri stream_info media is_iframe")
Resolution = namedtuple("Resolution", "width height")
Segment = namedtuple("Segment", "uri duration title key discontinuity "
"byterange date map")
ATTRIBUTE_REGEX = (r"([A-Z\-]+)=(\d+\.\d+|0x[0-9A-z]+|\d+x\d+|\d+|"
r"\"(.+?)\"|[0-9A-z\-]+)")
class M3U8(object):
def __init__(self):
self.is_endlist = False
self.is_master = False
self.allow_cache = None
self.discontinuity_sequence = None
self.iframes_only = None
self.media_sequence = None
self.playlist_type = None
self.target_duration = None
self.start = None
self.version = None
self.media = []
self.playlists = []
self.segments = []
class M3U8Parser(object):
def __init__(self, base_uri=None):
self.base_uri = base_uri
def create_stream_info(self, streaminf, cls=None):
program_id = streaminf.get("PROGRAM-ID")
if program_id:
program_id = int(program_id)
bandwidth = streaminf.get("BANDWIDTH")
if bandwidth:
bandwidth = int(bandwidth)
resolution = streaminf.get("RESOLUTION")
if resolution:
resolution = self.parse_resolution(resolution)
codecs = streaminf.get("CODECS")
if codecs:
codecs = codecs.split(",")
else:
codecs = []
if cls == IFrameStreamInfo:
return IFrameStreamInfo(bandwidth, program_id, codecs, resolution,
streaminf.get("VIDEO"))
else:
return StreamInfo(bandwidth, program_id, codecs, resolution,
streaminf.get("AUDIO"), streaminf.get("VIDEO"),
streaminf.get("SUBTITLES"))
def split_tag(self, line):
match = re.match("#(?P[\w-]+)(:(?P.+))?", line)
if match:
return match.group("tag"), match.group("value").strip()
return None, None
def parse_attributes(self, value):
def map_attribute(key, value, quoted):
return (key, quoted or value)
attr = re.findall(ATTRIBUTE_REGEX, value)
return dict(starmap(map_attribute, attr))
def parse_bool(self, value):
return value == "YES"
def parse_byterange(self, value):
match = re.match("(?P\d+)(@(?P.+))?", value)
if match:
return ByteRange(int(match.group("range")),
int(match.group("offset") or 0))
def parse_extinf(self, value):
match = re.match("(?P\d+(\.\d+)?)(,(?P.+))?", value)
if match:
return float(match.group("duration")), match.group("title")
def parse_hex(self, value):
value = value[2:]
if len(value) % 2:
value = "0" + value
return unhexlify(value)
def parse_resolution(self, value):
match = re.match("(\d+)x(\d+)", value)
if match:
width, height = int(match.group(1)), int(match.group(2))
else:
width, height = 0, 0
return Resolution(width, height)
def parse_tag(self, line, transform=None):
tag, value = self.split_tag(line)
if transform:
value = transform(value)
return value
def parse_line(self, lineno, line):
if lineno == 0 and not line.startswith("#EXTM3U"):
raise ValueError("Missing #EXTM3U header")
if not line.startswith("#"):
if self.state.pop("expect_segment", None):
byterange = self.state.pop("byterange", None)
extinf = self.state.pop("extinf", (0, None))
date = self.state.pop("date", None)
map_ = self.state.get("map")
key = self.state.get("key")
segment = Segment(self.uri(line), extinf[0],
extinf[1], key,
self.state.pop("discontinuity", False),
byterange, date, map_)
self.m3u8.segments.append(segment)
elif self.state.pop("expect_playlist", None):
streaminf = self.state.pop("streaminf", {})
stream_info = self.create_stream_info(streaminf)
playlist = Playlist(self.uri(line), stream_info, [], False)
self.m3u8.playlists.append(playlist)
elif line.startswith("#EXTINF"):
self.state["expect_segment"] = True
self.state["extinf"] = self.parse_tag(line, self.parse_extinf)
elif line.startswith("#EXT-X-BYTERANGE"):
self.state["expect_segment"] = True
self.state["byterange"] = self.parse_tag(line, self.parse_byterange)
elif line.startswith("#EXT-X-TARGETDURATION"):
self.m3u8.target_duration = self.parse_tag(line, int)
elif line.startswith("#EXT-X-MEDIA-SEQUENCE"):
self.m3u8.media_sequence = self.parse_tag(line, int)
elif line.startswith("#EXT-X-KEY"):
attr = self.parse_tag(line, self.parse_attributes)
iv = attr.get("IV")
if iv: iv = self.parse_hex(iv)
self.state["key"] = Key(attr.get("METHOD"),
self.uri(attr.get("URI")),
iv, attr.get("KEYFORMAT"),
attr.get("KEYFORMATVERSIONS"))
elif line.startswith("#EXT-X-PROGRAM-DATE-TIME"):
self.state["date"] = self.parse_tag(line)
elif line.startswith("#EXT-X-ALLOW-CACHE"):
self.m3u8.allow_cache = self.parse_tag(line, self.parse_bool)
elif line.startswith("#EXT-X-STREAM-INF"):
self.state["streaminf"] = self.parse_tag(line, self.parse_attributes)
self.state["expect_playlist"] = True
elif line.startswith("#EXT-X-PLAYLIST-TYPE"):
self.m3u8.playlist_type = self.parse_tag(line)
elif line.startswith("#EXT-X-ENDLIST"):
self.m3u8.is_endlist = True
elif line.startswith("#EXT-X-MEDIA"):
attr = self.parse_tag(line, self.parse_attributes)
media = Media(self.uri(attr.get("URI")), attr.get("TYPE"),
attr.get("GROUP-ID"), attr.get("LANGUAGE"),
attr.get("NAME"),
self.parse_bool(attr.get("DEFAULT")),
self.parse_bool(attr.get("AUTOSELECT")),
self.parse_bool(attr.get("FORCED")),
attr.get("CHARACTERISTICS"))
self.m3u8.media.append(media)
elif line.startswith("#EXT-X-DISCONTINUITY"):
self.state["discontinuity"] = True
self.state["map"] = None
elif line.startswith("#EXT-X-DISCONTINUITY-SEQUENCE"):
self.m3u8.discontinuity_sequence = self.parse_tag(line, int)
elif line.startswith("#EXT-X-I-FRAMES-ONLY"):
self.m3u8.iframes_only = True
elif line.startswith("#EXT-X-MAP"):
attr = self.parse_tag(line, self.parse_attributes)
byterange = self.parse_byterange(attr.get("BYTERANGE", ""))
self.state["map"] = Map(attr.get("URI"), byterange)
elif line.startswith("#EXT-X-I-FRAME-STREAM-INF"):
attr = self.parse_tag(line, self.parse_attributes)
streaminf = self.state.pop("streaminf", attr)
stream_info = self.create_stream_info(streaminf, IFrameStreamInfo)
playlist = Playlist(self.uri(attr.get("URI")), stream_info, [], True)
self.m3u8.playlists.append(playlist)
elif line.startswith("#EXT-X-VERSION"):
self.m3u8.version = self.parse_tag(line, int)
elif line.startswith("#EXT-X-START"):
attr = self.parse_tag(line, self.parse_attributes)
start = Start(attr.get("TIME-OFFSET"),
self.parse_bool(attr.get("PRECISE", "NO")))
self.m3u8.start = start
def parse(self, data):
self.state = {}
self.m3u8 = M3U8()
for lineno, line in enumerate(filter(bool, data.splitlines())):
self.parse_line(lineno, line)
# Associate Media entries with each Playlist
for playlist in self.m3u8.playlists:
for media_type in ("audio", "video", "subtitles"):
group_id = getattr(playlist.stream_info, media_type, None)
if group_id:
for media in filter(lambda m: m.group_id == group_id,
self.m3u8.media):
playlist.media.append(media)
self.m3u8.is_master = not not self.m3u8.playlists
return self.m3u8
def uri(self, uri):
if uri and uri.startswith("http"):
return uri
elif self.base_uri and uri:
return urljoin(self.base_uri, uri)
else:
return uri
def load(data, base_uri=None, parser=M3U8Parser):
"""Attempts to parse a M3U8 playlist from a string of data.
If specified, *base_uri* is the base URI that relative URIs will
be joined together with, otherwise relative URIs will be as is.
If specified, *parser* can be a M3U8Parser subclass to be used
to parse the data.
"""
return parser(base_uri).parse(data)
livestreamer-1.12.2/src/livestreamer/stream/hls.py 0000644 0001750 0001750 00000026543 12521217321 023327 0 ustar chrippa chrippa 0000000 0000000 from collections import defaultdict, namedtuple
try:
from Crypto.Cipher import AES
import struct
def num_to_iv(n):
return struct.pack(">8xq", n)
CAN_DECRYPT = True
except ImportError:
CAN_DECRYPT = False
from . import hls_playlist
from .http import HTTPStream
from .segmented import (SegmentedStreamReader,
SegmentedStreamWriter,
SegmentedStreamWorker)
from ..exceptions import StreamError
Sequence = namedtuple("Sequence", "num segment")
class HLSStreamWriter(SegmentedStreamWriter):
def __init__(self, reader, *args, **kwargs):
options = reader.stream.session.options
kwargs["retries"] = options.get("hls-segment-attempts")
kwargs["threads"] = options.get("hls-segment-threads")
kwargs["timeout"] = options.get("hls-segment-timeout")
SegmentedStreamWriter.__init__(self, reader, *args, **kwargs)
self.byterange_offsets = defaultdict(int)
self.key_data = None
self.key_uri = None
def create_decryptor(self, key, sequence):
if key.method != "AES-128":
raise StreamError("Unable to decrypt cipher {0}", key.method)
if not key.uri:
raise StreamError("Missing URI to decryption key")
if self.key_uri != key.uri:
res = self.session.http.get(key.uri, exception=StreamError,
**self.reader.request_params)
self.key_data = res.content
self.key_uri = key.uri
iv = key.iv or num_to_iv(sequence)
# Pad IV if needed
iv = b"\x00" * (16 - len(iv)) + iv
return AES.new(self.key_data, AES.MODE_CBC, iv)
def create_request_params(self, sequence):
request_params = dict(self.reader.request_params)
headers = request_params.pop("headers", {})
if sequence.segment.byterange:
bytes_start = self.byterange_offsets[sequence.segment.uri]
if sequence.segment.byterange.offset is not None:
bytes_start = sequence.segment.byterange.offset
bytes_len = max(sequence.segment.byterange.range - 1, 0)
bytes_end = bytes_start + bytes_len
headers["Range"] = "bytes={0}-{1}".format(bytes_start, bytes_end)
self.byterange_offsets[sequence.segment.uri] = bytes_end + 1
request_params["headers"] = headers
return request_params
def fetch(self, sequence, retries=None):
if self.closed or not retries:
return
try:
request_params = self.create_request_params(sequence)
return self.session.http.get(sequence.segment.uri,
timeout=self.timeout,
exception=StreamError,
**request_params)
except StreamError as err:
self.logger.error("Failed to open segment {0}: {1}", sequence.num, err)
return self.fetch(sequence, retries - 1)
def write(self, sequence, res, chunk_size=8192):
if sequence.segment.key and sequence.segment.key.method != "NONE":
try:
decryptor = self.create_decryptor(sequence.segment.key,
sequence.num)
except StreamError as err:
self.logger.error("Failed to create decryptor: {0}", err)
self.close()
return
# If the input data is not a multiple of 16, cut off any garbage
garbage_len = len(res.content) % 16
if garbage_len:
self.logger.debug("Cutting off {0} bytes of garbage "
"before decrypting", garbage_len)
content = decryptor.decrypt(res.content[:-(garbage_len)])
else:
content = decryptor.decrypt(res.content)
else:
content = res.content
self.reader.buffer.write(content)
self.logger.debug("Download of segment {0} complete", sequence.num)
class HLSStreamWorker(SegmentedStreamWorker):
def __init__(self, *args, **kwargs):
SegmentedStreamWorker.__init__(self, *args, **kwargs)
self.playlist_changed = False
self.playlist_end = None
self.playlist_sequence = -1
self.playlist_sequences = []
self.playlist_reload_time = 15
self.live_edge = self.session.options.get("hls-live-edge")
self.reload_playlist()
def reload_playlist(self):
if self.closed:
return
self.reader.buffer.wait_free()
self.logger.debug("Reloading playlist")
res = self.session.http.get(self.stream.url,
exception=StreamError,
**self.reader.request_params)
try:
playlist = hls_playlist.load(res.text, res.url)
except ValueError as err:
raise StreamError(err)
if playlist.is_master:
raise StreamError("Attempted to play a variant playlist, use "
"'hlsvariant://{0}' instead".format(self.stream.url))
if playlist.iframes_only:
raise StreamError("Streams containing I-frames only is not playable")
media_sequence = playlist.media_sequence or 0
sequences = [Sequence(media_sequence + i, s)
for i, s in enumerate(playlist.segments)]
if sequences:
self.process_sequences(playlist, sequences)
def process_sequences(self, playlist, sequences):
first_sequence, last_sequence = sequences[0], sequences[-1]
if first_sequence.segment.key and first_sequence.segment.key.method != "NONE":
self.logger.debug("Segments in this playlist are encrypted")
if not CAN_DECRYPT:
raise StreamError("Need pyCrypto installed to decrypt this stream")
self.playlist_changed = ([s.num for s in self.playlist_sequences] !=
[s.num for s in sequences])
self.playlist_reload_time = (playlist.target_duration or
last_sequence.segment.duration)
self.playlist_sequences = sequences
if not self.playlist_changed:
self.playlist_reload_time = max(self.playlist_reload_time / 2, 1)
if playlist.is_endlist:
self.playlist_end = last_sequence.num
if self.playlist_sequence < 0:
if self.playlist_end is None:
edge_index = -(min(len(sequences), max(int(self.live_edge), 1)))
edge_sequence = sequences[edge_index]
self.playlist_sequence = edge_sequence.num
else:
self.playlist_sequence = first_sequence.num
def valid_sequence(self, sequence):
return sequence.num >= self.playlist_sequence
def iter_segments(self):
while not self.closed:
for sequence in filter(self.valid_sequence, self.playlist_sequences):
self.logger.debug("Adding segment {0} to queue", sequence.num)
yield sequence
# End of stream
stream_end = self.playlist_end and sequence.num >= self.playlist_end
if self.closed or stream_end:
return
self.playlist_sequence = sequence.num + 1
if self.wait(self.playlist_reload_time):
try:
self.reload_playlist()
except StreamError as err:
self.logger.warning("Failed to reload playlist: {0}", err)
class HLSStreamReader(SegmentedStreamReader):
__worker__ = HLSStreamWorker
__writer__ = HLSStreamWriter
def __init__(self, stream, *args, **kwargs):
SegmentedStreamReader.__init__(self, stream, *args, **kwargs)
self.logger = stream.session.logger.new_module("stream.hls")
self.request_params = dict(stream.args)
self.timeout = stream.session.options.get("hls-timeout")
# These params are reserved for internal use
self.request_params.pop("exception", None)
self.request_params.pop("stream", None)
self.request_params.pop("timeout", None)
self.request_params.pop("url", None)
class HLSStream(HTTPStream):
"""Implementation of the Apple HTTP Live Streaming protocol
*Attributes:*
- :attr:`url` The URL to the HLS playlist.
- :attr:`args` A :class:`dict` containing keyword arguments passed
to :meth:`requests.request`, such as headers and cookies.
.. versionchanged:: 1.7.0
Added *args* attribute.
"""
__shortname__ = "hls"
def __init__(self, session_, url, **args):
HTTPStream.__init__(self, session_, url, **args)
def __repr__(self):
return "<HLSStream({0!r})>".format(self.url)
def __json__(self):
json = HTTPStream.__json__(self)
# Pretty sure HLS is GET only.
del json["method"]
del json["body"]
return json
def open(self):
reader = HLSStreamReader(self)
reader.open()
return reader
@classmethod
def parse_variant_playlist(cls, session_, url, name_key="name",
name_prefix="", check_streams=False,
**request_params):
"""Attempts to parse a variant playlist and return its streams.
:param url: The URL of the variant playlist.
:param name_key: Prefer to use this key as stream name, valid keys are:
name, pixels, bitrate.
:param name_prefix: Add this prefix to the stream names.
:param check_streams: Only allow streams that are accesible.
"""
# Backwards compatibility with "namekey" and "nameprefix" params.
name_key = request_params.pop("namekey", name_key)
name_prefix = request_params.pop("nameprefix", name_prefix)
res = session_.http.get(url, exception=IOError, **request_params)
try:
parser = hls_playlist.load(res.text, base_uri=res.url)
except ValueError as err:
raise IOError("Failed to parse playlist: {0}".format(err))
streams = {}
for playlist in filter(lambda p: not p.is_iframe, parser.playlists):
names = dict(name=None, pixels=None, bitrate=None)
for media in playlist.media:
if media.type == "VIDEO" and media.name:
names["name"] = media.name
if playlist.stream_info.resolution:
width, height = playlist.stream_info.resolution
names["pixels"] = "{0}p".format(height)
if playlist.stream_info.bandwidth:
bw = playlist.stream_info.bandwidth
if bw >= 1000:
names["bitrate"] = "{0}k".format(int(bw / 1000.0))
else:
names["bitrate"] = "{0}k".format(bw / 1000.0)
stream_name = (names.get(name_key) or names.get("name") or
names.get("pixels") or names.get("bitrate"))
if not stream_name or stream_name in streams:
continue
if check_streams:
try:
session_.http.get(playlist.uri, **request_params)
except Exception:
continue
stream = HLSStream(session_, playlist.uri, **request_params)
streams[name_prefix + stream_name] = stream
return streams
livestreamer-1.12.2/src/livestreamer/stream/hds.py 0000644 0001750 0001750 00000053246 12521217321 023317 0 ustar chrippa chrippa 0000000 0000000 from __future__ import division
import base64
import hmac
import re
import os.path
from binascii import unhexlify
from collections import namedtuple
from copy import deepcopy
from hashlib import sha256
from io import BytesIO
from math import ceil
from .flvconcat import FLVTagConcat
from .segmented import (SegmentedStreamReader,
SegmentedStreamWriter,
SegmentedStreamWorker)
from .stream import Stream
from .wrappers import StreamIOIterWrapper
from ..cache import Cache
from ..compat import parse_qsl, urljoin, urlparse, urlunparse, bytes, range
from ..exceptions import StreamError
from ..utils import absolute_url, swfdecompress
from ..packages.flashmedia import F4V, F4VError
from ..packages.flashmedia.box import Box
from ..packages.flashmedia.tag import ScriptData, Tag, TAG_TYPE_SCRIPT
# Akamai HD player verification key
# Use unhexlify() rather than bytes.fromhex() for compatibility with before
# Python 3. However, in Python 3.2 (not 3.3+), unhexlify only accepts a byte
# string.
AKAMAIHD_PV_KEY = unhexlify(
b"BD938D5EE6D9F42016F9C56577B6FDCF415FE4B184932B785AB32BCADC9BB592")
# Some streams hosted by Akamai seem to require a hdcore parameter
# to function properly.
HDCORE_VERSION = "3.1.0"
# Fragment URL format
FRAGMENT_URL = "{url}{identifier}{quality}Seg{segment}-Frag{fragment}"
Fragment = namedtuple("Fragment", "segment fragment duration url")
class HDSStreamWriter(SegmentedStreamWriter):
def __init__(self, reader, *args, **kwargs):
options = reader.stream.session.options
kwargs["retries"] = options.get("hds-segment-attempts")
kwargs["threads"] = options.get("hds-segment-threads")
kwargs["timeout"] = options.get("hds-segment-timeout")
SegmentedStreamWriter.__init__(self, reader, *args, **kwargs)
duration, tags = None, []
if self.stream.metadata:
duration = self.stream.metadata.value.get("duration")
tags = [Tag(TAG_TYPE_SCRIPT, timestamp=0,
data=self.stream.metadata)]
self.concater = FLVTagConcat(tags=tags,
duration=duration,
flatten_timestamps=True)
def fetch(self, fragment, retries=None):
if self.closed or not retries:
return
try:
return self.session.http.get(fragment.url,
stream=True,
timeout=self.timeout,
exception=StreamError,
**self.stream.request_params)
except StreamError as err:
self.logger.error("Failed to open fragment {0}-{1}: {2}",
fragment.segment, fragment.fragment, err)
return self.fetch(fragment, retries - 1)
def write(self, fragment, res, chunk_size=8192):
fd = StreamIOIterWrapper(res.iter_content(chunk_size))
self.convert_fragment(fragment, fd)
def convert_fragment(self, fragment, fd):
mdat = None
try:
f4v = F4V(fd, raw_payload=True)
# Fast forward to mdat box
for box in f4v:
if box.type == "mdat":
mdat = box.payload.data
break
except F4VError as err:
self.logger.error("Failed to parse fragment {0}-{1}: {2}",
fragment.segment, fragment.fragment, err)
return
if not mdat:
self.logger.error("No MDAT box found in fragment {0}-{1}",
fragment.segment, fragment.fragment)
return
try:
for chunk in self.concater.iter_chunks(buf=mdat, skip_header=True):
self.reader.buffer.write(chunk)
if self.closed:
break
else:
self.logger.debug("Download of fragment {0}-{1} complete",
fragment.segment, fragment.fragment)
except IOError as err:
if "Unknown tag type" in str(err):
self.logger.error("Unknown tag type found, this stream is "
"probably encrypted")
self.close()
return
self.logger.error("Error reading fragment {0}-{1}: {2}",
fragment.segment, fragment.fragment, err)
class HDSStreamWorker(SegmentedStreamWorker):
def __init__(self, *args, **kwargs):
SegmentedStreamWorker.__init__(self, *args, **kwargs)
self.bootstrap = self.stream.bootstrap
self.current_segment = -1
self.current_fragment = -1
self.first_fragment = 1
self.last_fragment = -1
self.end_fragment = None
self.bootstrap_minimal_reload_time = 2.0
self.bootstrap_reload_time = self.bootstrap_minimal_reload_time
self.invalid_fragments = set()
self.live_edge = self.session.options.get("hds-live-edge")
self.update_bootstrap()
def update_bootstrap(self):
self.logger.debug("Updating bootstrap")
if isinstance(self.bootstrap, Box):
bootstrap = self.bootstrap
else:
bootstrap = self.fetch_bootstrap(self.bootstrap)
self.live = bootstrap.payload.live
self.profile = bootstrap.payload.profile
self.timestamp = bootstrap.payload.current_media_time
self.identifier = bootstrap.payload.movie_identifier
self.time_scale = bootstrap.payload.time_scale
self.segmentruntable = bootstrap.payload.segment_run_table_entries[0]
self.fragmentruntable = bootstrap.payload.fragment_run_table_entries[0]
self.first_fragment, last_fragment = self.fragment_count()
fragment_duration = self.fragment_duration(last_fragment)
if last_fragment != self.last_fragment:
bootstrap_changed = True
self.last_fragment = last_fragment
else:
bootstrap_changed = False
if self.current_fragment < 0:
if self.live:
current_fragment = last_fragment
# Less likely to hit edge if we don't start with last fragment,
# default buffer is 10 sec.
fragment_buffer = int(ceil(self.live_edge / fragment_duration))
current_fragment = max(self.first_fragment,
current_fragment - (fragment_buffer - 1))
self.logger.debug("Live edge buffer {0} sec is {1} fragments",
self.live_edge, fragment_buffer)
# Make sure we don't have a duration set when it's a
# live stream since it will just confuse players anyway.
self.writer.concater.duration = None
else:
current_fragment = self.first_fragment
self.current_fragment = current_fragment
self.logger.debug("Current timestamp: {0}", self.timestamp / self.time_scale)
self.logger.debug("Current segment: {0}", self.current_segment)
self.logger.debug("Current fragment: {0}", self.current_fragment)
self.logger.debug("First fragment: {0}", self.first_fragment)
self.logger.debug("Last fragment: {0}", self.last_fragment)
self.logger.debug("End fragment: {0}", self.end_fragment)
self.bootstrap_reload_time = fragment_duration
if self.live and not bootstrap_changed:
self.logger.debug("Bootstrap not changed, shortening timer")
self.bootstrap_reload_time /= 2
self.bootstrap_reload_time = max(self.bootstrap_reload_time,
self.bootstrap_minimal_reload_time)
def fetch_bootstrap(self, url):
res = self.session.http.get(url,
exception=StreamError,
**self.stream.request_params)
return Box.deserialize(BytesIO(res.content))
def fragment_url(self, segment, fragment):
url = absolute_url(self.stream.baseurl, self.stream.url)
return FRAGMENT_URL.format(url=url,
segment=segment,
fragment=fragment,
identifier="",
quality="")
def fragment_count(self):
table = self.fragmentruntable.payload.fragment_run_entry_table
first_fragment, end_fragment = None, None
for i, fragmentrun in enumerate(table):
if fragmentrun.discontinuity_indicator is not None:
if fragmentrun.discontinuity_indicator == 0:
break
elif fragmentrun.discontinuity_indicator > 0:
continue
if first_fragment is None:
first_fragment = fragmentrun.first_fragment
end_fragment = fragmentrun.first_fragment
fragment_duration = (fragmentrun.first_fragment_timestamp +
fragmentrun.fragment_duration)
if self.timestamp > fragment_duration:
offset = ((self.timestamp - fragment_duration) /
fragmentrun.fragment_duration)
end_fragment += int(offset)
if first_fragment is None:
first_fragment = 1
if end_fragment is None:
end_fragment = 1
return first_fragment, end_fragment
def fragment_duration(self, fragment):
fragment_duration = 0
table = self.fragmentruntable.payload.fragment_run_entry_table
time_scale = self.fragmentruntable.payload.time_scale
for i, fragmentrun in enumerate(table):
if fragmentrun.discontinuity_indicator is not None:
self.invalid_fragments.add(fragmentrun.first_fragment)
# Check for the last fragment of the stream
if fragmentrun.discontinuity_indicator == 0:
if i > 0:
prev = table[i-1]
self.end_fragment = prev.first_fragment
break
elif fragmentrun.discontinuity_indicator > 0:
continue
if fragment >= fragmentrun.first_fragment:
fragment_duration = fragmentrun.fragment_duration / time_scale
return fragment_duration
def segment_from_fragment(self, fragment):
table = self.segmentruntable.payload.segment_run_entry_table
for segment, start, end in self.iter_segment_table(table):
if fragment >= (start + 1) and fragment <= (end + 1):
break
else:
segment = 1
return segment
def iter_segment_table(self, table):
# If the first segment in the table starts at the beginning we
# can go from there, otherwise we start from the end and use the
# total fragment count to figure out where the last segment ends.
if table[0].first_segment == 1:
prev_frag = self.first_fragment - 1
for segmentrun in table:
start = prev_frag + 1
end = prev_frag + segmentrun.fragments_per_segment
yield segmentrun.first_segment, start, end
prev_frag = end
else:
prev_frag = self.last_fragment + 1
for segmentrun in reversed(table):
start = prev_frag - segmentrun.fragments_per_segment
end = prev_frag - 1
yield segmentrun.first_segment, start, end
prev_frag = start
def valid_fragment(self, fragment):
return fragment not in self.invalid_fragments
def iter_segments(self):
while not self.closed:
fragments = range(self.current_fragment, self.last_fragment + 1)
fragments = filter(self.valid_fragment, fragments)
for fragment in fragments:
self.current_fragment = fragment + 1
self.current_segment = self.segment_from_fragment(fragment)
fragment_duration = int(self.fragment_duration(fragment) * 1000)
fragment_url = self.fragment_url(self.current_segment, fragment)
fragment = Fragment(self.current_segment, fragment,
fragment_duration, fragment_url)
self.logger.debug("Adding fragment {0}-{1} to queue",
fragment.segment, fragment.fragment)
yield fragment
# End of stream
stream_end = self.end_fragment and fragment.fragment >= self.end_fragment
if self.closed or stream_end:
return
if self.wait(self.bootstrap_reload_time):
try:
self.update_bootstrap()
except StreamError as err:
self.logger.warning("Failed to update bootstrap: {0}", err)
class HDSStreamReader(SegmentedStreamReader):
__worker__ = HDSStreamWorker
__writer__ = HDSStreamWriter
def __init__(self, stream, *args, **kwargs):
SegmentedStreamReader.__init__(self, stream, *args, **kwargs)
self.logger = stream.session.logger.new_module("stream.hds")
class HDSStream(Stream):
"""
Implements the Adobe HTTP Dynamic Streaming protocol
*Attributes:*
- :attr:`baseurl` Base URL
- :attr:`url` Base path of the stream, joined with the base URL when
fetching fragments
- :attr:`bootstrap` Either a URL pointing to the bootstrap or a
bootstrap :class:`Box` object used for initial information about
the stream
- :attr:`metadata` Either `None` or a :class:`ScriptData` object
that contains metadata about the stream, such as height, width and
bitrate
"""
__shortname__ = "hds"
def __init__(self, session, baseurl, url, bootstrap, metadata=None,
timeout=60, **request_params):
Stream.__init__(self, session)
self.baseurl = baseurl
self.url = url
self.bootstrap = bootstrap
self.metadata = metadata
self.timeout = timeout
# Deep copy request params to make it mutable
self.request_params = deepcopy(request_params)
parsed = urlparse(self.url)
if parsed.query:
params = parse_qsl(parsed.query)
if params:
if not self.request_params.get("params"):
self.request_params["params"] = {}
self.request_params["params"].update(params)
self.url = urlunparse(
(parsed.scheme, parsed.netloc, parsed.path, None, None, None)
)
def __repr__(self):
return ("<HDSStream({0!r}, {1!r}, {2!r},"
" metadata={3!r}, timeout={4!r})>").format(self.baseurl,
self.url,
self.bootstrap,
self.metadata,
self.timeout)
def __json__(self):
if isinstance(self.bootstrap, Box):
bootstrap = base64.b64encode(self.bootstrap.serialize())
else:
bootstrap = self.bootstrap
if isinstance(self.metadata, ScriptData):
metadata = self.metadata.__dict__
else:
metadata = self.metadata
return dict(type=HDSStream.shortname(), baseurl=self.baseurl,
url=self.url, bootstrap=bootstrap, metadata=metadata)
def open(self):
reader = HDSStreamReader(self)
reader.open()
return reader
@classmethod
def parse_manifest(cls, session, url, timeout=60, pvswf=None,
**request_params):
"""Parses a HDS manifest and returns its substreams.
:param url: The URL to the manifest.
:param timeout: How long to wait for data to be returned from
from the stream before raising an error.
:param pvswf: URL of player SWF for Akamai HD player verification.
"""
if not request_params:
request_params = {}
request_params["headers"] = request_params.get("headers", {})
request_params["params"] = request_params.get("params", {})
# These params are reserved for internal use
request_params.pop("exception", None)
request_params.pop("stream", None)
request_params.pop("timeout", None)
request_params.pop("url", None)
if "akamaihd" in url:
request_params["params"]["hdcore"] = HDCORE_VERSION
res = session.http.get(url, exception=IOError, **request_params)
manifest = session.http.xml(res, "manifest XML", ignore_ns=True,
exception=IOError)
parsed = urlparse(url)
baseurl = manifest.findtext("baseURL")
baseheight = manifest.findtext("height")
bootstraps = {}
streams = {}
if not baseurl:
baseurl = urljoin(url, os.path.dirname(parsed.path))
if not baseurl.endswith("/"):
baseurl += "/"
for bootstrap in manifest.findall("bootstrapInfo"):
name = bootstrap.attrib.get("id") or "_global"
url = bootstrap.attrib.get("url")
if url:
box = absolute_url(baseurl, url)
else:
data = base64.b64decode(bytes(bootstrap.text, "utf8"))
box = Box.deserialize(BytesIO(data))
bootstraps[name] = box
pvtoken = manifest.findtext("pv-2.0")
if pvtoken:
if not pvswf:
raise IOError("This manifest requires the 'pvswf' parameter "
"to verify the SWF")
params = cls._pv_params(session, pvswf, pvtoken, **request_params)
request_params["params"].update(params)
for media in manifest.findall("media"):
url = media.attrib.get("url")
bootstrapid = media.attrib.get("bootstrapInfoId", "_global")
href = media.attrib.get("href")
if url and bootstrapid:
bootstrap = bootstraps.get(bootstrapid)
if not bootstrap:
continue
bitrate = media.attrib.get("bitrate")
streamid = media.attrib.get("streamId")
height = media.attrib.get("height")
if height:
quality = height + "p"
elif bitrate:
quality = bitrate + "k"
elif streamid:
quality = streamid
elif baseheight:
quality = baseheight + "p"
else:
quality = "live"
metadata = media.findtext("metadata")
if metadata:
metadata = base64.b64decode(bytes(metadata, "utf8"))
metadata = ScriptData.deserialize(BytesIO(metadata))
else:
metadata = None
stream = HDSStream(session, baseurl, url, bootstrap,
metadata=metadata, timeout=timeout,
**request_params)
streams[quality] = stream
elif href:
url = absolute_url(baseurl, href)
child_streams = cls.parse_manifest(session, url,
timeout=timeout,
**request_params)
for name, stream in child_streams.items():
# Override stream name if bitrate is available in parent
# manifest but not the child one.
bitrate = media.attrib.get("bitrate")
if bitrate and not re.match("^(\d+)k$", name):
name = bitrate + "k"
streams[name] = stream
return streams
@classmethod
def _pv_params(cls, session, pvswf, pv, **request_params):
"""Returns any parameters needed for Akamai HD player verification.
Algorithm originally documented by KSV, source:
http://stream-recorder.com/forum/showpost.php?p=43761&postcount=13
"""
try:
data, hdntl = pv.split(";")
except ValueError:
data = pv
hdntl = ""
cache = Cache(filename="stream.json")
key = "akamaihd-player:" + pvswf
cached = cache.get(key)
request_params = deepcopy(request_params)
headers = request_params.pop("headers", {})
if cached:
headers["If-Modified-Since"] = cached["modified"]
swf = session.http.get(pvswf, headers=headers, **request_params)
if cached and swf.status_code == 304: # Server says not modified
hash = cached["hash"]
else:
# Calculate SHA-256 hash of the uncompressed SWF file, base-64
# encoded
hash = sha256()
hash.update(swfdecompress(swf.content))
hash = base64.b64encode(hash.digest()).decode("ascii")
modified = swf.headers.get("Last-Modified", "")
# Only save in cache if a valid date is given
if len(modified) < 40:
cache.set(key, dict(hash=hash, modified=modified))
msg = "st=0~exp=9999999999~acl=*~data={0}!{1}".format(data, hash)
auth = hmac.new(AKAMAIHD_PV_KEY, msg.encode("ascii"), sha256)
pvtoken = "{0}~hmac={1}".format(msg, auth.hexdigest())
# The "hdntl" parameter can be accepted as a cookie or passed in the
# query string, but the "pvtoken" parameter can only be in the query
# string
params = [("pvtoken", pvtoken)]
params.extend(parse_qsl(hdntl, keep_blank_values=True))
return params
livestreamer-1.12.2/src/livestreamer/stream/flvconcat.py 0000644 0001750 0001750 00000025035 12521217321 024513 0 ustar chrippa chrippa 0000000 0000000 from __future__ import division
from collections import namedtuple
from io import IOBase
from itertools import chain, islice
from threading import Thread
from ..buffers import RingBuffer
from ..packages.flashmedia import FLVError
from ..packages.flashmedia.tag import (AudioData, AACAudioData, VideoData,
AVCVideoData, VideoCommandFrame,
Header, ScriptData, Tag)
from ..packages.flashmedia.tag import (AAC_PACKET_TYPE_SEQUENCE_HEADER,
AVC_PACKET_TYPE_SEQUENCE_HEADER,
AUDIO_CODEC_ID_AAC,
VIDEO_CODEC_ID_AVC,
TAG_TYPE_AUDIO,
TAG_TYPE_VIDEO)
__all__ = ["extract_flv_header_tags", "FLVTagConcat", "FLVTagConcatIO"]
FLVHeaderTags = namedtuple("FLVHeaderTags", "metadata aac vc")
def iter_flv_tags(fd=None, buf=None, strict=False, skip_header=False):
if not (fd or buf):
return
offset = 0
if not skip_header:
if fd:
Header.deserialize(fd)
elif buf:
header, offset = Header.deserialize_from(buf, offset)
while fd or buf and offset < len(buf):
try:
if fd:
tag = Tag.deserialize(fd, strict=strict)
elif buf:
tag, offset = Tag.deserialize_from(buf, offset, strict=strict)
except (IOError, FLVError) as err:
if "Insufficient tag header" in str(err):
break
raise IOError(err)
yield tag
def extract_flv_header_tags(stream):
fd = stream.open()
metadata = aac_header = avc_header = None
for tag_index, tag in enumerate(iter_flv_tags(fd)):
if isinstance(tag.data, ScriptData) and tag.data.name == "onMetaData":
metadata = tag
elif (isinstance(tag.data, VideoData) and
isinstance(tag.data.data, AVCVideoData)):
if tag.data.data.type == AVC_PACKET_TYPE_SEQUENCE_HEADER:
avc_header = tag
elif (isinstance(tag.data, AudioData) and
isinstance(tag.data.data, AACAudioData)):
if tag.data.data.type == AAC_PACKET_TYPE_SEQUENCE_HEADER:
aac_header = tag
if aac_header and avc_header and metadata:
break
# Give up after 10 tags
if tag_index == 9:
break
return FLVHeaderTags(metadata, aac_header, avc_header)
class FLVTagConcat(object):
def __init__(self, duration=None, tags=[], has_video=True, has_audio=True,
flatten_timestamps=False, sync_headers=False):
self.duration = duration
self.flatten_timestamps = flatten_timestamps
self.has_audio = has_audio
self.has_video = has_video
self.sync_headers = sync_headers
self.tags = tags
if not (has_audio and has_video):
self.sync_headers = False
self.audio_header_written = False
self.flv_header_written = False
self.video_header_written = False
self.timestamps_add = {}
self.timestamps_orig = {}
self.timestamps_sub = {}
@property
def headers_written(self):
return self.audio_header_written and self.video_header_written
def verify_tag(self, tag):
if tag.filter:
raise IOError("Tag has filter flag set, probably encrypted")
# Only AAC and AVC has detectable headers
if isinstance(tag.data, AudioData) and tag.data.codec != AUDIO_CODEC_ID_AAC:
self.audio_header_written = True
if isinstance(tag.data, VideoData) and tag.data.codec != VIDEO_CODEC_ID_AVC:
self.video_header_written = True
# Make sure there is no timestamp gap between audio and video when syncing
if self.sync_headers and self.timestamps_sub and not self.headers_written:
self.timestamps_sub = {}
if isinstance(tag.data, AudioData):
if isinstance(tag.data.data, AACAudioData):
if tag.data.data.type == AAC_PACKET_TYPE_SEQUENCE_HEADER:
if self.audio_header_written:
return
self.audio_header_written = True
else:
if self.sync_headers and not self.headers_written:
return
if not self.audio_header_written:
return
else:
if self.sync_headers and not self.headers_written:
return
elif isinstance(tag.data, VideoData):
if isinstance(tag.data.data, AVCVideoData):
if tag.data.data.type == AVC_PACKET_TYPE_SEQUENCE_HEADER:
if self.video_header_written:
return
self.video_header_written = True
else:
if self.sync_headers and not self.headers_written:
return
if not self.video_header_written:
return
elif isinstance(tag.data.data, VideoCommandFrame):
return
else:
if self.sync_headers and not self.headers_written:
return
elif isinstance(tag.data, ScriptData):
if tag.data.name == "onMetaData":
if self.duration:
tag.data.value["duration"] = self.duration
elif "duration" in tag.data.value:
del tag.data.value["duration"]
else:
return False
return True
def adjust_tag_gap(self, tag):
timestamp_gap = tag.timestamp - self.timestamps_orig.get(tag.type, 0)
timestamp_sub = self.timestamps_sub.get(tag.type)
if timestamp_gap > 1000 and timestamp_sub is not None:
self.timestamps_sub[tag.type] += timestamp_gap
self.timestamps_orig[tag.type] = tag.timestamp
def adjust_tag_timestamp(self, tag):
timestamp_offset_sub = self.timestamps_sub.get(tag.type)
if timestamp_offset_sub is None and tag not in self.tags:
self.timestamps_sub[tag.type] = tag.timestamp
timestamp_offset_sub = self.timestamps_sub.get(tag.type)
timestamp_offset_add = self.timestamps_add.get(tag.type)
if timestamp_offset_add:
tag.timestamp = max(0, tag.timestamp + timestamp_offset_add)
elif timestamp_offset_sub:
tag.timestamp = max(0, tag.timestamp - timestamp_offset_sub)
def analyze_tags(self, tag_iterator):
tags = list(islice(tag_iterator, 10))
audio_tags = len(list(filter(lambda t: t.type == TAG_TYPE_AUDIO, tags)))
video_tags = len(list(filter(lambda t: t.type == TAG_TYPE_VIDEO, tags)))
self.has_audio = audio_tags > 0
self.has_video = video_tags > 0
if not (self.has_audio and self.has_video):
self.sync_headers = False
return tags
def iter_tags(self, fd=None, buf=None, skip_header=None):
if skip_header is None:
skip_header = not not self.tags
tags_iterator = filter(None, self.tags)
flv_iterator = iter_flv_tags(fd=fd, buf=buf, skip_header=skip_header)
for tag in chain(tags_iterator, flv_iterator):
yield tag
def iter_chunks(self, fd=None, buf=None, skip_header=None):
"""Reads FLV tags from fd or buf and returns them with adjusted
timestamps."""
timestamps = dict(self.timestamps_add)
tag_iterator = self.iter_tags(fd=fd, buf=buf, skip_header=skip_header)
if not self.flv_header_written:
analyzed_tags = self.analyze_tags(tag_iterator)
else:
analyzed_tags = []
for tag in chain(analyzed_tags, tag_iterator):
if not self.flv_header_written:
flv_header = Header(has_video=self.has_video,
has_audio=self.has_audio)
yield flv_header.serialize()
self.flv_header_written = True
if self.verify_tag(tag):
self.adjust_tag_gap(tag)
self.adjust_tag_timestamp(tag)
if self.duration:
norm_timestamp = tag.timestamp / 1000
if norm_timestamp > self.duration:
break
yield tag.serialize()
timestamps[tag.type] = tag.timestamp
if not self.flatten_timestamps:
self.timestamps_add = timestamps
self.tags = []
class FLVTagConcatWorker(Thread):
def __init__(self, iterator, stream):
self.error = None
self.stream = stream
self.stream_iterator = iterator
self.concater = FLVTagConcat(stream.duration, stream.tags,
**stream.concater_params)
Thread.__init__(self)
self.daemon = True
def run(self):
for fd in self.stream_iterator:
try:
chunks = self.concater.iter_chunks(
fd, skip_header=self.stream.skip_header
)
for chunk in chunks:
self.stream.buffer.write(chunk)
if not self.running:
return
except IOError as err:
self.error = err
break
self.stop()
def stop(self):
self.running = False
self.stream.buffer.close()
def start(self):
self.running = True
return Thread.start(self)
class FLVTagConcatIO(IOBase):
__worker__ = FLVTagConcatWorker
__log_name__ = "stream.flv_concat"
def __init__(self, session, duration=None, tags=[], skip_header=None,
timeout=30, **concater_params):
self.session = session
self.timeout = timeout
self.logger = session.logger.new_module(self.__log_name__)
self.concater_params = concater_params
self.duration = duration
self.skip_header = skip_header
self.tags = tags
def open(self, iterator):
self.buffer = RingBuffer(self.session.get_option("ringbuffer-size"))
self.worker = self.__worker__(iterator, self)
self.worker.start()
def close(self):
self.worker.stop()
if self.worker.is_alive():
self.worker.join()
def read(self, size=-1):
if not self.buffer:
return b""
if self.worker.error:
raise self.worker.error
return self.buffer.read(size, block=self.worker.is_alive(),
timeout=self.timeout)
livestreamer-1.12.2/src/livestreamer/stream/akamaihd.py 0000644 0001750 0001750 00000017310 12521217321 024270 0 ustar chrippa chrippa 0000000 0000000 import base64
import io
import hashlib
import hmac
import random
from .stream import Stream
from .wrappers import StreamIOThreadWrapper, StreamIOIterWrapper
from ..buffers import Buffer
from ..compat import str, bytes, urlparse
from ..exceptions import StreamError
from ..utils import swfdecompress
from ..packages.flashmedia import FLV, FLVError
from ..packages.flashmedia.tag import ScriptData
class TokenGenerator(object):
def __init__(self, stream):
self.stream = stream
def generate(self):
raise NotImplementedError
class Auth3TokenGenerator(TokenGenerator):
def generate(self):
if not self.stream.swf:
raise StreamError("A SWF URL is required to create session token")
res = self.stream.session.http.get(self.stream.swf,
exception=StreamError)
data = swfdecompress(res.content)
md5 = hashlib.md5()
md5.update(data)
data = bytes(self.stream.sessionid, "ascii") + md5.digest()
sig = hmac.new(b"foo", data, hashlib.sha1)
b64 = base64.encodestring(sig.digest())
token = str(b64, "ascii").replace("\n", "")
return token
def cache_bust_string(length):
rval = ""
for i in range(length):
rval += chr(65 + int(round(random.random() * 25)))
return rval
class AkamaiHDStreamIO(io.IOBase):
Version = "2.5.8"
FlashVersion = "LNX 11,1,102,63"
StreamURLFormat = "{host}/{streamname}"
ControlURLFormat = "{host}/control/{streamname}"
ControlData = b":)"
TokenGenerators = {
"c11e59dea648d56e864fc07a19f717b9": Auth3TokenGenerator
}
StatusComplete = 3
StatusError = 4
Errors = {
1: "Stream not found",
2: "Track not found",
3: "Seek out of bounds",
4: "Authentication failed",
5: "DVR disabled",
6: "Invalid bitrate test"
}
def __init__(self, session, url, swf=None, seek=None):
parsed = urlparse(url)
self.session = session
self.logger = self.session.logger.new_module("stream.akamaihd")
self.host = ("{scheme}://{netloc}").format(scheme=parsed.scheme, netloc=parsed.netloc)
self.streamname = parsed.path[1:]
self.swf = swf
self.seek = seek
def open(self):
self.guid = cache_bust_string(12)
self.islive = None
self.sessionid = None
self.flv = None
self.buffer = Buffer()
self.completed_handshake = False
url = self.StreamURLFormat.format(host=self.host, streamname=self.streamname)
params = self._create_params(seek=self.seek)
self.logger.debug("Opening host={host} streamname={streamname}",
host=self.host, streamname=self.streamname)
try:
res = self.session.http.get(url, stream=True, params=params)
self.fd = StreamIOIterWrapper(res.iter_content(8192))
except Exception as err:
raise StreamError(str(err))
self.handshake(self.fd)
return self
def handshake(self, fd):
try:
self.flv = FLV(fd)
except FLVError as err:
raise StreamError(str(err))
self.buffer.write(self.flv.header.serialize())
self.logger.debug("Attempting to handshake")
for i, tag in enumerate(self.flv):
if i == 10:
raise StreamError("No OnEdge metadata in FLV after 10 tags, probably not a AkamaiHD stream")
self.process_tag(tag, exception=StreamError)
if self.completed_handshake:
self.logger.debug("Handshake successful")
break
def process_tag(self, tag, exception=IOError):
if isinstance(tag.data, ScriptData) and tag.data.name == "onEdge":
self._on_edge(tag.data.value, exception=exception)
self.buffer.write(tag.serialize())
def send_token(self, token):
headers = { "x-Akamai-Streaming-SessionToken": token }
self.logger.debug("Sending new session token")
self.send_control("sendingNewToken", headers=headers,
swf=self.swf)
def send_control(self, cmd, headers=None, **params):
if not headers:
headers = {}
url = self.ControlURLFormat.format(host=self.host,
streamname=self.streamname)
headers["x-Akamai-Streaming-SessionID"] = self.sessionid
params = self._create_params(cmd=cmd, **params)
return self.session.http.post(url,
headers=headers,
params=params,
data=self.ControlData,
exception=StreamError)
def read(self, size=-1):
if not (self.flv and self.fd):
return b""
if self.buffer.length:
return self.buffer.read(size)
else:
return self.fd.read(size)
def _create_params(self, **extra):
params = dict(v=self.Version, fp=self.FlashVersion,
r=cache_bust_string(5), g=self.guid)
params.update(extra)
return params
def _generate_session_token(self, data64):
swfdata = base64.decodestring(bytes(data64, "ascii"))
md5 = hashlib.md5()
md5.update(swfdata)
hash = md5.hexdigest()
if hash in self.TokenGenerators:
generator = self.TokenGenerators[hash](self)
return generator.generate()
else:
raise StreamError(("No token generator available for hash '{0}'").format(hash))
def _on_edge(self, data, exception=IOError):
def updateattr(attr, key):
if key in data:
setattr(self, attr, data[key])
self.logger.debug("onEdge data")
for key, val in data.items():
if isinstance(val, str):
val = val[:50]
self.logger.debug(" {key}={val}",
key=key, val=val)
updateattr("islive", "isLive")
updateattr("sessionid", "session")
updateattr("status", "status")
updateattr("streamname", "streamName")
if self.status == self.StatusComplete:
self.flv = None
elif self.status == self.StatusError:
errornum = data["errorNumber"]
if errornum in self.Errors:
msg = self.Errors[errornum]
else:
msg = "Unknown error"
raise exception("onEdge error: " + msg)
if not self.completed_handshake:
if "data64" in data:
sessiontoken = self._generate_session_token(data["data64"])
else:
sessiontoken = None
self.send_token(sessiontoken)
self.completed_handshake = True
class AkamaiHDStream(Stream):
"""
Implements the AkamaiHD Adaptive Streaming protocol
*Attributes:*
- :attr:`url` URL to the stream
- :attr:`swf` URL to a SWF used by the handshake protocol
- :attr:`seek` Position to seek to when opening the stream
"""
__shortname__ = "akamaihd"
def __init__(self, session, url, swf=None, seek=None):
Stream.__init__(self, session)
self.seek = seek
self.swf = swf
self.url = url
def __repr__(self):
return ("<AkamaiHDStream({0!r}, "
"swf={1!r})>".format(self.url, self.swf))
def __json__(self):
return dict(type=AkamaiHDStream.shortname(),
url=self.url, swf=self.swf)
def open(self):
stream = AkamaiHDStreamIO(self.session, self.url,
self.swf, self.seek)
return StreamIOThreadWrapper(self.session, stream.open())
__all__ = ["AkamaiHDStream"]
livestreamer-1.12.2/src/livestreamer/stream/__init__.py 0000644 0001750 0001750 00000000661 12521217321 024271 0 ustar chrippa chrippa 0000000 0000000 from ..exceptions import StreamError
from .stream import Stream
from .akamaihd import AkamaiHDStream
from .hds import HDSStream
from .hls import HLSStream
from .http import HTTPStream
from .rtmpdump import RTMPStream
from .streamprocess import StreamProcess
from .wrappers import StreamIOWrapper, StreamIOIterWrapper, StreamIOThreadWrapper
from .flvconcat import extract_flv_header_tags
from .playlist import Playlist, FLVPlaylist
livestreamer-1.12.2/src/livestreamer/plugins/ 0000755 0001750 0001750 00000000000 12521217500 022342 5 ustar chrippa chrippa 0000000 0000000 livestreamer-1.12.2/src/livestreamer/plugins/zdf_mediathek.py 0000644 0001750 0001750 00000005327 12521217321 025522 0 ustar chrippa chrippa 0000000 0000000 import re
from livestreamer.plugin import Plugin
from livestreamer.plugin.api import http, validate
from livestreamer.stream import HDSStream, HLSStream, RTMPStream
API_URL = "http://www.zdf.de/ZDFmediathek/xmlservice/web/beitragsDetails"
QUALITY_WEIGHTS = {
"hd": 720,
"veryhigh": 480,
"high": 240,
"med": 176,
"low": 112
}
STREAMING_TYPES = {
"h264_aac_f4f_http_f4m_http": (
"HDS", HDSStream.parse_manifest
),
"h264_aac_ts_http_m3u8_http": (
"HLS", HLSStream.parse_variant_playlist
)
}
_url_re = re.compile("""
http(s)?://(\w+\.)?zdf.de/zdfmediathek(\#)?/.+
/(live|video)
/(?P<video_id>\d+)
""", re.VERBOSE | re.IGNORECASE)
_schema = validate.Schema(
validate.xml_findall("video/formitaeten/formitaet"),
[
validate.union({
"type": validate.get("basetype"),
"quality": validate.xml_findtext("quality"),
"url": validate.all(
validate.xml_findtext("url"),
validate.url()
)
})
]
)
class zdf_mediathek(Plugin):
@classmethod
def can_handle_url(cls, url):
return _url_re.match(url)
@classmethod
def stream_weight(cls, key):
weight = QUALITY_WEIGHTS.get(key)
if weight:
return weight, "zdf_mediathek"
return Plugin.stream_weight(key)
def _create_rtmp_stream(self, url):
return RTMPStream(self.session, {
"rtmp": self._get_meta_url(url),
"pageUrl": self.url,
})
def _get_meta_url(self, url):
res = http.get(url, exception=IOError)
root = http.xml(res, exception=IOError)
return root.findtext("default-stream-url")
def _get_streams(self):
match = _url_re.match(self.url)
video_id = match.group("video_id")
res = http.get(API_URL, params=dict(ak="web", id=video_id))
fmts = http.xml(res, schema=_schema)
streams = {}
for fmt in fmts:
if fmt["type"] in STREAMING_TYPES:
name, parser = STREAMING_TYPES[fmt["type"]]
try:
streams.update(parser(self.session, fmt["url"]))
except IOError as err:
self.logger.error("Failed to extract {0} streams: {1}",
name, err)
elif fmt["type"] == "h264_aac_mp4_rtmp_zdfmeta_http":
name = fmt["quality"]
try:
streams[name] = self._create_rtmp_stream(fmt["url"])
except IOError as err:
self.logger.error("Failed to extract RTMP stream '{0}': {1}",
name, err)
return streams
__plugin__ = zdf_mediathek
livestreamer-1.12.2/src/livestreamer/plugins/youtube.py 0000644 0001750 0001750 00000014174 12521217321 024420 0 ustar chrippa chrippa 0000000 0000000 import re
from livestreamer.plugin import Plugin, PluginError
from livestreamer.plugin.api import http, validate
from livestreamer.plugin.api.utils import parse_query
from livestreamer.stream import HTTPStream, HLSStream
API_KEY = "AIzaSyBDBi-4roGzWJN4du9TuDMLd_jVTcVkKz4"
API_BASE = "https://www.googleapis.com/youtube/v3"
API_SEARCH_URL = API_BASE + "/search"
API_VIDEO_INFO = "http://youtube.com/get_video_info"
HLS_HEADERS = {
"User-Agent": "Mozilla/5.0"
}
def parse_stream_map(stream_map):
if not stream_map:
return []
return [parse_query(s) for s in stream_map.split(",")]
def parse_fmt_list(formatsmap):
formats = {}
if not formatsmap:
return formats
for format in formatsmap.split(","):
s = format.split("/")
(w, h) = s[1].split("x")
formats[int(s[0])] = "{0}p".format(h)
return formats
_config_schema = validate.Schema(
{
validate.optional("fmt_list"): validate.all(
validate.text,
validate.transform(parse_fmt_list)
),
validate.optional("url_encoded_fmt_stream_map"): validate.all(
validate.text,
validate.transform(parse_stream_map),
[{
"itag": validate.all(
validate.text,
validate.transform(int)
),
"quality": validate.text,
"url": validate.url(scheme="http"),
validate.optional("s"): validate.text,
validate.optional("stereo3d"): validate.all(
validate.text,
validate.transform(int),
validate.transform(bool)
),
}]
),
validate.optional("adaptive_fmts"): validate.all(
validate.text,
validate.transform(parse_stream_map),
[{
validate.optional("s"): validate.text,
"type": validate.all(
validate.text,
validate.transform(lambda t: t.split(";")[0].split("/")),
[validate.text, validate.text]
),
"url": validate.all(
validate.url(scheme="http")
)
}]
),
validate.optional("hlsvp"): validate.text,
validate.optional("live_playback"): validate.transform(bool),
"status": validate.text
}
)
_search_schema = validate.Schema(
{
"items": [{
"id": {
"videoId": validate.text
}
}]
},
validate.get("items")
)
_channelid_re = re.compile('meta itemprop="channelId" content="([^"]+)"')
_url_re = re.compile("""
http(s)?://(\w+\.)?youtube.com
(?:
(?:
/(watch.+v=|embed/|v/)
(?P<video_id>[0-9A-z_-]{11})
)
|
(?:
/(user|channel)/(?P<user>[^/?]+)
)
)
""", re.VERBOSE)
class YouTube(Plugin):
@classmethod
def can_handle_url(self, url):
return _url_re.match(url)
@classmethod
def stream_weight(cls, stream):
match = re.match("(\w+)_3d", stream)
if match:
weight, group = Plugin.stream_weight(match.group(1))
weight -= 1
group = "youtube_3d"
else:
weight, group = Plugin.stream_weight(stream)
return weight, group
def _find_channel_video(self):
res = http.get(self.url)
match = _channelid_re.search(res.text)
if not match:
return
channel_id = match.group(1)
query = {
"channelId": channel_id,
"type": "video",
"eventType": "live",
"part": "id",
"key": API_KEY
}
res = http.get(API_SEARCH_URL, params=query)
videos = http.json(res, schema=_search_schema)
for video in videos:
video_id = video["id"]["videoId"]
return video_id
def _get_stream_info(self, url):
match = _url_re.match(url)
user = match.group("user")
if user:
video_id = self._find_channel_video()
else:
video_id = match.group("video_id")
if not video_id:
return
params = {
"video_id": video_id,
"el": "player_embedded"
}
res = http.get(API_VIDEO_INFO, params=params)
return parse_query(res.text, name="config", schema=_config_schema)
def _get_streams(self):
info = self._get_stream_info(self.url)
if not info:
return
formats = info.get("fmt_list")
streams = {}
protected = False
for stream_info in info.get("url_encoded_fmt_stream_map", []):
if stream_info.get("s"):
protected = True
continue
stream = HTTPStream(self.session, stream_info["url"])
name = formats.get(stream_info["itag"]) or stream_info["quality"]
if stream_info.get("stereo3d"):
name += "_3d"
streams[name] = stream
# Extract audio streams from the DASH format list
for stream_info in info.get("adaptive_fmts", []):
if stream_info.get("s"):
protected = True
continue
stream_type, stream_format = stream_info["type"]
if stream_type != "audio":
continue
stream = HTTPStream(self.session, stream_info["url"])
name = "audio_{0}".format(stream_format)
streams[name] = stream
hls_playlist = info.get("hlsvp")
if hls_playlist:
try:
hls_streams = HLSStream.parse_variant_playlist(
self.session, hls_playlist, headers=HLS_HEADERS, namekey="pixels"
)
streams.update(hls_streams)
except IOError as err:
self.logger.warning("Failed to extract HLS streams: {0}", err)
if not streams and protected:
raise PluginError("This plugin does not support protected videos, "
"try youtube-dl instead")
return streams
__plugin__ = YouTube
livestreamer-1.12.2/src/livestreamer/plugins/weeb.py 0000644 0001750 0001750 00000006436 12521217321 023650 0 ustar chrippa chrippa 0000000 0000000 import re
from livestreamer.plugin import Plugin, PluginError
from livestreamer.plugin.api import http, validate
from livestreamer.plugin.api.utils import parse_query
from livestreamer.stream import RTMPStream
API_URL = "http://weeb.tv/api/setPlayer"
SWF_URL = "http://static2.weeb.tv/static2/player.swf"
HEADERS = {
"Referer": SWF_URL
}
PARAMS_KEY_MAP = {
"0": "status",
"10": "rtmp",
"11": "playpath",
"13": "block_type",
"14": "block_time",
"16": "reconnect_time",
"20": "multibitrate",
"73": "token"
}
BLOCKED_MSG_FORMAT = (
"You have crossed the free viewing limit. You have been blocked for "
"{0} minutes. Try again in {1} minutes"
)
BLOCK_TYPE_VIEWING_LIMIT = 1
BLOCK_TYPE_NO_SLOTS = 11
_url_re = re.compile("http(s)?://(\w+\.)?weeb.tv/(channel|online)/(?P<channel>[^/&?]+)")
_schema = validate.Schema(
dict,
validate.map(lambda k, v: (PARAMS_KEY_MAP.get(k, k), v)),
validate.any(
{
"status": validate.transform(int),
"rtmp": validate.url(scheme="rtmp"),
"playpath": validate.text,
"multibitrate": validate.all(
validate.transform(int),
validate.transform(bool)
),
"block_type": validate.transform(int),
validate.optional("token"): validate.text,
validate.optional("block_time"): validate.text,
validate.optional("reconnect_time"): validate.text,
},
{
"status": validate.transform(int),
},
)
)
class Weeb(Plugin):
@classmethod
def can_handle_url(self, url):
return _url_re.match(url)
def _get_streams(self):
match = _url_re.match(self.url)
channel_name = match.group("channel")
form = {
"cid": channel_name,
"watchTime": 0,
"firstConnect": 1,
"ip": "NaN"
}
res = http.post(API_URL, data=form, headers=HEADERS)
params = parse_query(res.text, schema=_schema)
if params["status"] <= 0:
return
if params["block_type"] != 0:
if params["block_type"] == BLOCK_TYPE_VIEWING_LIMIT:
msg = BLOCKED_MSG_FORMAT.format(
params.get("block_time", "UNKNOWN"),
params.get("reconnect_time", "UNKNOWN")
)
raise PluginError(msg)
elif params["block_type"] == BLOCK_TYPE_NO_SLOTS:
raise PluginError("No free slots available")
else:
raise PluginError("Blocked for unknown reasons")
if "token" not in params:
raise PluginError("Server seems busy, retry again later")
streams = {}
stream_names = ["sd"]
if params["multibitrate"]:
stream_names += ["hd"]
for stream_name in stream_names:
playpath = params["playpath"]
if stream_name == "hd":
playpath += "HI"
stream = RTMPStream(self.session, {
"rtmp": "{0}/{1}".format(params["rtmp"], playpath),
"pageUrl": self.url,
"swfVfy": SWF_URL,
"weeb": params["token"],
"live": True
})
streams[stream_name] = stream
return streams
__plugin__ = Weeb
livestreamer-1.12.2/src/livestreamer/plugins/wattv.py 0000644 0001750 0001750 00000004445 12521217321 024071 0 ustar chrippa chrippa 0000000 0000000 import hashlib
import re
from livestreamer.plugin import Plugin
from livestreamer.plugin.api import http
from livestreamer.stream import HDSStream
# Got the secret from the swf with rev number location
# (tv/wat/player/media/Media.as)
TOKEN_SECRET = '9b673b13fa4682ed14c3cfa5af5310274b514c4133e9b3a81e6e3aba009l2564'
_url_re = re.compile("http(s)?://(\w+\.)?wat.tv/")
_video_id_re = re.compile("href=\"http://m.wat.tv/video/([^\"]+)", re.IGNORECASE)
class WAT(Plugin):
@classmethod
def can_handle_url(cls, url):
return _url_re.match(url)
def _get_streams(self):
res = http.get(self.url)
match = video_id = _video_id_re.search(res.text)
if not match:
return
video_id = match.group(1)
# TODO: Replace with "yield from" when dropping Python 2.
for __ in self._create_streams('web', video_id).items():
yield __
for __ in self._create_streams('webhd', video_id).items():
yield __
def _create_streams(self, type_, video_id):
url = self._generate_security_url(type_, video_id)
res = http.get(url)
return HDSStream.parse_manifest(self.session, res.text, cookies=res.cookies)
def _generate_security_url(self, type_, video_id):
token = self._generate_security_token(type_, video_id)
return ("http://www.wat.tv/get/{type_}/{video_id}?token={token}"
"&domain=www.wat.tv&refererURL=wat.tv&revision=04.00.719%0A&"
"synd=0&helios=1&context=playerWat&pub=1&country=FR"
"&sitepage=WAT%2Ftv%2Ft%2Finedit%2Ftf1%2Fparamount_pictures_"
"france&lieu=wat&playerContext=CONTEXT_WAT&getURL=1"
"&version=LNX%2014,0,0,125").format(**locals())
def _generate_security_token(self, type_, video_id):
# Get timestamp
res = http.get('http://www.wat.tv/servertime')
timestamp = int(res.text.split('|')[0])
timestamp_hex = format(timestamp, 'x').rjust(8, '0')
# Player id
player_prefix = "/{0}/{1}".format(type_, video_id)
# Create the token
data = (TOKEN_SECRET + player_prefix + timestamp_hex).encode('utf8')
token = hashlib.md5(data)
token = "{0}/{1}".format(token.hexdigest(), timestamp_hex)
return token
__plugin__ = WAT
livestreamer-1.12.2/src/livestreamer/plugins/viasat_embed.py 0000644 0001750 0001750 00000001070 12521217321 025336 0 ustar chrippa chrippa 0000000 0000000 import re
from livestreamer.plugin import Plugin
from livestreamer.plugin.api import http
_url_re = re.compile("http(s)?://(www\.)?tv(3|6|8|10)\.se")
_embed_re = re.compile('<iframe class="iframe-player" src="([^"]+)">')
class ViasatEmbed(Plugin):
@classmethod
def can_handle_url(self, url):
return _url_re.match(url)
def _get_streams(self):
res = http.get(self.url)
match = _embed_re.search(res.text)
if match:
url = match.group(1)
return self.session.streams(url)
__plugin__ = ViasatEmbed
livestreamer-1.12.2/src/livestreamer/plugins/viasat.py 0000644 0001750 0001750 00000005726 12521217321 024216 0 ustar chrippa chrippa 0000000 0000000 """Plugin for Viasat's on demand content sites, such as tv6play.se."""
import re
from livestreamer.exceptions import PluginError
from livestreamer.plugin import Plugin
from livestreamer.plugin.api import StreamMapper, http, validate
from livestreamer.stream import HDSStream, HLSStream, RTMPStream
from livestreamer.utils import rtmpparse
STREAM_API_URL = "http://playapi.mtgx.tv/v3/videos/stream/{0}"
_swf_url_re = re.compile("data-flashplayer-url=\"([^\"]+)\"")
_player_data_re = re.compile("window.fluxData\s*=\s*JSON.parse\(\"(.+)\"\);")
_url_re = re.compile("""
http(s)?://(www\.)?
(?:
tv(3|6|8|10)play |
viasat4play |
play.tv3 |
juicyplay
)
\.
(?:
dk|ee|lt|lv|no|se|com
)
(/.+?/|/embed\?id=)
(?P<stream_id>\d+)
""", re.VERBOSE)
_stream_schema = validate.Schema(
{
"streams": validate.all(
{validate.text: validate.any(validate.text, int, None)},
validate.filter(lambda k, v: isinstance(v, validate.text))
)
},
validate.get("streams")
)
class Viasat(Plugin):
@classmethod
def can_handle_url(cls, url):
return _url_re.match(url)
def _get_swf_url(self):
res = http.get(self.url)
match = _swf_url_re.search(res.text)
if not match:
raise PluginError("Unable to find SWF URL in the HTML")
return match.group(1)
def _create_dynamic_streams(self, stream_type, parser, video):
try:
streams = parser(self.session, video[1])
return streams.items()
except IOError as err:
self.logger.error("Failed to extract {0} streams: {1}", stream_type, err)
def _create_rtmp_stream(self, video):
name, stream_url = video
params = {
"rtmp": stream_url,
"pageUrl": self.url,
"swfVfy": self._get_swf_url(),
}
if stream_url.endswith(".mp4"):
tcurl, playpath = rtmpparse(stream_url)
params["rtmp"] = tcurl
params["playpath"] = playpath
else:
params["live"] = True
return name, RTMPStream(self.session, params)
def _extract_streams(self, stream_id):
res = http.get(STREAM_API_URL.format(stream_id), raise_for_status=False)
stream_info = http.json(res, schema=_stream_schema)
mapper = StreamMapper(lambda pattern, video: re.search(pattern, video[1]))
mapper.map(
r"/\w+\.m3u8",
self._create_dynamic_streams,
"HLS", HLSStream.parse_variant_playlist
)
mapper.map(
r"/\w+\.f4m",
self._create_dynamic_streams,
"HDS", HDSStream.parse_manifest
)
mapper.map(r"^rtmp://", self._create_rtmp_stream)
return mapper(stream_info.items())
def _get_streams(self):
match = _url_re.match(self.url)
stream_id = match.group("stream_id")
return self._extract_streams(stream_id)
__plugin__ = Viasat
livestreamer-1.12.2/src/livestreamer/plugins/viagame.py 0000644 0001750 0001750 00000004514 12521217321 024332 0 ustar chrippa chrippa 0000000 0000000 """Plugin for Viasat's gaming site Viagame."""
import re
from livestreamer.plugin.api import http, validate
from livestreamer.plugin.api.utils import parse_json
from livestreamer.plugin.api.support_plugin import viasat
STREAM_API_URL = "http://playapi.mtgx.tv/v3/videos/stream/{0}"
_embed_url_re = re.compile(
'<meta itemprop="embedURL" content="http://www.viagame.com/embed/video/([^"]+)"'
)
_store_data_re = re.compile("window.fluxData\s*=\s*JSON.parse\(\"(.+)\"\);")
_url_re = re.compile("http(s)?://(www\.)?viagame.com/channels/.+")
_store_schema = validate.Schema(
{
"initialStoresData": [{
"instanceName": validate.text,
"storeName": validate.text,
"initialData": validate.any(dict, list)
}]
},
validate.get("initialStoresData")
)
_match_store_schema = validate.Schema(
{
"match": {
"id": validate.text,
"type": validate.text,
"videos": [{
"id": validate.text,
"play_id": validate.text,
}]
}
},
validate.get("match")
)
class Viagame(viasat.Viasat):
@classmethod
def can_handle_url(cls, url):
return _url_re.match(url)
def _find_store(self, res, name):
match = _store_data_re.search(res.text)
if not match:
return
stores_data = parse_json(match.group(1).replace('\\"', '"'),
schema=_store_schema)
if not stores_data:
return
for store in filter(lambda s: s["instanceName"] == name, stores_data):
return store
def _find_video_id(self, res):
match = _embed_url_re.search(res.text)
if match:
return match.group(1)
def _find_stream_id(self):
res = http.get(self.url)
video_id = self._find_video_id(res)
match_store = self._find_store(res, "matchStore")
if not (video_id and match_store):
return
match_store = _match_store_schema.validate(match_store["initialData"])
for video in filter(lambda v: v["id"] == video_id, match_store["videos"]):
return video["play_id"]
def _get_streams(self):
stream_id = self._find_stream_id()
if not stream_id:
return
return self._extract_streams(stream_id)
__plugin__ = Viagame
livestreamer-1.12.2/src/livestreamer/plugins/vgtv.py 0000644 0001750 0001750 00000012113 12521217321 023701 0 ustar chrippa chrippa 0000000 0000000 """Plugin for VGTV, Norwegian newspaper VG Nett's streaming service."""
import re
from livestreamer.plugin import Plugin
from livestreamer.plugin.api import http, validate
from livestreamer.stream import HDSStream, HLSStream, HTTPStream
# This will have to be set to handle "secure" HDS streams. For now we
# leave it empty, as the same streams can likely be watched with HLS.
# SWF_URL = ""
STREAM_TYPES = {
"hds": {
"parser": HDSStream.parse_manifest,
# "params": { "pvswf": SWF_URL },
"file": "manifest.f4m"
},
"hls": {
"parser": HLSStream.parse_variant_playlist,
"file" : "master.m3u8"
},
"http" : {}
}
# For now we only handle MP4.
STREAM_FORMATS = ("mp4")
INFO_URL = "http://www.vgtv.no/data/actions/videostatus/"
_url_re = re.compile("https?://(www\.)?(vgtv|vg).no")
_content_id_re = re.compile("(?:data-videoid=\"|videostatus/\?id=)(\d+)")
_url_id_re = re.compile((
"https?://(?:www\.)?vgtv.no/"
"(?:(?:#!/)?video/|(?:#!|\?)id=)(\d+)"
))
_video_schema = validate.Schema({
"status": 200,
"formats": validate.all(
dict,
validate.filter(lambda k, v: k in STREAM_TYPES),
{
validate.text: validate.all(
dict,
validate.filter(lambda k, v: k in STREAM_FORMATS),
{
validate.text: [{
"bitrate" : int,
"paths": [{
"address": validate.text,
"port" : int,
"path" : validate.text,
"filename": validate.text,
"application": validate.text,
}],
}]
}
)
}
)
})
class VGTV(Plugin):
@classmethod
def can_handle_url(self, url):
return _url_re.match(url)
def _build_url(self, **kwargs):
kwargs["scheme"] = "https" if kwargs["port"] == 443 else "http"
return "{scheme}://{address}:{port}/{path}".format(**kwargs)
def _get_streams(self):
match = _url_id_re.search(self.url)
video_id = None
# We can get the VGTV ID directly from vgtv.no URLs
if match:
video_id = match.group(1)
# If we can't, we need to get the VGTV ID from the page content
else:
res = http.get(self.url)
match = _content_id_re.search(res.text)
if match:
video_id = match.group(1)
if not video_id:
return
# Now fetch video information
self.logger.debug("Fetching video info for ID {0}", video_id)
res = http.get(INFO_URL, params=dict(id=video_id))
info = http.json(res, schema=_video_schema)
streams = {}
# At the time of writing, The previously fetched JSON doesn't
# point to playlist/manifest files, but to individual stream
# variants. Based on the provided variants, however, we can
# build the playlist URLs ourselves.
# HDS/HLS: Get all variants and produce a playlist URL.
for f in ('hds', 'hls'):
if not f in info["formats"]:
next
if not "mp4" in info["formats"][f]:
next
streamtype = STREAM_TYPES[f]
f_streams = {}
hmac = ""
# Get variants.
for stream in info["formats"][f]["mp4"]:
for p in stream["paths"]:
url = self._build_url(**p)
variant = p["filename"][:-4] # strip ".mp4"
if url in f_streams:
f_streams[url].append(variant)
else:
f_streams[url] = [variant]
if p["application"]:
hmac = "?hdnea={0}&hdcore?3.1.0".format(
p["application"]
)
# Make playlist URL and pass to parser.
for url, variants in f_streams.items():
playlist = "{0}/,{1},.mp4.csmil/{2}{3}".format(
url,
",".join(variants),
streamtype["file"],
hmac
)
parser = streamtype["parser"]
params = streamtype.get("params") or {}
try:
streams.update(parser(self.session, playlist, **params))
except IOError as err:
self.logger.error("Failed to extract {0} streams: {1}",
f.upper(), err)
# HTTP: Also make direct content URLs available for use.
http_formats = info["formats"].get("http")
if http_formats and "mp4" in http_formats:
for stream in http_formats["mp4"]:
p = stream["paths"][0]
url = "{0}/{1}".format(self._build_url(**p), p["filename"])
stream_name = "http_{0}k".format(stream["bitrate"])
streams[stream_name] = HTTPStream(self.session, url)
return streams
__plugin__ = VGTV
livestreamer-1.12.2/src/livestreamer/plugins/veetle.py 0000644 0001750 0001750 00000003153 12521217321 024203 0 ustar chrippa chrippa 0000000 0000000 import re
from livestreamer.compat import urlparse
from livestreamer.plugin import Plugin
from livestreamer.plugin.api import http, validate
from livestreamer.stream import FLVPlaylist, HTTPStream
API_URL = "http://veetle.com/index.php/stream/ajaxStreamLocation/{0}/flash"
_url_re = re.compile("""
http(s)?://(\w+\.)?veetle.com
(:?
/.*(v|view)/
(?P<channel>[^/]+/[^/&?]+)
)?
""", re.VERBOSE)
_schema = validate.Schema({
validate.optional("isLive"): bool,
"payload": validate.any(int, validate.url(scheme="http")),
"success": bool
})
class Veetle(Plugin):
@classmethod
def can_handle_url(self, url):
return _url_re.match(url)
def _get_streams(self):
self.url = http.resolve_url(self.url)
match = _url_re.match(self.url)
parsed = urlparse(self.url)
if parsed.fragment:
channel_id = parsed.fragment
elif parsed.path[:3] == '/v/':
channel_id = parsed.path.split('/')[-1]
else:
channel_id = match.group("channel")
if not channel_id:
return
channel_id = channel_id.lower().replace("/", "_")
res = http.get(API_URL.format(channel_id))
info = http.json(res, schema=_schema)
if not info["success"]:
return
if info.get("isLive"):
name = "live"
else:
name = "vod"
stream = HTTPStream(self.session, info["payload"])
# Wrap the stream in a FLVPlaylist to verify the FLV tags
stream = FLVPlaylist(self.session, [stream])
return {name: stream}
__plugin__ = Veetle
livestreamer-1.12.2/src/livestreamer/plugins/vaughnlive.py 0000644 0001750 0001750 00000003612 12521217321 025067 0 ustar chrippa chrippa 0000000 0000000 import re
from livestreamer.plugin import Plugin
from livestreamer.plugin.api import http, validate
from livestreamer.stream import RTMPStream
INFO_URL = "http://mvn.vaughnsoft.net/video/edge/{domain}_{channel}"
DOMAIN_MAP = {
"breakers": "btv",
"vapers": "vtv",
"vaughnlive": "live",
}
_url_re = re.compile("""
http(s)?://(\w+\.)?
(?P<domain>vaughnlive|breakers|instagib|vapers).tv
/(?P<channel>[^/&?]+)
""", re.VERBOSE)
_channel_not_found_re = re.compile("<title>Channel Not Found")
def decode_token(token):
return token.replace("0m0", "")
_schema = validate.Schema(
validate.transform(lambda s: s.split(";:mvnkey%")),
validate.length(2),
validate.union({
"server": validate.all(
validate.get(0),
validate.text
),
"token": validate.all(
validate.get(1),
validate.text,
validate.transform(decode_token)
)
})
)
class VaughnLive(Plugin):
@classmethod
def can_handle_url(cls, url):
return _url_re.match(url)
def _get_streams(self):
res = http.get(self.url)
if _channel_not_found_re.search(res.text):
return
match = _url_re.match(self.url)
params = match.groupdict()
params["domain"] = DOMAIN_MAP.get(params["domain"], params["domain"])
info = http.get(INFO_URL.format(**params), schema=_schema)
swfUrl = "http://vaughnlive.tv" + re.compile('swfobject.embedSWF\("(/\d+/swf/[0-9A-Za-z]+\.swf)"').findall(res.text)[0]
stream = RTMPStream(self.session, {
"rtmp": "rtmp://{0}/live".format(info["server"]),
"app": "live?{0}".format(info["token"]),
"swfVfy": swfUrl,
"pageUrl": self.url,
"live": True,
"playpath": "{domain}_{channel}".format(**params),
})
return dict(live=stream)
__plugin__ = VaughnLive
livestreamer-1.12.2/src/livestreamer/plugins/ustreamtv.py 0000644 0001750 0001750 00000050255 12521217321 024756 0 ustar chrippa chrippa 0000000 0000000 import re
from collections import namedtuple
from functools import partial
from random import randint
from time import sleep
from livestreamer.compat import urlparse, urljoin, range
from livestreamer.exceptions import StreamError, PluginError, NoStreamsError
from livestreamer.plugin import Plugin, PluginOptions
from livestreamer.plugin.api import http, validate
from livestreamer.stream import RTMPStream, HLSStream, HTTPStream, Stream
from livestreamer.stream.flvconcat import FLVTagConcat
from livestreamer.stream.segmented import (
SegmentedStreamReader, SegmentedStreamWriter, SegmentedStreamWorker
)
try:
import librtmp
HAS_LIBRTMP = True
except ImportError:
HAS_LIBRTMP = False
_url_re = re.compile("""
http(s)?://(www\.)?ustream.tv
(?:
(/embed/|/channel/id/)(?P<channel_id>\d+)
)?
(?:
/recorded/(?P<video_id>\d+)
)?
""", re.VERBOSE)
_channel_id_re = re.compile("\"channelId\":(\d+)")
HLS_PLAYLIST_URL = (
"http://iphone-streaming.ustream.tv"
"/uhls/{0}/streams/live/iphone/playlist.m3u8"
)
RECORDED_URL = "http://tcdn.ustream.tv/video/{0}"
RTMP_URL = "rtmp://r{0}-1-{1}-channel-live.ums.ustream.tv:1935/ustream"
SWF_URL = "http://static-cdn1.ustream.tv/swf/live/viewer.rsl:505.swf"
_module_info_schema = validate.Schema(
list,
validate.length(1),
validate.get(0),
dict
)
_amf3_array = validate.Schema(
validate.any(
validate.all(
{int: object},
validate.transform(lambda a: list(a.values())),
),
list
)
)
_recorded_schema = validate.Schema({
validate.optional("stream"): validate.all(
_amf3_array,
[{
"name": validate.text,
"streams": validate.all(
_amf3_array,
[{
"streamName": validate.text,
"bitrate": float,
}],
),
validate.optional("url"): validate.text,
}]
)
})
_stream_schema = validate.Schema({
"name": validate.text,
"url": validate.text,
"streams": validate.all(
_amf3_array,
[{
"chunkId": validate.any(int, float),
"chunkRange": {validate.text: validate.text},
"chunkTime": validate.any(int, float),
"offset": validate.any(int, float),
"offsetInMs": validate.any(int, float),
"streamName": validate.text,
validate.optional("bitrate"): validate.any(int, float),
validate.optional("height"): validate.any(int, float),
validate.optional("description"): validate.text,
validate.optional("isTranscoded"): bool
}],
)
})
_channel_schema = validate.Schema({
validate.optional("stream"): validate.any(
validate.all(
_amf3_array,
[_stream_schema],
),
"offline"
)
})
Chunk = namedtuple("Chunk", "num url offset")
if HAS_LIBRTMP:
from io import BytesIO
from time import time
from librtmp.rtmp import RTMPTimeoutError, PACKET_TYPE_INVOKE
from livestreamer.packages.flashmedia.types import AMF0Value
def decode_amf(body):
def generator():
fd = BytesIO(body)
while True:
try:
yield AMF0Value.read(fd)
except IOError:
break
return list(generator())
class FlashmediaRTMP(librtmp.RTMP):
"""RTMP connection using python-flashmedia's AMF decoder.
TODO: Move to python-librtmp instead.
"""
def process_packets(self, transaction_id=None, invoked_method=None,
timeout=None):
start = time()
while self.connected and transaction_id not in self._invoke_results:
if timeout and (time() - start) >= timeout:
raise RTMPTimeoutError("Timeout")
packet = self.read_packet()
if packet.type == PACKET_TYPE_INVOKE:
try:
decoded = decode_amf(packet.body)
except IOError:
continue
try:
method, transaction_id_, obj = decoded[:3]
args = decoded[3:]
except ValueError:
continue
if method == "_result":
if len(args) > 0:
result = args[0]
else:
result = None
self._invoke_results[transaction_id_] = result
else:
handler = self._invoke_handlers.get(method)
if handler:
res = handler(*args)
if res is not None:
self.call("_result", res,
transaction_id=transaction_id_)
if method == invoked_method:
self._invoke_args[invoked_method] = args
break
if transaction_id_ == 1.0:
self._connect_result = packet
else:
self.handle_packet(packet)
else:
self.handle_packet(packet)
if transaction_id:
result = self._invoke_results.pop(transaction_id, None)
return result
if invoked_method:
args = self._invoke_args.pop(invoked_method, None)
return args
def create_ums_connection(app, media_id, page_url, password,
exception=PluginError):
url = RTMP_URL.format(randint(0, 0xffffff), media_id)
params = {
"application": app,
"media": str(media_id),
"password": password
}
conn = FlashmediaRTMP(url,
swfurl=SWF_URL,
pageurl=page_url,
connect_data=params)
try:
conn.connect()
except librtmp.RTMPError:
raise exception("Failed to connect to RTMP server")
return conn
class UHSStreamWriter(SegmentedStreamWriter):
def __init__(self, *args, **kwargs):
SegmentedStreamWriter.__init__(self, *args, **kwargs)
self.concater = FLVTagConcat(flatten_timestamps=True,
sync_headers=True)
def fetch(self, chunk, retries=None):
if not retries or self.closed:
return
try:
params = {}
if chunk.offset:
params["start"] = chunk.offset
return http.get(chunk.url,
timeout=self.timeout,
params=params,
exception=StreamError)
except StreamError as err:
self.logger.error("Failed to open chunk {0}: {1}", chunk.num, err)
return self.fetch(chunk, retries - 1)
def write(self, chunk, res, chunk_size=8192):
try:
for data in self.concater.iter_chunks(buf=res.content,
skip_header=not chunk.offset):
self.reader.buffer.write(data)
if self.closed:
break
else:
self.logger.debug("Download of chunk {0} complete", chunk.num)
except IOError as err:
self.logger.error("Failed to read chunk {0}: {1}", chunk.num, err)
class UHSStreamWorker(SegmentedStreamWorker):
def __init__(self, *args, **kwargs):
SegmentedStreamWorker.__init__(self, *args, **kwargs)
self.chunk_ranges = {}
self.chunk_id = None
self.chunk_id_max = None
self.chunks = []
self.filename_format = ""
self.module_info_reload_time = 2
self.process_module_info()
def fetch_module_info(self):
self.logger.debug("Fetching module info")
conn = create_ums_connection("channel",
self.stream.channel_id,
self.stream.page_url,
self.stream.password,
exception=StreamError)
try:
result = conn.process_packets(invoked_method="moduleInfo",
timeout=10)
except (IOError, librtmp.RTMPError) as err:
raise StreamError("Failed to get module info: {0}".format(err))
finally:
conn.close()
result = _module_info_schema.validate(result)
return _channel_schema.validate(result, "module info")
def process_module_info(self):
if self.closed:
return
try:
result = self.fetch_module_info()
except PluginError as err:
self.logger.error("{0}", err)
return
providers = result.get("stream")
if not providers or providers == "offline":
self.logger.debug("Stream went offline")
self.close()
return
for provider in providers:
if provider.get("name") == self.stream.provider:
break
else:
return
try:
stream = provider["streams"][self.stream.stream_index]
except IndexError:
self.logger.error("Stream index not in result")
return
filename_format = stream["streamName"].replace("%", "%s")
filename_format = urljoin(provider["url"], filename_format)
self.filename_format = filename_format
self.update_chunk_info(stream)
def update_chunk_info(self, result):
chunk_range = result["chunkRange"]
if not chunk_range:
return
chunk_id = int(result["chunkId"])
chunk_offset = int(result["offset"])
chunk_range = dict(map(partial(map, int), chunk_range.items()))
self.chunk_ranges.update(chunk_range)
self.chunk_id_min = sorted(chunk_range)[0]
self.chunk_id_max = int(result["chunkId"])
self.chunks = [Chunk(i, self.format_chunk_url(i),
not self.chunk_id and i == chunk_id and chunk_offset)
for i in range(self.chunk_id_min, self.chunk_id_max + 1)]
if self.chunk_id is None and self.chunks:
self.chunk_id = chunk_id
def format_chunk_url(self, chunk_id):
chunk_hash = ""
for chunk_start in sorted(self.chunk_ranges):
if chunk_id >= chunk_start:
chunk_hash = self.chunk_ranges[chunk_start]
return self.filename_format % (chunk_id, chunk_hash)
def valid_chunk(self, chunk):
return self.chunk_id and chunk.num >= self.chunk_id
def iter_segments(self):
while not self.closed:
for chunk in filter(self.valid_chunk, self.chunks):
self.logger.debug("Adding chunk {0} to queue", chunk.num)
yield chunk
# End of stream
if self.closed:
return
self.chunk_id = chunk.num + 1
if self.wait(self.module_info_reload_time):
try:
self.process_module_info()
except StreamError as err:
self.logger.warning("Failed to process module info: {0}", err)
class UHSStreamReader(SegmentedStreamReader):
__worker__ = UHSStreamWorker
__writer__ = UHSStreamWriter
def __init__(self, stream, *args, **kwargs):
self.logger = stream.session.logger.new_module("stream.uhs")
SegmentedStreamReader.__init__(self, stream, *args, **kwargs)
class UHSStream(Stream):
__shortname__ = "uhs"
def __init__(self, session, channel_id, page_url, provider,
stream_index, password=""):
Stream.__init__(self, session)
self.channel_id = channel_id
self.page_url = page_url
self.provider = provider
self.stream_index = stream_index
self.password = password
def __repr__(self):
return "<UHSStream({0!r}, {1!r}, {2!r}, {3!r}, {4!r})>".format(
self.channel_id, self.page_url, self.provider,
self.stream_index, self.password
)
def __json__(self):
json = Stream.__json__(self)
json.update({
"channel_id": self.channel_id,
"page_url": self.page_url,
"provider": self.provider,
"stream_index": self.stream_index,
"password": self.password
})
return json
def open(self):
reader = UHSStreamReader(self)
reader.open()
return reader
class UStreamTV(Plugin):
options = PluginOptions({
"password": ""
})
@classmethod
def can_handle_url(cls, url):
return _url_re.match(url)
@classmethod
def stream_weight(cls, stream):
match = re.match("mobile_(\w+)", stream)
if match:
weight, group = Plugin.stream_weight(match.group(1))
weight -= 1
group = "mobile_ustream"
elif stream == "recorded":
weight, group = 720, "ustream"
else:
weight, group = Plugin.stream_weight(stream)
return weight, group
def _get_channel_id(self):
res = http.get(self.url)
match = _channel_id_re.search(res.text)
if match:
return int(match.group(1))
def _get_hls_streams(self, channel_id, wait_for_transcode=False):
# HLS streams are created on demand, so we may have to wait
# for a transcode to be started.
attempts = wait_for_transcode and 10 or 1
playlist_url = HLS_PLAYLIST_URL.format(channel_id)
streams = {}
while attempts and not streams:
try:
streams = HLSStream.parse_variant_playlist(self.session,
playlist_url,
nameprefix="mobile_")
except IOError:
# Channel is probably offline
break
attempts -= 1
sleep(3)
return streams
def _create_rtmp_stream(self, cdn, stream_name):
parsed = urlparse(cdn)
params = {
"rtmp": cdn,
"app": parsed.path[1:],
"playpath": stream_name,
"pageUrl": self.url,
"swfUrl": SWF_URL,
"live": True
}
return RTMPStream(self.session, params)
def _get_module_info(self, app, media_id, password="", schema=None):
self.logger.debug("Waiting for moduleInfo invoke")
conn = create_ums_connection(app, media_id, self.url, password)
attempts = 3
while conn.connected and attempts:
try:
result = conn.process_packets(invoked_method="moduleInfo",
timeout=10)
except (IOError, librtmp.RTMPError) as err:
raise PluginError("Failed to get stream info: {0}".format(err))
try:
result = _module_info_schema.validate(result)
break
except PluginError:
attempts -= 1
conn.close()
if schema:
result = schema.validate(result)
return result
def _get_desktop_streams(self, channel_id):
password = self.options.get("password")
channel = self._get_module_info("channel", channel_id, password,
schema=_channel_schema)
if not isinstance(channel.get("stream"), list):
raise NoStreamsError(self.url)
streams = {}
for provider in channel["stream"]:
provider_url = provider["url"]
provider_name = provider["name"]
for stream_index, stream_info in enumerate(provider["streams"]):
stream = None
stream_height = int(stream_info.get("height", 0))
stream_name = stream_info.get("description")
if not stream_name:
if stream_height > 0:
if not stream_info.get("isTranscoded"):
stream_name = "{0}p+".format(stream_height)
else:
stream_name = "{0}p".format(stream_height)
else:
stream_name = "live"
if stream_name in streams:
provider_name_clean = provider_name.replace("uhs_", "")
stream_name += "_alt_{0}".format(provider_name_clean)
if provider_name.startswith("uhs_"):
stream = UHSStream(self.session, channel_id,
self.url, provider_name,
stream_index, password)
elif provider_url.startswith("rtmp"):
playpath = stream_info["streamName"]
stream = self._create_rtmp_stream(provider_url,
playpath)
if stream:
streams[stream_name] = stream
return streams
def _get_live_streams(self, channel_id):
has_desktop_streams = False
if HAS_LIBRTMP:
try:
streams = self._get_desktop_streams(channel_id)
# TODO: Replace with "yield from" when dropping Python 2.
for stream in streams.items():
has_desktop_streams = True
yield stream
except PluginError as err:
self.logger.error("Unable to fetch desktop streams: {0}", err)
except NoStreamsError:
pass
else:
self.logger.warning(
"python-librtmp is not installed, but is needed to access "
"the desktop streams"
)
try:
streams = self._get_hls_streams(channel_id,
wait_for_transcode=not has_desktop_streams)
# TODO: Replace with "yield from" when dropping Python 2.
for stream in streams.items():
yield stream
except PluginError as err:
self.logger.error("Unable to fetch mobile streams: {0}", err)
except NoStreamsError:
pass
def _get_recorded_streams(self, video_id):
if HAS_LIBRTMP:
recording = self._get_module_info("recorded", video_id,
schema=_recorded_schema)
if not isinstance(recording.get("stream"), list):
return
for provider in recording["stream"]:
base_url = provider.get("url")
for stream_info in provider["streams"]:
bitrate = int(stream_info.get("bitrate", 0))
stream_name = (bitrate > 0 and "{0}k".format(bitrate) or
"recorded")
url = stream_info["streamName"]
if base_url:
url = base_url + url
if url.startswith("http"):
yield stream_name, HTTPStream(self.session, url)
elif url.startswith("rtmp"):
params = dict(rtmp=url, pageUrl=self.url)
yield stream_name, RTMPStream(self.session, params)
else:
self.logger.warning(
"The proper API could not be used without python-librtmp "
"installed. Stream URL is not guaranteed to be valid"
)
url = RECORDED_URL.format(video_id)
random_hash = "{0:02x}{1:02x}".format(randint(0, 255),
randint(0, 255))
params = dict(hash=random_hash)
stream = HTTPStream(self.session, url, params=params)
yield "recorded", stream
def _get_streams(self):
match = _url_re.match(self.url)
video_id = match.group("video_id")
if video_id:
return self._get_recorded_streams(video_id)
channel_id = match.group("channel_id") or self._get_channel_id()
if channel_id:
return self._get_live_streams(channel_id)
__plugin__ = UStreamTV
livestreamer-1.12.2/src/livestreamer/plugins/twitch.py 0000644 0001750 0001750 00000034703 12521217321 024226 0 ustar chrippa chrippa 0000000 0000000 import re
import requests
from random import random
from livestreamer.compat import urlparse
from livestreamer.exceptions import NoStreamsError, PluginError, StreamError
from livestreamer.plugin import Plugin, PluginOptions
from livestreamer.plugin.api import http, validate
from livestreamer.plugin.api.utils import parse_json, parse_query
from livestreamer.stream import (
HTTPStream, HLSStream, FLVPlaylist, extract_flv_header_tags
)
try:
from itertools import izip as zip
except ImportError:
pass
QUALITY_WEIGHTS = {
"source": 1080,
"high": 720,
"medium": 480,
"low": 240,
"mobile": 120,
}
_url_re = re.compile(r"""
http(s)?://
(?:
(?P<subdomain>\w+)
\.
)?
twitch.tv
/
(?P<channel>[^/]+)
(?:
/
(?P<video_type>[bcv])
/
(?P<video_id>\d+)
)?
""", re.VERBOSE)
_time_re = re.compile("""
(?:
(?P<hours>\d+)h
)?
(?:
(?P<minutes>\d+)m
)?
(?:
(?P<seconds>\d+)s
)?
""", re.VERBOSE)
_access_token_schema = validate.Schema(
{
"token": validate.text,
"sig": validate.text
},
validate.union((
validate.get("sig"),
validate.get("token")
))
)
_token_schema = validate.Schema(
{
"chansub": {
"restricted_bitrates": validate.all(
[validate.text],
validate.filter(
lambda n: not re.match(r"(.+_)?archives|live|chunked", n)
)
)
}
},
validate.get("chansub")
)
_user_schema = validate.Schema(
{
validate.optional("display_name"): validate.text
},
validate.get("display_name")
)
_video_schema = validate.Schema(
{
"chunks": {
validate.text: [{
"length": int,
"url": validate.any(None, validate.url(scheme="http")),
"upkeep": validate.any("pass", "fail", None)
}]
},
"restrictions": {validate.text: validate.text},
"start_offset": int,
"end_offset": int,
}
)
_viewer_info_schema = validate.Schema(
{
validate.optional("login"): validate.text
},
validate.get("login")
)
_viewer_token_schema = validate.Schema(
{
validate.optional("token"): validate.text
},
validate.get("token")
)
def time_to_offset(t):
match = _time_re.match(t)
if match:
offset = int(match.group("hours") or "0") * 60 * 60
offset += int(match.group("minutes") or "0") * 60
offset += int(match.group("seconds") or "0")
else:
offset = 0
return offset
class UsherService(object):
def _create_url(self, endpoint, **extra_params):
url = "http://usher.twitch.tv{0}".format(endpoint)
params = {
"player": "twitchweb",
"p": int(random() * 999999),
"type": "any",
"allow_source": "true",
"allow_audio_only": "true",
}
params.update(extra_params)
req = requests.Request("GET", url, params=params)
# prepare_request is only available in requests 2.0+
if hasattr(http, "prepare_request"):
req = http.prepare_request(req)
else:
req = req.prepare()
return req.url
def channel(self, channel, **extra_params):
return self._create_url("/api/channel/hls/{0}.m3u8".format(channel),
**extra_params)
def video(self, video_id, **extra_params):
return self._create_url("/vod/{0}".format(video_id), **extra_params)
class TwitchAPI(object):
def __init__(self, beta=False):
self.oauth_token = None
self.subdomain = beta and "betaapi" or "api"
def add_cookies(self, cookies):
http.parse_cookies(cookies, domain="twitch.tv")
def call(self, path, format="json", schema=None, **extra_params):
params = dict(as3="t", **extra_params)
if self.oauth_token:
params["oauth_token"] = self.oauth_token
url = "https://{0}.twitch.tv{1}.{2}".format(self.subdomain, path, format)
# The certificate used by Twitch cannot be verified on some OpenSSL versions.
res = http.get(url, params=params, verify=False)
if format == "json":
return http.json(res, schema=schema)
else:
return res
def access_token(self, endpoint, asset, **params):
return self.call("/api/{0}/{1}/access_token".format(endpoint, asset), **params)
def channel_info(self, channel, **params):
return self.call("/api/channels/{0}".format(channel), **params)
def channel_subscription(self, channel, **params):
return self.call("/api/channels/{0}/subscription".format(channel), **params)
def channel_viewer_info(self, channel, **params):
return self.call("/api/channels/{0}/viewer".format(channel), **params)
def token(self, **params):
return self.call("/api/viewer/token", **params)
def user(self, **params):
return self.call("/kraken/user", **params)
def videos(self, video_id, **params):
return self.call("/api/videos/{0}".format(video_id), **params)
def viewer_info(self, **params):
return self.call("/api/viewer/info", **params)
class Twitch(Plugin):
options = PluginOptions({
"cookie": None,
"oauth_token": None,
})
@classmethod
def stream_weight(cls, key):
weight = QUALITY_WEIGHTS.get(key)
if weight:
return weight, "twitch"
return Plugin.stream_weight(key)
@classmethod
def can_handle_url(cls, url):
return _url_re.match(url)
def __init__(self, url):
Plugin.__init__(self, url)
match = _url_re.match(url).groupdict()
self.channel = match.get("channel").lower()
self.subdomain = match.get("subdomain")
self.video_type = match.get("video_type")
self.video_id = match.get("video_id")
parsed = urlparse(url)
self.params = parse_query(parsed.query)
self.api = TwitchAPI(beta=self.subdomain == "beta")
self.usher = UsherService()
def _authenticate(self):
if self.api.oauth_token:
return
oauth_token = self.options.get("oauth_token")
cookies = self.options.get("cookie")
if oauth_token:
self.logger.info("Attempting to authenticate using OAuth token")
self.api.oauth_token = oauth_token
user = self.api.user(schema=_user_schema)
if user:
self.logger.info("Successfully logged in as {0}", user)
else:
self.logger.error("Failed to authenticate, the access token "
"is invalid or missing required scope")
elif cookies:
self.logger.info("Attempting to authenticate using cookies")
self.api.add_cookies(cookies)
self.api.oauth_token = self.api.token(schema=_viewer_token_schema)
login = self.api.viewer_info(schema=_viewer_info_schema)
if login:
self.logger.info("Successfully logged in as {0}", login)
else:
self.logger.error("Failed to authenticate, your cookies "
"may have expired")
def _create_playlist_streams(self, videos):
start_offset = int(videos.get("start_offset", 0))
stop_offset = int(videos.get("end_offset", 0))
streams = {}
for quality, chunks in videos.get("chunks").items():
if not chunks:
if videos.get("restrictions", {}).get(quality) == "chansub":
self.logger.warning("The quality '{0}' is not available "
"since it requires a subscription.",
quality)
continue
# Rename 'live' to 'source'
if quality == "live":
quality = "source"
chunks_filtered = list(filter(lambda c: c["url"], chunks))
if len(chunks) != len(chunks_filtered):
self.logger.warning("The video '{0}' contains invalid chunks. "
"There will be missing data.", quality)
chunks = chunks_filtered
chunks_duration = sum(c.get("length") for c in chunks)
# If it's a full broadcast we just use all the chunks
if start_offset == 0 and chunks_duration == stop_offset:
# No need to use the FLV concat if it's just one chunk
if len(chunks) == 1:
url = chunks[0].get("url")
stream = HTTPStream(self.session, url)
else:
chunks = [HTTPStream(self.session, c.get("url")) for c in chunks]
stream = FLVPlaylist(self.session, chunks,
duration=chunks_duration)
else:
try:
stream = self._create_video_clip(chunks,
start_offset,
stop_offset)
except StreamError as err:
self.logger.error("Error while creating video '{0}': {1}",
quality, err)
continue
streams[quality] = stream
return streams
def _create_video_clip(self, chunks, start_offset, stop_offset):
playlist_duration = stop_offset - start_offset
playlist_offset = 0
playlist_streams = []
playlist_tags = []
for chunk in chunks:
chunk_url = chunk["url"]
chunk_length = chunk["length"]
chunk_start = playlist_offset
chunk_stop = chunk_start + chunk_length
chunk_stream = HTTPStream(self.session, chunk_url)
if start_offset >= chunk_start and start_offset <= chunk_stop:
try:
headers = extract_flv_header_tags(chunk_stream)
except IOError as err:
raise StreamError("Error while parsing FLV: {0}", err)
if not headers.metadata:
raise StreamError("Missing metadata tag in the first chunk")
metadata = headers.metadata.data.value
keyframes = metadata.get("keyframes")
if not keyframes:
if chunk["upkeep"] == "fail":
raise StreamError("Unable to seek into muted chunk, try another timestamp")
else:
raise StreamError("Missing keyframes info in the first chunk")
keyframe_offset = None
keyframe_offsets = keyframes.get("filepositions")
keyframe_times = [playlist_offset + t for t in keyframes.get("times")]
for time, offset in zip(keyframe_times, keyframe_offsets):
if time > start_offset:
break
keyframe_offset = offset
if keyframe_offset is None:
raise StreamError("Unable to find a keyframe to seek to "
"in the first chunk")
chunk_headers = dict(Range="bytes={0}-".format(int(keyframe_offset)))
chunk_stream = HTTPStream(self.session, chunk_url,
headers=chunk_headers)
playlist_streams.append(chunk_stream)
for tag in headers:
playlist_tags.append(tag)
elif chunk_start >= start_offset and chunk_start < stop_offset:
playlist_streams.append(chunk_stream)
playlist_offset += chunk_length
return FLVPlaylist(self.session, playlist_streams,
tags=playlist_tags, duration=playlist_duration)
def _get_video_streams(self):
self._authenticate()
if self.video_type == "b":
self.video_type = "a"
try:
videos = self.api.videos(self.video_type + self.video_id,
schema=_video_schema)
except PluginError as err:
if "HTTP/1.1 0 ERROR" in str(err):
raise NoStreamsError(self.url)
else:
raise
# Parse the "t" query parameter on broadcasts and adjust
# start offset if needed.
time_offset = self.params.get("t")
if time_offset:
videos["start_offset"] += time_to_offset(self.params.get("t"))
return self._create_playlist_streams(videos)
def _access_token(self, type="live"):
try:
if type == "live":
endpoint = "channels"
value = self.channel
elif type == "video":
endpoint = "vods"
value = self.video_id
sig, token = self.api.access_token(endpoint, value,
schema=_access_token_schema)
except PluginError as err:
if "404 Client Error" in str(err):
raise NoStreamsError(self.url)
else:
raise
return sig, token
def _get_hls_streams(self, type="live"):
self._authenticate()
sig, token = self._access_token(type)
if type == "live":
url = self.usher.channel(self.channel, sig=sig, token=token)
elif type == "video":
url = self.usher.video(self.video_id, nauthsig=sig, nauth=token)
try:
streams = HLSStream.parse_variant_playlist(self.session, url)
except IOError as err:
err = str(err)
if "404 Client Error" in err or "Failed to parse playlist" in err:
return
else:
raise PluginError(err)
try:
token = parse_json(token, schema=_token_schema)
for name in token["restricted_bitrates"]:
if name not in streams:
self.logger.warning("The quality '{0}' is not available "
"since it requires a subscription.",
name)
except PluginError:
pass
return streams
def _get_streams(self):
if self.video_id:
if self.video_type == "v":
return self._get_hls_streams("video")
else:
return self._get_video_streams()
else:
return self._get_hls_streams("live")
__plugin__ = Twitch
livestreamer-1.12.2/src/livestreamer/plugins/tvplayer.py 0000644 0001750 0001750 00000002323 12521217321 024563 0 ustar chrippa chrippa 0000000 0000000 #!/usr/bin/env python
import re
from livestreamer.plugin import Plugin
from livestreamer.plugin.api import http, validate
from livestreamer.stream import HLSStream
STREAM_INFO_URL = "http://lapi.cdn.tvplayer.com/tvplayer/stream/live/id/{id}"
_url_re = re.compile(r"http://(?:www.)?tvplayer.com/watch/(.+)")
_channel_map_re = re.compile(r'href="/watch/([a-z]+?)".*?img.*?src=".*?/(\d+).png"', re.S)
_channel_schema = validate.Schema({
"stream": validate.url(scheme=validate.any("http"))
})
class TVPlayer(Plugin):
@classmethod
def can_handle_url(cls, url):
match = _url_re.match(url)
return match
def _get_streams(self):
url_match = _url_re.match(self.url)
if url_match:
# find the list of channels from the html in the page
res = http.get(self.url)
channel_map = dict(_channel_map_re.findall(res.text))
channel_id = channel_map.get(url_match.group(1))
# get the stream urls
res = http.get(STREAM_INFO_URL.format(id=channel_id))
stream_data = http.json(res, schema=_channel_schema)
return HLSStream.parse_variant_playlist(self.session, stream_data['stream'])
__plugin__ = TVPlayer
livestreamer-1.12.2/src/livestreamer/plugins/tvcatchup.py 0000644 0001750 0001750 00000001565 12521217321 024725 0 ustar chrippa chrippa 0000000 0000000 import re
from livestreamer.plugin import Plugin
from livestreamer.plugin.api import http
from livestreamer.stream import HLSStream
SUCCESS_HTTP_CODES = (200,)
STREAM_URL_FORMAT = "http://tvcatchup.com/stream.php?chan={0}"
_url_re = re.compile("http://(?:www\.)?tvcatchup.com/watch/(?P<channel_id>[0-9]+)")
class TVCatchup(Plugin):
@classmethod
def can_handle_url(cls, url):
return _url_re.match(url)
def _get_streams(self):
"""
Finds the stream from tvcatchup, they only provide a single 480p stream per channel.
"""
match = _url_re.match(self.url).groupdict()
channel_id = match["channel_id"]
res = http.get(STREAM_URL_FORMAT.format(channel_id))
stream_url = http.json(res).get('url')
if stream_url:
return {"480p": HLSStream(self.session, stream_url)}
__plugin__ = TVCatchup
livestreamer-1.12.2/src/livestreamer/plugins/tv4play.py 0000644 0001750 0001750 00000004005 12521217321 024317 0 ustar chrippa chrippa 0000000 0000000 """Plugin for TV4 Play, swedish TV channel TV4's streaming service."""
import re
from livestreamer.compat import urlparse
from livestreamer.plugin import Plugin
from livestreamer.plugin.api import http, validate
from livestreamer.stream import HDSStream, RTMPStream
ASSET_URL = "http://prima.tv4play.se/api/web/asset/{0}/play"
SWF_URL = "http://www.tv4play.se/flash/tv4video.swf"
_url_re = re.compile("""
http(s)?://(www\.)?
(?:
tv4play.se/program/[^\?/]+
)?
(?:
fotbollskanalen.se/video
)?
.+(video_id|videoid)=(?P<video_id>\d+)
""", re.VERBOSE)
_asset_schema = validate.Schema(
validate.xml_findall("items/item"),
[
validate.all(
validate.xml_findall("*"),
validate.map(lambda e: (e.tag, e.text)),
validate.transform(dict),
{
"base": validate.text,
"bitrate": validate.all(
validate.text, validate.transform(int)
),
"url": validate.text
}
)
]
)
class TV4Play(Plugin):
@classmethod
def can_handle_url(cls, url):
return _url_re.match(url)
def _get_streams(self):
match = _url_re.match(self.url)
video_id = match.group("video_id")
res = http.get(ASSET_URL.format(video_id))
assets = http.xml(res, schema=_asset_schema)
streams = {}
for asset in assets:
base = asset["base"]
url = asset["url"]
if urlparse(url).path.endswith(".f4m"):
streams.update(
HDSStream.parse_manifest(self.session, url, pvswf=SWF_URL)
)
elif base.startswith("rtmp"):
name = "{0}k".format(asset["bitrate"])
params = {
"rtmp": asset["base"],
"playpath": url,
"live": True
}
streams[name] = RTMPStream(self.session, params)
return streams
__plugin__ = TV4Play
livestreamer-1.12.2/src/livestreamer/plugins/tv3cat.py 0000644 0001750 0001750 00000003230 12521217321 024117 0 ustar chrippa chrippa 0000000 0000000 #!/usr/bin/env python
import re
from livestreamer.plugin import Plugin
from livestreamer.plugin.api import http
from livestreamer.stream import HLSStream
from livestreamer.plugin.api import validate
STREAM_INFO_URL = "http://dinamics.ccma.cat/pvideo/media.jsp?media=video&version=0s&idint={ident}&profile=pc&desplacament=0"
_url_re = re.compile(r"http://(?:www.)?ccma.cat/tv3/directe/(.+?)/")
_media_schema = validate.Schema({
"geo": validate.text,
"url": validate.url(scheme=validate.any("http"))
})
_channel_schema = validate.Schema({
"media": validate.any([_media_schema], _media_schema)
})
class TV3Cat(Plugin):
@classmethod
def can_handle_url(self, url):
match = _url_re.match(url)
return match
def _get_streams(self):
match = _url_re.match(self.url)
if match:
ident = match.group(1)
data_url = STREAM_INFO_URL.format(ident=ident)
# find the region, default to TOTS (international)
res = http.get(self.url)
geo_data = re.search(r'data-geo="([A-Z]+?)"', res.text)
geo = geo_data and geo_data.group(1) or "TOTS"
stream_data = http.json(http.get(data_url), schema=_channel_schema)
# If there is only one item, it's not a list ... silly
if isinstance(stream_data['media'], list):
stream_infos = stream_data['media']
else:
stream_infos = [stream_data['media']]
for stream in stream_infos:
if stream['geo'] == geo:
return HLSStream.parse_variant_playlist(self.session, stream['url'])
__plugin__ = TV3Cat
livestreamer-1.12.2/src/livestreamer/plugins/tga.py 0000644 0001750 0001750 00000004462 12521217321 023476 0 ustar chrippa chrippa 0000000 0000000 #coding: utf-8
import re
from livestreamer.plugin import Plugin
from livestreamer.plugin.api import http, validate
from livestreamer.plugin.api.utils import parse_query
from livestreamer.stream import HLSStream, HTTPStream
CHANNEL_INFO_URL = "http://api.plu.cn/tga/streams/%s"
STREAM_INFO_URL = "http://info.zb.qq.com/?cnlid=%d&cmd=2&stream=%d&system=1&sdtfrom=113"
_url_re = re.compile("http://star\.longzhu\.(?:tv|com)/(m\/)?(?P<domain>[a-z0-9]+)");
_channel_schema = validate.Schema(
{
"data" : validate.any(None, {
"channel" : validate.any(None, {
"id" : validate.all(
validate.text,
validate.transform(int)
),
"vid" : int
})
})
},
validate.get("data")
);
_qq_schema = validate.Schema({
validate.optional("playurl"): validate.url(scheme="http")
},
validate.get("playurl")
)
STREAM_WEIGHTS = {
"middle": 540,
"source": 1080
}
class Tga(Plugin):
@classmethod
def can_handle_url(self, url):
return _url_re.match(url)
@classmethod
def stream_weight(cls, stream):
if stream in STREAM_WEIGHTS:
return STREAM_WEIGHTS[stream], "tga"
return Plugin.stream_weight(stream)
def _get_channel_id(self, domain):
channel_info = http.get(CHANNEL_INFO_URL % str(domain))
info = http.json(channel_info, schema=_channel_schema)
if info is None:
return False
cnid = info['channel']['vid']
if cnid <= 0:
return False
return cnid
def _get_qq_stream_url(self, cnid, weight = 1):
qq_stream_url = http.get(STREAM_INFO_URL % (int(cnid), int(weight)));
qq_info = http.json(qq_stream_url, schema=_qq_schema)
return qq_info;
def _get_streams(self):
match = _url_re.match(self.url);
domain = match.group('domain')
cnid = self._get_channel_id(domain);
if cnid == False:
return;
flash_stream = HTTPStream(self.session, self._get_qq_stream_url(cnid, 1))
if flash_stream:
yield "live", flash_stream
mobile_stream = HLSStream(self.session, self._get_qq_stream_url(cnid, 2))
if mobile_stream:
yield "live_http", mobile_stream
__plugin__ = Tga
livestreamer-1.12.2/src/livestreamer/plugins/svtplay.py 0000644 0001750 0001750 00000002764 12521217321 024430 0 ustar chrippa chrippa 0000000 0000000 import re
from livestreamer.plugin import Plugin
from livestreamer.plugin.api import StreamMapper, http, validate
from livestreamer.stream import HLSStream, HDSStream
_url_re = re.compile("""
http(s)?://
(www\.)?
(?:
svtplay |
svtflow |
oppetarkiv
)
.se
""", re.VERBOSE)
_video_schema = validate.Schema(
{
"video": {
"videoReferences": validate.all(
[{
"url": validate.text,
"playerType": validate.text
}],
),
}
},
validate.get("video"),
validate.get("videoReferences")
)
class SVTPlay(Plugin):
@classmethod
def can_handle_url(self, url):
return _url_re.match(url)
def _create_streams(self, stream_type, parser, video):
try:
streams = parser(self.session, video["url"])
return streams.items()
except IOError as err:
self.logger.error("Failed to extract {0} streams: {1}",
stream_type, err)
def _get_streams(self):
res = http.get(self.url, params=dict(output="json"))
videos = http.json(res, schema=_video_schema)
mapper = StreamMapper(cmp=lambda type, video: video["playerType"] == type)
mapper.map("ios", self._create_streams, "HLS", HLSStream.parse_variant_playlist)
mapper.map("flash", self._create_streams, "HDS", HDSStream.parse_manifest)
return mapper(videos)
__plugin__ = SVTPlay
livestreamer-1.12.2/src/livestreamer/plugins/streamlive.py 0000644 0001750 0001750 00000003313 12521217321 025070 0 ustar chrippa chrippa 0000000 0000000 import re
from livestreamer.compat import urlparse
from livestreamer.plugin import Plugin
from livestreamer.plugin.api import StreamMapper, http, validate
from livestreamer.stream import HLSStream, RTMPStream
CHANNEL_URL = "http://www.mobileonline.tv/channel.php"
_url_re = re.compile("http(s)?://(\w+\.)?(ilive.to|streamlive.to)/.*/(?P<channel>\d+)")
_link_re = re.compile("<a href=(\S+) target=\"_blank\"")
_schema = validate.Schema(
validate.transform(_link_re.findall),
)
class StreamLive(Plugin):
@classmethod
def can_handle_url(self, url):
return _url_re.match(url)
def _create_hls_streams(self, url):
try:
streams = HLSStream.parse_variant_playlist(self.session, url)
return streams.items()
except IOError as err:
self.logger.warning("Failed to extract HLS streams: {0}", err)
def _create_rtmp_stream(self, url):
parsed = urlparse(url)
if parsed.query:
app = "{0}?{1}".format(parsed.path[1:], parsed.query)
else:
app = parsed.path[1:]
params = {
"rtmp": url,
"app": app,
"pageUrl": self.url,
"live": True
}
stream = RTMPStream(self.session, params)
return "live", stream
def _get_streams(self):
channel = _url_re.match(self.url).group("channel")
urls = http.get(CHANNEL_URL, params=dict(n=channel), schema=_schema)
if not urls:
return
mapper = StreamMapper(cmp=lambda scheme, url: url.startswith(scheme))
mapper.map("http", self._create_hls_streams)
mapper.map("rtmp", self._create_rtmp_stream)
return mapper(urls)
__plugin__ = StreamLive
livestreamer-1.12.2/src/livestreamer/plugins/streamingvideoprovider.py 0000644 0001750 0001750 00000004524 12521217321 027515 0 ustar chrippa chrippa 0000000 0000000 import re
from time import time
from livestreamer.plugin import Plugin, PluginError
from livestreamer.plugin.api import http, validate
from livestreamer.stream import RTMPStream, HLSStream
SWF_URL = "http://play.streamingvideoprovider.com/player2.swf"
API_URL = "http://player.webvideocore.net/index.php"
_url_re = re.compile(
"http(s)?://(\w+\.)?streamingvideoprovider.co.uk/(?P<channel>[^/&?]+)"
)
_hls_re = re.compile("'(http://.+\.m3u8)'")
_rtmp_schema = validate.Schema(
validate.xml_findtext("./info/url"),
validate.url(scheme="rtmp")
)
_hls_schema = validate.Schema(
validate.transform(_hls_re.search),
validate.any(
None,
validate.all(
validate.get(1),
validate.url(
scheme="http",
path=validate.endswith("m3u8")
)
)
)
)
class Streamingvideoprovider(Plugin):
@classmethod
def can_handle_url(self, url):
return _url_re.match(url)
def _get_hls_stream(self, channel_name):
params = {
"l": "info",
"a": "ajax_video_info",
"file": channel_name,
"rid": time()
}
playlist_url = http.get(API_URL, params=params, schema=_hls_schema)
if not playlist_url:
return
return HLSStream(self.session, playlist_url)
def _get_rtmp_stream(self, channel_name):
params = {
"l": "info",
"a": "xmlClipPath",
"clip_id": channel_name,
"rid": time()
}
res = http.get(API_URL, params=params)
rtmp_url = http.xml(res, schema=_rtmp_schema)
return RTMPStream(self.session, {
"rtmp": rtmp_url,
"swfVfy": SWF_URL,
"live": True
})
def _get_streams(self):
match = _url_re.match(self.url)
channel_name = match.group("channel")
try:
stream = self._get_rtmp_stream(channel_name)
yield "live", stream
except PluginError as err:
self.logger.error("Unable to extract RTMP stream: {0}", err)
try:
stream = self._get_hls_stream(channel_name)
if stream:
yield "live", stream
except PluginError as err:
self.logger.error("Unable to extract HLS stream: {0}", err)
__plugin__ = Streamingvideoprovider
livestreamer-1.12.2/src/livestreamer/plugins/stream.py 0000644 0001750 0001750 00000004506 12521217321 024215 0 ustar chrippa chrippa 0000000 0000000 from livestreamer.compat import urlparse
from livestreamer.exceptions import PluginError
from livestreamer.plugin import Plugin
from livestreamer.stream import (AkamaiHDStream, HDSStream, HLSStream,
HTTPStream, RTMPStream)
import ast
import re
PROTOCOL_MAP = {
"akamaihd": AkamaiHDStream,
"hds": HDSStream.parse_manifest,
"hls": HLSStream,
"hlsvariant": HLSStream.parse_variant_playlist,
"httpstream": HTTPStream,
"rtmp": RTMPStream,
"rtmpe": RTMPStream,
"rtmps": RTMPStream,
"rtmpt": RTMPStream,
"rtmpte": RTMPStream
}
PARAMS_REGEX = r"(\w+)=({.+?}|\[.+?\]|\(.+?\)|'(?:[^'\\]|\\')*'|\"(?:[^\"\\]|\\\")*\"|\S+)"
class StreamURL(Plugin):
@classmethod
def can_handle_url(self, url):
parsed = urlparse(url)
return parsed.scheme in PROTOCOL_MAP
def _parse_params(self, params):
rval = {}
matches = re.findall(PARAMS_REGEX, params)
for key, value in matches:
try:
value = ast.literal_eval(value)
except Exception:
pass
rval[key] = value
return rval
def _get_streams(self):
parsed = urlparse(self.url)
cls = PROTOCOL_MAP.get(parsed.scheme)
if not cls:
return
split = self.url.split(" ")
url = split[0]
urlnoproto = re.match("^\w+://(.+)", url).group(1)
# Prepend http:// if needed.
if cls != RTMPStream and not re.match("^http(s)?://", urlnoproto):
urlnoproto = "http://{0}".format(urlnoproto)
params = (" ").join(split[1:])
params = self._parse_params(params)
if cls == RTMPStream:
params["rtmp"] = url
for boolkey in ("live", "realtime", "quiet", "verbose", "debug"):
if boolkey in params:
params[boolkey] = bool(params[boolkey])
stream = cls(self.session, params)
elif cls == HLSStream.parse_variant_playlist or cls == HDSStream.parse_manifest:
try:
streams = cls(self.session, urlnoproto, **params)
except IOError as err:
raise PluginError(err)
return streams
else:
stream = cls(self.session, urlnoproto, **params)
return dict(live=stream)
__plugin__ = StreamURL
livestreamer-1.12.2/src/livestreamer/plugins/ssh101.py 0000644 0001750 0001750 00000002126 12521217321 023735 0 ustar chrippa chrippa 0000000 0000000 import re
from livestreamer.compat import urlparse
from livestreamer.plugin import Plugin
from livestreamer.plugin.api import http, validate
from livestreamer.stream import HLSStream
_url_re = re.compile("http(s)?://(\w+\.)?ssh101\.com/")
_live_re = re.compile("""
\s*jwplayer\(\"player\"\)\.setup\({.*?
\s*primary:\s+"([^"]+)".*?
\s*file:\s+"([^"]+)"
""", re.DOTALL)
_live_schema = validate.Schema(
validate.transform(_live_re.search),
validate.any(
None,
validate.union({
"type": validate.get(1),
"url": validate.all(
validate.get(2),
validate.url(scheme="http"),
),
})
)
)
class SSH101(Plugin):
@classmethod
def can_handle_url(self, url):
return _url_re.match(url)
def _get_streams(self):
res = http.get(self.url, schema=_live_schema)
if not res:
return
if res["type"] == "hls" and urlparse(res["url"]).path.endswith("m3u8"):
stream = HLSStream(self.session, res["url"])
return dict(hls=stream)
__plugin__ = SSH101
livestreamer-1.12.2/src/livestreamer/plugins/speedrunslive.py 0000644 0001750 0001750 00000001007 12521217321 025603 0 ustar chrippa chrippa 0000000 0000000 import re
from livestreamer.plugin import Plugin
TWITCH_URL_FORMAT = "http://www.twitch.tv/{0}"
_url_re = re.compile("http://(?:www\.)?speedrunslive.com/#!/(?P<user>\w+)")
class SpeedRunsLive(Plugin):
@classmethod
def can_handle_url(self, url):
return _url_re.match(url)
def _get_streams(self):
match = _url_re.match(self.url)
username = match.group("user")
url = TWITCH_URL_FORMAT.format(username)
return self.session.streams(url)
__plugin__ = SpeedRunsLive
livestreamer-1.12.2/src/livestreamer/plugins/seemeplay.py 0000644 0001750 0001750 00000002306 12521217321 024702 0 ustar chrippa chrippa 0000000 0000000 import re
from livestreamer.compat import urlparse
from livestreamer.plugin import Plugin
from livestreamer.plugin.api import http, validate
from livestreamer.stream import HLSStream, HTTPStream
_url_re = re.compile("http(s)?://(\w+\.)?seemeplay.ru/")
_player_re = re.compile("""
SMP.(channel|video).player.init\({
\s+file:\s+"([^"]+)"
""", re.VERBOSE)
_schema = validate.Schema(
validate.transform(_player_re.search),
validate.any(
None,
validate.union({
"type": validate.get(1),
"url": validate.all(
validate.get(2),
validate.url(scheme="http"),
),
})
)
)
class SeeMePlay(Plugin):
@classmethod
def can_handle_url(cls, url):
return _url_re.match(url)
def _get_streams(self):
res = http.get(self.url, schema=_schema)
if not res:
return
if res["type"] == "channel" and urlparse(res["url"]).path.endswith("m3u8"):
return HLSStream.parse_variant_playlist(self.session, res["url"])
elif res["type"] == "video":
stream = HTTPStream(self.session, res["url"])
return dict(video=stream)
__plugin__ = SeeMePlay
livestreamer-1.12.2/src/livestreamer/plugins/sbsdiscovery.py 0000644 0001750 0001750 00000003144 12521217321 025436 0 ustar chrippa chrippa 0000000 0000000 """Plugin for Swedish TV channels Kanal 5, Kanal 9 and Kanal 11."""
import re
from livestreamer.plugin import Plugin
from livestreamer.plugin.api import http, validate
from livestreamer.stream import RTMPStream
API_URL = "http://www.kanal{0}play.se/api/getVideo?videoId={1}&format=FLASH"
_url_re = re.compile ("""
(http(s)?://)?www.kanal(?P<channel>5|9|11)play.se/(play/)?
program/\d+/video/(?P<video_id>\d+)
""", re.VERBOSE)
_schema = validate.Schema (
{
"streams": validate.all (
[{
"bitrate": validate.transform (int),
"source": validate.text
}]),
"streamBaseUrl": validate.text
}
)
class Kanal5_9_11 (Plugin):
@classmethod
def can_handle_url (cls, url):
return _url_re.match (url)
def _get_streams (self):
match = _url_re.match (self.url)
channel = match.group ("channel")
video_id = match.group ("video_id")
# Get response from API and validate
res = http.get (API_URL.format (channel, video_id))
data = http.json (res, schema=_schema)
# Form collection of available streams
baseUrl = data["streamBaseUrl"]
streams = {}
for stream in data["streams"]:
kbitrate = int (stream["bitrate"] / 1000)
name = "{0}k".format (kbitrate)
params = {
"rtmp": baseUrl,
"playpath": stream["source"],
"live": True
}
streams[name] = RTMPStream (self.session, params)
return streams
__plugin__ = Kanal5_9_11
livestreamer-1.12.2/src/livestreamer/plugins/rtve.py 0000644 0001750 0001750 00000003175 12521217321 023703 0 ustar chrippa chrippa 0000000 0000000 import re
from livestreamer.plugin import Plugin, PluginError
from livestreamer.plugin.api import http
from livestreamer.stream import HLSStream
# The last four channel_paths repsond with 301 and provide
# a redirect location that corresponds to a channel_path above.
_url_re = re.compile(r"""
https?://www\.rtve\.es/
(?P<channel_path>
directo/la-1|
directo/la-2|
directo/teledeporte|
directo/canal-24h|
noticias/directo-la-1|
television/la-2-directo|
deportes/directo/teledeporte|
noticias/directo/canal-24h
)
/?
""", re.VERBOSE)
_id_map = {
"directo/la-1": "LA1",
"directo/la-2": "LA2",
"directo/teledeporte": "TDP",
"directo/canal-24h": "24H",
"noticias/directo-la-1": "LA1",
"television/la-2-directo": "LA2",
"deportes/directo/teledeporte": "TDP",
"noticias/directo/canal-24h": "24H",
}
class Rtve(Plugin):
@classmethod
def can_handle_url(cls, url):
return _url_re.match(url)
def __init__(self, url):
Plugin.__init__(self, url)
match = _url_re.match(url).groupdict()
self.channel_path = match["channel_path"]
def _get_streams(self):
stream_id = _id_map[self.channel_path]
hls_url = "http://iphonelive.rtve.es/{0}_LV3_IPH/{0}_LV3_IPH.m3u8".format(stream_id)
# Check if the stream is available
res = http.head(hls_url, raise_for_status=False)
if res.status_code == 404:
raise PluginError("The program is not available due to rights restrictions")
return HLSStream.parse_variant_playlist(self.session, hls_url)
__plugin__ = Rtve
livestreamer-1.12.2/src/livestreamer/plugins/picarto.py 0000644 0001750 0001750 00000001364 12521217321 024362 0 ustar chrippa chrippa 0000000 0000000 import re
from livestreamer.plugin import Plugin
from livestreamer.stream import RTMPStream
RTMP_URL = "rtmp://live.us.picarto.tv/golive/{0}"
_url_re = re.compile("""
http(s)?://(\w+\.)?picarto.tv
/live/(channel|channelhd|multistream).php
.+watch=(?P<channel>[^&?/]+)
""", re.VERBOSE)
class Picarto(Plugin):
@classmethod
def can_handle_url(self, url):
return _url_re.match(url)
def _get_streams(self):
match = _url_re.match(self.url)
channel = match.group("channel")
streams = {}
streams["live"] = RTMPStream(self.session, {
"rtmp": RTMP_URL.format(channel),
"pageUrl": self.url,
"live": True
})
return streams
__plugin__ = Picarto
livestreamer-1.12.2/src/livestreamer/plugins/periscope.py 0000644 0001750 0001750 00000001777 12521217321 024722 0 ustar chrippa chrippa 0000000 0000000 import re
from livestreamer.plugin import Plugin
from livestreamer.plugin.api import http, validate
from livestreamer.stream import HLSStream
STREAM_INFO_URL = "https://api.periscope.tv/api/v2/getAccessPublic"
STATUS_GONE = 410
STATUS_UNAVAILABLE = (STATUS_GONE,)
_url_re = re.compile(r"http(s)?://(www\.)?periscope.tv/w/(?P<token>[\w\-\=]+)")
_stream_schema = validate.Schema(
{"hls_url": validate.url(scheme="http")},
validate.get("hls_url")
)
class Periscope(Plugin):
@classmethod
def can_handle_url(cls, url):
return _url_re.match(url)
def _get_streams(self):
match = _url_re.match(self.url)
res = http.get(STREAM_INFO_URL,
params=match.groupdict(),
acceptable_status=STATUS_UNAVAILABLE)
if res.status_code in STATUS_UNAVAILABLE:
return
playlist_url = http.json(res, schema=_stream_schema)
return HLSStream.parse_variant_playlist(self.session, playlist_url)
__plugin__ = Periscope
livestreamer-1.12.2/src/livestreamer/plugins/oldlivestream.py 0000644 0001750 0001750 00000001272 12521217321 025571 0 ustar chrippa chrippa 0000000 0000000 import re
from livestreamer.plugin import Plugin
from livestreamer.stream import HLSStream
PLAYLIST_URL = "http://x{0}x.api.channel.livestream.com/3.0/playlist.m3u8"
_url_re = re.compile("http(s)?://original.livestream.com/(?P<channel>[^&?/]+)")
class OldLivestream(Plugin):
@classmethod
def can_handle_url(self, url):
return _url_re.match(url)
def _get_streams(self):
match = _url_re.match(self.url)
channel = match.group("channel")
channel = channel.replace("_", "-")
playlist_url = PLAYLIST_URL.format(channel)
return HLSStream.parse_variant_playlist(self.session, playlist_url, check_streams=True)
__plugin__ = OldLivestream
livestreamer-1.12.2/src/livestreamer/plugins/nrk.py 0000644 0001750 0001750 00000002337 12521217321 023514 0 ustar chrippa chrippa 0000000 0000000 import re
from livestreamer.plugin import Plugin
from livestreamer.plugin.api import http, validate
from livestreamer.stream import HLSStream
COOKIE_PARAMS = (
"devicetype=desktop&"
"preferred-player-odm=hlslink&"
"preferred-player-live=hlslink"
)
_url_re = re.compile("http://(tv|radio).nrk.no/")
_media_url_re = re.compile("""
<div[^>]*?id="playerelement"[^>]+
data-media="(?P<url>[^"]+)"
""", re.VERBOSE)
_schema = validate.Schema(
validate.transform(_media_url_re.search),
validate.any(
None,
validate.all(
validate.get("url"),
validate.url(
scheme="http",
path=validate.endswith(".m3u8")
)
)
)
)
class NRK(Plugin):
@classmethod
def can_handle_url(self, url):
return _url_re.match(url)
def _get_streams(self):
stream_type = _url_re.match(self.url).group(1).upper()
cookie = {
"NRK_PLAYER_SETTINGS_{0}".format(stream_type): COOKIE_PARAMS
}
playlist_url = http.get(self.url, cookies=cookie, schema=_schema)
if not playlist_url:
return
return HLSStream.parse_variant_playlist(self.session, playlist_url)
__plugin__ = NRK
livestreamer-1.12.2/src/livestreamer/plugins/npo.py 0000644 0001750 0001750 00000005137 12521217321 023517 0 ustar chrippa chrippa 0000000 0000000 """Plugin for NPO: Nederlandse Publieke Omroep
Supports:
VODs: http://www.npo.nl/het-zandkasteel/POMS_S_NTR_059963
Live: http://www.npo.nl/live/nederland-1
"""
import re
import json
from livestreamer.plugin import Plugin
from livestreamer.plugin.api import http
from livestreamer.stream import HTTPStream, HLSStream
_url_re = re.compile("http(s)?://(\w+\.)?npo.nl/")
HTTP_HEADERS = {
"User-Agent": "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/36.0.1944.9 Safari/537.36"
}
class NPO(Plugin):
@classmethod
def can_handle_url(cls, url):
return _url_re.match(url)
def get_token(self):
token = http.get('http://ida.omroep.nl/npoplayer/i.js', headers=HTTP_HEADERS).content
return re.compile('token.*?"(.*?)"', re.DOTALL + re.IGNORECASE).search(token).group(1)
def _get_meta(self):
html = http.get('http://www.npo.nl/live/{}'.format(self.npo_id), headers=HTTP_HEADERS).content
program_id = re.compile('data-prid="(.*?)"', re.DOTALL + re.IGNORECASE).search(html).group(1)
meta = http.get('http://e.omroep.nl/metadata/{}'.format(program_id), headers=HTTP_HEADERS).content
meta = re.compile('({.*})', re.DOTALL + re.IGNORECASE).search(meta).group(1)
return json.loads(meta)
def _get_vod_streams(self):
url = 'http://ida.omroep.nl/odi/?prid={}&puboptions=adaptive,h264_bb,h264_std,h264_sb&adaptive=no&part=1&token={}'.format(self.npo_id, self.get_token())
data = http.get(url, headers=HTTP_HEADERS).json()
streams = {}
stream = http.get(data['streams'][0].replace('jsonp', 'json'), headers=HTTP_HEADERS).json()
streams['best'] = streams['high'] = HTTPStream(self.session, stream['url'])
return streams
def _get_live_streams(self):
meta = self._get_meta()
stream = filter(lambda x: x['type'] == 'hls', meta['streams'])[0]['url']
url = 'http://ida.omroep.nl/aapi/?type=jsonp&stream={}&token={}'.format(stream, self.get_token())
streamdata = http.get(url, headers=HTTP_HEADERS).json()
deeplink = http.get(streamdata['stream'], headers=HTTP_HEADERS).content
deeplink = re.compile('"(.*?)"', re.DOTALL + re.IGNORECASE).search(deeplink).group(1)
playlist_url = deeplink.replace("\\/", "/")
return HLSStream.parse_variant_playlist(self.session, playlist_url)
def _get_streams(self):
urlparts = self.url.split('/')
self.npo_id = urlparts[-1]
if (urlparts[-2] == 'live'):
return self._get_live_streams()
else:
return self._get_vod_streams()
__plugin__ = NPO
livestreamer-1.12.2/src/livestreamer/plugins/nos.py 0000644 0001750 0001750 00000004112 12521217321 023512 0 ustar chrippa chrippa 0000000 0000000 """Plugin for NOS: Nederlandse Omroep Stichting
Supports:
MP$: http://nos.nl/uitzending/nieuwsuur.html
Live: http://www.nos.nl/livestream/*
"""
import re
import json
from livestreamer.plugin import Plugin
from livestreamer.plugin.api import http
from livestreamer.plugin.api.utils import parse_json
from livestreamer.stream import HTTPStream, HLSStream
_url_re = re.compile("http(s)?://(\w+\.)?nos.nl/")
_js_re = re.compile('\((.*)\)')
_data_stream_re = re.compile('data-stream="(.*?)"', re.DOTALL | re.IGNORECASE)
_source_re = re.compile("<source(?P<source>[^>]+)>", re.IGNORECASE)
_source_src_re = re.compile("src=\"(?P<src>[^\"]+)\"", re.IGNORECASE)
_source_type_re = re.compile("type=\"(?P<type>[^\"]+)\"", re.IGNORECASE)
class NOS(Plugin):
@classmethod
def can_handle_url(cls, url):
return _url_re.match(url)
def _resolve_stream(self):
res = http.get(self.url)
match = _data_stream_re.search(res.text)
if not match:
return
data_stream = match.group(1)
resolve_data = {
'stream': data_stream
}
res = http.post(
'http://www-ipv4.nos.nl/livestream/resolve/',
data=json.dumps(resolve_data)
)
data = http.json(res)
res = http.get(data['url'])
match = _js_re.search(res.text)
if not match:
return
stream_url = parse_json(match.group(1))
return HLSStream.parse_variant_playlist(self.session, stream_url)
def _get_source_streams(self):
res = http.get(self.url)
streams = {}
sources = _source_re.findall(res.text)
for source in sources:
src = _source_src_re.search(source).group("src")
pixels = _source_type_re.search(source).group("type")
streams[pixels] = HTTPStream(self.session, src)
return streams
def _get_streams(self):
urlparts = self.url.split('/')
if urlparts[-2] == 'livestream':
return self._resolve_stream()
else:
return self._get_source_streams()
__plugin__ = NOS
livestreamer-1.12.2/src/livestreamer/plugins/nhkworld.py 0000644 0001750 0001750 00000002356 12521217321 024553 0 ustar chrippa chrippa 0000000 0000000 """Plugin for NHK World, NHK Japan's english TV channel."""
import re
from livestreamer.plugin import Plugin
from livestreamer.plugin.api import http, validate
from livestreamer.stream import HDSStream
API_URL = "http://api.sh.nhk.fivecool.tv/api/cdn/?publicId=3bz2huey&playerId=7Dy"
_url_re = re.compile("http(s)?://(\w+\.)?nhk.or.jp/nhkworld")
_schema = validate.Schema({
"live-streams": [{
"streams": validate.all(
[{
"protocol": validate.text,
"streamUrl": validate.text
}],
validate.filter(lambda s: s["protocol"] in ("http-flash", "http-hds"))
)
}]
})
class NHKWorld(Plugin):
@classmethod
def can_handle_url(cls, url):
return _url_re.match(url)
def _get_streams(self):
res = http.get(API_URL)
data = http.json(res, schema=_schema)
streams = {}
for livestreams in data["live-streams"]:
for stream in livestreams["streams"]:
url = stream["streamUrl"]
for name, stream in HDSStream.parse_manifest(self.session, url).items():
if name.endswith("k"):
streams[name] = stream
return streams
__plugin__ = NHKWorld
livestreamer-1.12.2/src/livestreamer/plugins/mlgtv.py 0000644 0001750 0001750 00000005577 12521217321 024064 0 ustar chrippa chrippa 0000000 0000000 import re
from livestreamer.plugin import Plugin
from livestreamer.plugin.api import StreamMapper, http, validate
from livestreamer.plugin.api.utils import parse_json
from livestreamer.stream import HDSStream, HLSStream
PLAYER_EMBED_URL = "http://www.majorleaguegaming.com/player/embed/{0}"
STREAM_API_URL = "http://streamapi.majorleaguegaming.com/service/streams/playback/{0}"
STREAM_TYPES = {
"hls": HLSStream.parse_variant_playlist,
"hds": HDSStream.parse_manifest
}
_stream_id_re = re.compile(r"<meta content='.+/([\w_-]+).+' property='og:video'>")
_player_config_re = re.compile(r"var playerConfig = (.+);")
_url_re = re.compile("http(s)?://(\w+\.)?(majorleaguegaming\.com|mlg\.tv)")
_player_config_schema = validate.Schema(
{
"media": {
"stream_name": validate.text
}
},
validate.get("media", {}),
validate.get("stream_name")
)
_stream_schema = validate.Schema(
{
"data": {
"items": validate.all(
[{
"format": validate.text,
"url": validate.text
}],
validate.filter(lambda s: s["format"] in STREAM_TYPES)
)
}
},
validate.get("data", {}),
validate.get("items", [])
)
class MLGTV(Plugin):
@classmethod
def can_handle_url(self, url):
return _url_re.match(url)
def _find_channel_id(self, text):
match = _stream_id_re.search(text)
if match:
return match.group(1)
def _find_stream_id(self, text):
match = _player_config_re.search(text)
if match:
stream_id = parse_json(match.group(1),
schema=_player_config_schema)
return stream_id
def _create_streams(self, parser, stream):
try:
streams = parser(self.session, stream["url"])
return streams.items()
except IOError as err:
if not re.search(r"(404|400) Client Error", str(err)):
self.logger.error("Failed to extract {0} streams: {1}",
stream["format"].upper(), err)
def _get_streams(self):
res = http.get(self.url)
channel_id = self._find_channel_id(res.text)
if not channel_id:
return
res = http.get(PLAYER_EMBED_URL.format(channel_id))
stream_id = self._find_stream_id(res.text)
if not stream_id:
return
res = http.get(STREAM_API_URL.format(stream_id),
params=dict(format="all"))
items = http.json(res, schema=_stream_schema)
mapper = StreamMapper(
cmp=lambda type, stream: stream["format"] == type
)
mapper.map("hls", self._create_streams, HLSStream.parse_variant_playlist)
mapper.map("hds", self._create_streams, HDSStream.parse_manifest)
return mapper(items)
__plugin__ = MLGTV
livestreamer-1.12.2/src/livestreamer/plugins/mips.py 0000644 0001750 0001750 00000003460 12521217321 023670 0 ustar chrippa chrippa 0000000 0000000 import re
from livestreamer.plugin import Plugin
from livestreamer.plugin.api import http, validate
from livestreamer.plugin.api.utils import parse_query
from livestreamer.stream import RTMPStream
BALANCER_URL = "http://www.mips.tv:1935/loadbalancer"
PLAYER_URL = "http://mips.tv/embedplayer/{0}/1/500/400"
SWF_URL = "http://mips.tv/content/scripts/eplayer.swf"
_url_re = re.compile("http(s)?://(\w+.)?mips.tv/(?P<channel>[^/&?]+)")
_flashvars_re = re.compile("'FlashVars', '([^']+)'")
_rtmp_re = re.compile("redirect=(.+)")
_schema = validate.Schema(
validate.transform(_flashvars_re.search),
validate.any(
None,
validate.all(
validate.get(1),
validate.transform(parse_query),
{
"id": validate.transform(int),
validate.optional("s"): validate.text
}
)
)
)
_rtmp_schema = validate.Schema(
validate.transform(_rtmp_re.search),
validate.get(1),
)
class Mips(Plugin):
@classmethod
def can_handle_url(self, url):
return _url_re.match(url)
def _get_streams(self):
match = _url_re.match(self.url)
channel = match.group("channel")
headers = {"Referer": self.url}
url = PLAYER_URL.format(channel)
res = http.get(url, headers=headers, schema=_schema)
if not res or "s" not in res:
return
streams = {}
server = http.get(BALANCER_URL, headers=headers, schema=_rtmp_schema)
playpath = "{0}?{1}".format(res["s"], res["id"])
streams["live"] = RTMPStream(self.session, {
"rtmp": "rtmp://{0}/live/{1}".format(server, playpath),
"pageUrl": self.url,
"swfVfy": SWF_URL,
"conn": "S:OK",
"live": True
})
return streams
__plugin__ = Mips
livestreamer-1.12.2/src/livestreamer/plugins/media_ccc_de.py 0000644 0001750 0001750 00000015411 12521217321 025256 0 ustar chrippa chrippa 0000000 0000000 """Plugin for media.ccc.de
Media.ccc.de is a distribution platform for multimedia files provided by the
Chaos Computer Club. It provides a wide variety of video and audio material
in native formats.
Some CCC related events like the Chaos Communication Congress are live
streamed on streaming.media.ccc.de.
Supports:
- http://media.ccc.de (vod)
- http://streaming.media.ccc.de (livestreaming)
Limitations:
* streaming.media.ccc.de:
- only HLS and audio only (opus and mp3) live streams are supported
* media.ccc.de
- only mp4 and audio only (opus and mp3) recordings are supported
"""
import re
from livestreamer.plugin import Plugin, PluginError
from livestreamer.plugin.api import http
from livestreamer.stream import HTTPStream, HLSStream
API_URL_MEDIA = "https://api.media.ccc.de"
API_URL_STREAMING_MEDIA = "http://streaming.media.ccc.de/streams/v1.json"
# http(s)://media.ccc.de/path/to/talk.html
_url_media_re = re.compile("(?P<scheme>http|https)"
":\/\/"
"(?P<server>media\.ccc\.de)"
"\/.*\.html")
# http://streaming.media.ccc.de/room/
_url_streaming_media_re = re.compile("(?P<scheme>http)"
":\/\/"
"(?P<server>streaming\.media\.ccc\.de)"
"\/"
"(?P<room>.*)"
"\/")
def get_event_id(url):
"""Extract event id from talk html page.
Raises :exc:`PluginError` on failure.
:param url: talk URL
"""
match = re.search(r"{event_id:\s(?P<event_id>\d+),.*}", http.get(url).text)
try:
event_id = int(match.group('event_id'))
except:
raise PluginError("Failed to get event id from URL.")
return event_id
def get_json(url):
"""Fetch page for given URL and return json Python object.
:param url: URL to fetch
"""
res = http.get(url)
return http.json(res)
def parse_media_json(json_object):
"""Expose available file formats.
:param json_string: json as string
"""
recordings = {}
for recording in json_object['recordings']:
match = re.search(r".*\/(?P<format>.*)", recording['mime_type'])
file_format = match.group('format')
if recording['mime_type'] == 'vnd.voc/mp4-web' or\
recording['display_mime_type'] == 'video/webm':
continue
elif recording['mime_type'] == 'vnd.voc/h264-hd':
name = "1080p"
elif recording['mime_type'] == 'vnd.voc/h264-lq':
name = "420p"
elif re.match(r"audio", recording['display_mime_type']):
name = "audio_%s" % file_format
else:
if recording['hd'] == 'True':
name = "1080p"
else:
name = "420p"
recordings[name] = recording['recording_url']
return recordings
def parse_streaming_media_json(json_object, room_from_url):
"""Filter all availabe live streams for given json and room name.
API-Doku: https://github.com/voc/streaming-website#json-api
:param json_string: json as string
:param room_from_url:
"""
streams = {}
for group in json_object:
for room in group['rooms']:
# only consider to requested room
match = _url_streaming_media_re.match(room['link'])
if not match.group('room') == room_from_url:
continue
for stream in room['streams']:
# get stream language
if stream['isTranslated'] == False:
language = 'native'
else:
language = 'translated'
# get available hls stream urls
hls_stream = stream['urls'].get('hls')
if hls_stream:
stream_url = hls_stream['url']
name = None
# native HLS streams are announced as
# ${height}p and (hd|sd)_native_${height}p
if language == 'native':
name = "%sp" % stream['videoSize'][-1]
long_name = "hls_%s_%sp" % ("native",\
stream['videoSize'][-1])
streams[name] = stream_url
streams[long_name] = stream_url
elif language == 'translated':
long_name = "hls_%s_%sp" % ("translated",\
stream['videoSize'][-1])
streams[long_name] = stream_url
# get available audio only mpeg urls
mp3_stream = stream['urls'].get('mp3')
if mp3_stream:
stream_url = mp3_stream['url']
name = "audio_%s_mpeg" % language
streams[name] = stream_url
# get available audio only opus urls
opus_stream = stream['urls'].get('opus')
if opus_stream:
stream_url = opus_stream['url']
name = "audio_%s_opus" % language
streams[name] = stream_url
return streams
class media_ccc_de(Plugin):
@classmethod
def can_handle_url(self, url):
return _url_media_re.match(url) or _url_streaming_media_re.match(url)
def _get_streams(self):
streams = {}
# streaming.media.ccc.de
match = _url_streaming_media_re.match(self.url)
if match:
query_url = API_URL_STREAMING_MEDIA
live_streams = parse_streaming_media_json(get_json(query_url),\
match.group('room'))
for stream_name, stream_url in live_streams.items():
if re.search(r"m3u8", live_streams[stream_name]):
streams[stream_name] = HLSStream(self.session,\
stream_url)
else:
streams[stream_name] = HTTPStream(self.session,\
stream_url)
# media.ccc.de
elif _url_media_re.search(self.url):
event_id = get_event_id(self.url)
query_url = "%s/public/events/%i" % (API_URL_MEDIA, event_id)
recordings = parse_media_json(get_json(query_url))
for name, stream_url in recordings.items():
streams[name] = HTTPStream(self.session, stream_url)
if not streams:
raise PluginError("This plugin does not support your "
"selected video.")
return streams
__plugin__ = media_ccc_de
livestreamer-1.12.2/src/livestreamer/plugins/livestream.py 0000644 0001750 0001750 00000010212 12521217321 025064 0 ustar chrippa chrippa 0000000 0000000 import re
from livestreamer.compat import urljoin
from livestreamer.plugin import Plugin
from livestreamer.plugin.api import http, validate
from livestreamer.plugin.api.utils import parse_json
from livestreamer.stream import AkamaiHDStream, HLSStream
_url_re = re.compile("http(s)?://(www\.)?livestream.com/")
_stream_config_schema = validate.Schema({
"event": {
"stream_info": validate.any({
"is_live": bool,
"qualities": [{
"bitrate": int,
"height": int
}],
validate.optional("play_url"): validate.url(scheme="http"),
validate.optional("m3u8_url"): validate.url(
scheme="http",
path=validate.endswith(".m3u8")
),
}, None)
},
validate.optional("viewerPlusSwfUrl"): validate.url(scheme="http"),
validate.optional("hdPlayerSwfUrl"): validate.text
})
_smil_schema = validate.Schema(validate.union({
"http_base": validate.all(
validate.xml_find("{http://www.w3.org/2001/SMIL20/Language}head/"
"{http://www.w3.org/2001/SMIL20/Language}meta"
"[@name='httpBase']"),
validate.xml_element(attrib={
"content": validate.text
}),
validate.get("content")
),
"videos": validate.all(
validate.xml_findall("{http://www.w3.org/2001/SMIL20/Language}body/"
"{http://www.w3.org/2001/SMIL20/Language}switch/"
"{http://www.w3.org/2001/SMIL20/Language}video"),
[
validate.all(
validate.xml_element(attrib={
"src": validate.text,
"system-bitrate": validate.all(
validate.text,
validate.transform(int)
)
}),
validate.transform(
lambda e: (e.attrib["src"], e.attrib["system-bitrate"])
)
)
],
)
}))
class Livestream(Plugin):
@classmethod
def default_stream_types(cls, streams):
return ["akamaihd", "hls"]
@classmethod
def can_handle_url(self, url):
return _url_re.match(url)
def _get_stream_info(self):
res = http.get(self.url)
match = re.search("window.config = ({.+})", res.text)
if match:
config = match.group(1)
return parse_json(config, "config JSON",
schema=_stream_config_schema)
def _parse_smil(self, url, swf_url):
res = http.get(url)
smil = http.xml(res, "SMIL config", schema=_smil_schema)
for src, bitrate in smil["videos"]:
url = urljoin(smil["http_base"], src)
yield bitrate, AkamaiHDStream(self.session, url, swf=swf_url)
def _get_streams(self):
info = self._get_stream_info()
if not info:
return
stream_info = info["event"]["stream_info"]
if not (stream_info and stream_info["is_live"]):
# Stream is not live
return
play_url = stream_info.get("play_url")
if play_url:
swf_url = info.get("viewerPlusSwfUrl") or info.get("hdPlayerSwfUrl")
if not swf_url.startswith("http"):
swf_url = "http://" + swf_url
# Work around broken SSL.
swf_url = swf_url.replace("https://", "http://")
qualities = stream_info["qualities"]
for bitrate, stream in self._parse_smil(play_url, swf_url):
name = "{0}k".format(bitrate / 1000)
for quality in qualities:
if quality["bitrate"] == bitrate:
name = "{0}p".format(quality["height"])
yield name, stream
m3u8_url = stream_info.get("m3u8_url")
if m3u8_url:
streams = HLSStream.parse_variant_playlist(self.session, m3u8_url,
namekey="pixels")
# TODO: Replace with "yield from" when dropping Python 2.
for stream in streams.items():
yield stream
__plugin__ = Livestream
livestreamer-1.12.2/src/livestreamer/plugins/livestation.py 0000644 0001750 0001750 00000005152 12521217321 025261 0 ustar chrippa chrippa 0000000 0000000 import re
from livestreamer.plugin import Plugin, PluginError, PluginOptions
from livestreamer.plugin.api import http, validate
from livestreamer.stream import HLSStream
LOGIN_PAGE_URL = "http://www.livestation.com/en/users/new"
LOGIN_POST_URL = "http://www.livestation.com/en/sessions.json"
_csrf_token_re = re.compile("<meta content=\"([^\"]+)\" name=\"csrf-token\"")
_hls_playlist_re = re.compile("<meta content=\"([^\"]+.m3u8)\" property=\"og:video\" />")
_url_re = re.compile("http(s)?://(\w+\.)?livestation.com")
_csrf_token_schema = validate.Schema(
validate.transform(_csrf_token_re.search),
validate.any(None, validate.get(1))
)
_hls_playlist_schema = validate.Schema(
validate.transform(_hls_playlist_re.search),
validate.any(
None,
validate.all(
validate.get(1),
validate.url(scheme="http", path=validate.endswith(".m3u8"))
)
)
)
_login_schema = validate.Schema({
"email": validate.text,
validate.optional("errors"): validate.all(
{
"base": [validate.text]
},
validate.get("base"),
)
})
class Livestation(Plugin):
options = PluginOptions({
"email": "",
"password": ""
})
@classmethod
def can_handle_url(self, url):
return _url_re.match(url)
def _authenticate(self, email, password):
csrf_token = http.get(LOGIN_PAGE_URL, schema=_csrf_token_schema)
if not csrf_token:
raise PluginError("Unable to find CSRF token")
data = {
"authenticity_token": csrf_token,
"channel_id": "",
"commit": "Login",
"plan_id": "",
"session[email]": email,
"session[password]": password,
"utf8": "\xE2\x9C\x93", # Check Mark Character
}
res = http.post(LOGIN_POST_URL, data=data, acceptable_status=(200, 422))
result = http.json(res, schema=_login_schema)
errors = result.get("errors")
if errors:
errors = ", ".join(errors)
raise PluginError("Unable to authenticate: {0}".format(errors))
self.logger.info("Successfully logged in as {0}", result["email"])
def _get_streams(self):
login_email = self.options.get("email")
login_password = self.options.get("password")
if login_email and login_password:
self._authenticate(login_email, login_password)
hls_playlist = http.get(self.url, schema=_hls_playlist_schema)
if not hls_playlist:
return
return HLSStream.parse_variant_playlist(self.session, hls_playlist)
__plugin__ = Livestation
livestreamer-1.12.2/src/livestreamer/plugins/letontv.py 0000644 0001750 0001750 00000003765 12521217321 024423 0 ustar chrippa chrippa 0000000 0000000 import re
from livestreamer.plugin import Plugin
from livestreamer.plugin.api import http, validate
from livestreamer.stream import RTMPStream
PLAYER_URL = "http://leton.tv/player.php"
SWF_URL = "http://files.leton.tv/jwplayer.flash.swf"
_url_re = re.compile("""
http?://(\w+.)?leton.tv
(?:
/player\.php\?.*streampage=
)?
(?:
/broadcast/
)?
(?P<streampage>[^/?&]+)
""", re.VERBOSE)
_js_var_re = re.compile("var (?P<var>\w+)\s?=\s?'?(?P<value>[^;']+)'?;")
_rtmp_re = re.compile("/(?P<app>[^/]+)/(?P<playpath>.+)")
def _parse_server_ip(values):
octets = [
values["a"] / values["f"],
values["b"] / values["f"],
values["c"] / values["f"],
values["d"] / values["f"],
]
return ".".join(str(int(octet)) for octet in octets)
_schema = validate.Schema(
validate.transform(_js_var_re.findall),
validate.transform(dict),
{
"a": validate.transform(int),
"b": validate.transform(int),
"c": validate.transform(int),
"d": validate.transform(int),
"f": validate.transform(int),
"v_part": validate.text,
},
validate.union({
"server_ip": validate.transform(_parse_server_ip),
"path": validate.all(
validate.get("v_part"),
validate.transform(_rtmp_re.findall),
validate.get(0)
)
})
)
class LetOnTV(Plugin):
@classmethod
def can_handle_url(self, url):
return _url_re.match(url)
def _get_streams(self):
match = _url_re.match(self.url)
info = http.get(PLAYER_URL, params=match.groupdict(), schema=_schema)
if not info["path"]:
return
app, playpath = info["path"]
stream = RTMPStream(self.session, {
"rtmp": "rtmp://{0}/{1}".format(info["server_ip"], app),
"playpath": playpath,
"pageUrl": self.url,
"swfUrl": SWF_URL,
"live": True
})
return dict(live=stream)
__plugin__ = LetOnTV
livestreamer-1.12.2/src/livestreamer/plugins/itvplayer.py 0000644 0001750 0001750 00000015036 12521217321 024741 0 ustar chrippa chrippa 0000000 0000000 import re
from uuid import uuid4
try:
import xml.etree.cElementTree as ET
except ImportError:
import xml.etree.ElementTree as ET
from livestreamer.plugin import Plugin
from livestreamer.plugin.api import http
from livestreamer.stream import RTMPStream
from livestreamer.compat import urlparse
ITV_PLAYER_USER_AGENT = 'Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/32.0.1700.107 Safari/537.36'
LIVE_SWF_URL = "http://www.itv.com/mediaplayer/ITVMediaPlayer.swf"
ONDEMAND_SWF_URL = "http://www.itv.com/mercury/Mercury_VideoPlayer.swf"
CHANNEL_MAP = {'itv': 1, 'itv2': 2, 'itv3': 3, 'itv4': 4, 'itvbe': 8, 'citv': 7}
_url_re = re.compile(r"https://(?:www.)?itv.com/itvplayer/(?P<stream>.+)")
class ITVPlayer(Plugin):
def __init__(self, url):
Plugin.__init__(self, url)
match = _url_re.match(url)
self._stream = match and match.groupdict()["stream"]
@classmethod
def can_handle_url(self, url):
match = _url_re.match(url)
return match
@property
def channel_id(self):
if self._stream in CHANNEL_MAP:
return CHANNEL_MAP[self._stream]
@property
def production_id(self):
if self._stream not in CHANNEL_MAP:
res = http.get(self.url, verify=False)
production_id_match = re.findall(r'"productionId":"(.*?)",', res.text, flags=re.DOTALL)
if production_id_match:
return production_id_match[0]
def _get_streams(self):
"""
Find all the streams for the ITV url
:return: Mapping of quality to stream
"""
soap_message = self._soap_request()
headers = {'Content-Length': '{0:d}'.format(len(soap_message)),
'Content-Type': 'text/xml; charset=utf-8',
'Host': 'mercury.itv.com',
'Origin': 'http://www.itv.com',
'Referer': 'http://www.itv.com/Mercury/Mercury_VideoPlayer.swf?v=null',
'SOAPAction': "http://tempuri.org/PlaylistService/GetPlaylist",
'User-Agent': ITV_PLAYER_USER_AGENT,
"X-Requested-With": "ShockwaveFlash/16.0.0.305"}
res = http.post("http://mercury.itv.com/PlaylistService.svc?wsdl",
headers=headers,
data=soap_message)
# looking for the <MediaFiles> tag
xmldoc = http.xml(res)
mediafiles = xmldoc.find(".//VideoEntries//MediaFiles")
# No mediafiles, no streams
if not mediafiles:
return None
rtmp = mediafiles.attrib['base']
streams = {}
for mediafile in mediafiles.findall("MediaFile"):
playpath = mediafile.find("URL").text
rtmp_url = urlparse(rtmp)
app = (rtmp_url.path[1:] + '?' + rtmp_url.query).rstrip('?')
live = app == "live"
params = dict(rtmp="{u.scheme}://{u.netloc}{u.path}".format(u=rtmp_url),
app=app.rstrip('?'),
playpath=playpath,
swfVfy=LIVE_SWF_URL if live else ONDEMAND_SWF_URL,
timeout=10)
if live:
params['live'] = True
bitrate = int(mediafile.attrib['bitrate']) / 1000
quality = "{0}k".format(bitrate)
streams[quality] = RTMPStream(self.session, params)
return streams
def _soap_request(self):
def sub_ns(parent, tag, ns):
return ET.SubElement(parent, "{%s}%s" % (ns, tag))
def sub_common(parent, tag):
return sub_ns(parent, tag, "http://schemas.itv.com/2009/05/Common")
def sub_soap(parent, tag):
return sub_ns(parent, tag, "http://schemas.xmlsoap.org/soap/envelope/")
def sub_item(parent, tag):
return sub_ns(parent, tag, "http://tempuri.org/")
def sub_itv(parent, tag):
return sub_ns(parent, tag, "http://schemas.datacontract.org/2004/07/Itv.BB.Mercury.Common.Types")
production_id = self.production_id
channel_id = self.channel_id
ET.register_namespace("com", "http://schemas.itv.com/2009/05/Common")
ET.register_namespace("soapenv", "http://schemas.xmlsoap.org/soap/envelope/")
ET.register_namespace("tem", "http://tempuri.org/")
ET.register_namespace("itv", "http://schemas.datacontract.org/2004/07/Itv.BB.Mercury.Common.Types")
# Start of XML
root = ET.Element("{http://schemas.xmlsoap.org/soap/envelope/}Envelope")
sub_soap(root, "Header")
body = sub_soap(root, "Body")
# build request
get_playlist = sub_item(body, "GetPlaylist")
request = sub_item(get_playlist, "request")
prode = sub_itv(request, "ProductionId")
if production_id:
# request -> ProductionId
prode.text = production_id
# request -> RequestGuid
sub_itv(request, "RequestGuid").text = str(uuid4()).upper()
vodcrid = sub_itv(request, "Vodcrid")
# request -> Vodcrid -> Id
vod_id = sub_common(vodcrid, "Id")
# request -> Vodcrid -> Partition
sub_common(vodcrid, "Partition").text = "itv.com"
if channel_id:
vod_id.text = "sim{0}".format(channel_id)
# build userinfo
userinfo = sub_item(get_playlist, "userInfo")
sub_itv(userinfo, "Broadcaster").text = "Itv"
sub_itv(userinfo, "RevenueScienceValue").text = "ITVPLAYER.2.14.1.+build.4a9166f0ba"
sub_itv(userinfo, "SessionId")
sub_itv(userinfo, "SsoToken")
sub_itv(userinfo, "UserToken")
# GeoLocationToken -> Token
# sub_itv(sub_itv(userinfo, "GeoLocationToken"), "Token")
# build siteinfo
siteinfo = sub_item(get_playlist, "siteInfo")
sub_itv(siteinfo, "AdvertisingRestriction").text = "None"
sub_itv(siteinfo, "AdvertisingSite").text = "ITV"
sub_itv(siteinfo, "AdvertisingType").text = "Any"
sub_itv(siteinfo,
"Area").text = "ITVPLAYER.VIDEO" # "channels.itv{0}".format(channel_id) if channel_id else "ITVPLAYER.VIDEO"
sub_itv(siteinfo, "Category")
sub_itv(siteinfo, "Platform").text = "DotCom"
sub_itv(siteinfo, "Site").text = "ItvCom"
# build deviceInfo
deviceinfo = sub_item(get_playlist, "deviceInfo")
sub_itv(deviceinfo, "ScreenSize").text = "Big"
# build playerinfo
playerinfo = sub_item(get_playlist, "playerInfo")
sub_itv(playerinfo, "Version").text = "2"
return ET.tostring(root)
__plugin__ = ITVPlayer
livestreamer-1.12.2/src/livestreamer/plugins/hitbox.py 0000644 0001750 0001750 00000014354 12521217321 024221 0 ustar chrippa chrippa 0000000 0000000 import re
from itertools import chain
from livestreamer.compat import urlparse
from livestreamer.plugin import Plugin
from livestreamer.plugin.api import StreamMapper, http, validate
from livestreamer.stream import HLSStream, HTTPStream, RTMPStream
from livestreamer.utils import absolute_url
HLS_PLAYLIST_BASE = "http://www.hitbox.tv{0}"
LIVE_API = "http://www.hitbox.tv/api/media/live/{0}?showHidden=true"
PLAYER_API = "http://www.hitbox.tv/api/player/config/{0}/{1}?embed=false&showHidden=true"
SWF_BASE = "http://edge.vie.hitbox.tv/static/player/flowplayer/"
SWF_URL = SWF_BASE + "flowplayer.commercial-3.2.16.swf"
VOD_BASE_URL = "http://www.hitbox.tv/"
_quality_re = re.compile("(\d+p)$")
_url_re = re.compile("""
http(s)?://(www\.)?hitbox.tv
/(?P<channel>[^/]+)
(?:
/(?P<media_id>[^/]+)
)?
""", re.VERBOSE)
_live_schema = validate.Schema(
{
"livestream": [{
"media_is_live": validate.all(
validate.text,
validate.transform(int),
validate.transform(bool)
),
"media_id": validate.text
}],
},
validate.get("livestream"),
validate.length(1),
validate.get(0)
)
_player_schema = validate.Schema(
{
"clip": {
"baseUrl": validate.any(None, validate.text),
"bitrates": validate.all(
validate.filter(lambda b: b.get("url") and b.get("label")),
[{
"label": validate.text,
"url": validate.text,
}],
)
},
validate.optional("playlist"): [{
validate.optional("connectionProvider"): validate.text,
validate.optional("netConnectionUrl"): validate.text,
validate.optional("bitrates"): [{
"label": validate.text,
"url": validate.text,
"provider": validate.text
}]
}],
"plugins": validate.all(
dict,
validate.filter(lambda k, v: k in ["rtmp", "rtmpHitbox", "hls"]),
{
validate.text: {
validate.optional("netConnectionUrl"): validate.text,
"url": validate.text
}
}
)
}
)
class Hitbox(Plugin):
@classmethod
def can_handle_url(self, url):
return _url_re.match(url)
def _get_quality(self, label):
match = _quality_re.search(label)
if match:
return match.group(1)
return "live"
def _create_hls_streams(self, bitrate):
url = bitrate["url"]
quality = self._get_quality(bitrate["label"])
if not url.startswith("http"):
url = HLS_PLAYLIST_BASE.format(url)
if bitrate["label"] == "Auto":
try:
streams = HLSStream.parse_variant_playlist(self.session, url)
return streams.items()
except IOError as err:
self.logger.warning("Failed to extract HLS streams: {0}", err)
else:
return quality, HLSStream(self.session, url)
def _create_rtmp_stream(self, rtmp, swf_url, bitrate):
quality = self._get_quality(bitrate["label"])
url = bitrate["url"]
stream = RTMPStream(self.session, {
"rtmp": rtmp,
"pageUrl": self.url,
"playpath": url,
"swfVfy": swf_url,
"live": True
})
return quality, stream
def _get_live_streams(self, player):
mappers = []
swf_url = SWF_URL
for playlist in player.get("playlist", []):
bitrates = playlist.get("bitrates")
provider = playlist.get("connectionProvider")
rtmp = None
if bitrates:
rtmp = playlist.get("netConnectionUrl")
elif provider and provider in player["plugins"]:
provider = player["plugins"][provider]
swf_name = provider["url"]
swf_url = SWF_BASE + swf_name
rtmp = provider["netConnectionUrl"]
bitrates = player["clip"]["bitrates"]
else:
continue
mapper = StreamMapper(
cmp=lambda provider, bitrate: bitrate["provider"].startswith(provider)
)
mapper.map("hls", self._create_hls_streams)
mapper.map("rtmp", self._create_rtmp_stream, rtmp, swf_url)
mappers.append(mapper(bitrates))
return chain.from_iterable(mappers)
def _create_video_stream(self, cls, base_url, bitrate):
url = absolute_url(base_url, bitrate["url"])
if bitrate["label"].lower() == "auto":
try:
return cls.parse_variant_playlist(self.session, url).items()
except IOError as err:
self.logger.warning("Failed to extract HLS streams: {0}", err)
return
quality = self._get_quality(bitrate["label"])
return quality, cls(self.session, url)
def _get_video_streams(self, player):
base_url = player["clip"]["baseUrl"] or VOD_BASE_URL
mapper = StreamMapper(
cmp=lambda ext, bitrate: urlparse(bitrate["url"]).path.endswith(ext)
)
mapper.map(".m3u8", self._create_video_stream, HLSStream, base_url)
mapper.map(".mp4", self._create_video_stream, HTTPStream, base_url)
mapper.map(".flv", self._create_video_stream, HTTPStream, base_url)
return mapper(player["clip"]["bitrates"])
def _get_streams(self):
match = _url_re.match(self.url)
if not match:
return
channel, media_id = match.group("channel", "media_id")
if channel != "video":
res = http.get(LIVE_API.format(channel))
livestream = http.json(res, schema=_live_schema)
if not livestream["media_is_live"]:
return
media_id = livestream["media_id"]
media_type = "live"
else:
media_type = "video"
res = http.get(PLAYER_API.format(media_type, media_id))
player = http.json(res, schema=_player_schema)
if media_type == "live":
return self._get_live_streams(player)
else:
return self._get_video_streams(player)
__plugin__ = Hitbox
livestreamer-1.12.2/src/livestreamer/plugins/goodgame.py 0000644 0001750 0001750 00000002343 12521217321 024501 0 ustar chrippa chrippa 0000000 0000000 import re
from livestreamer.plugin import Plugin
from livestreamer.plugin.api import http
from livestreamer.stream import HLSStream
HLS_URL_FORMAT = "http://hls.goodgame.ru/hls/{0}{1}.m3u8"
QUALITIES = {
"1080p": "",
"720p": "_720",
"480p": "_480",
"240p": "_240"
}
_url_re = re.compile("http://(?:www\.)?goodgame.ru/channel/(?P<user>\w+)/")
_stream_re = re.compile(
"iframe frameborder=\"0\" width=\"100%\" height=\"100%\" src=\"http://goodgame.ru/player(\d)?\?(\d+)\""
)
class GoodGame(Plugin):
@classmethod
def can_handle_url(self, url):
return _url_re.match(url)
def _check_stream(self, url):
res = http.get(url, acceptable_status=(200, 404))
if res.status_code == 200:
return True
def _get_streams(self):
res = http.get(self.url)
match = _stream_re.search(res.text)
if not match:
return
stream_id = match.group(2)
streams = {}
for name, url_suffix in QUALITIES.items():
url = HLS_URL_FORMAT.format(stream_id, url_suffix)
if not self._check_stream(url):
continue
streams[name] = HLSStream(self.session, url)
return streams
__plugin__ = GoodGame
livestreamer-1.12.2/src/livestreamer/plugins/gomexp.py 0000644 0001750 0001750 00000002574 12521217321 024224 0 ustar chrippa chrippa 0000000 0000000 """Plugin for GOMeXP live streams.
This plugin is using the same API as the mobile app.
"""
import re
from livestreamer.plugin import Plugin
from livestreamer.plugin.api import http, validate
from livestreamer.stream import HLSStream
API_BASE = "http://gox.gomexp.com/cgi-bin"
API_URL_APP = API_BASE + "/app_api.cgi"
API_URL_LIVE = API_BASE + "/gox_live.cgi"
_url_re = re.compile("http(s)?://(www\.)?gomexp.com")
_entries_schema = validate.Schema(
validate.xml_findall("./ENTRY/*/[@reftype='live'][@href]"),
[validate.get("href")]
)
class GOMeXP(Plugin):
@classmethod
def can_handle_url(self, url):
return _url_re.match(url)
def _get_live_cubeid(self):
res = http.get(API_URL_APP, params=dict(mode="get_live"))
root = http.xml(res)
return root.findtext("./cube/cubeid")
def _get_streams(self):
cubeid = self._get_live_cubeid()
if not cubeid:
return
res = http.get(API_URL_LIVE, params=dict(cubeid=cubeid))
entries = http.xml(res, schema=_entries_schema)
streams = {}
for url in entries:
try:
streams.update(
HLSStream.parse_variant_playlist(self.session, url)
)
except IOError as err:
self.logger.error("Failed to open playlist: {0}", err)
return streams
__plugin__ = GOMeXP
livestreamer-1.12.2/src/livestreamer/plugins/gaminglive.py 0000644 0001750 0001750 00000005622 12521217321 025044 0 ustar chrippa chrippa 0000000 0000000 import re
from livestreamer.plugin import Plugin
from livestreamer.plugin.api import http, validate
from livestreamer.stream import RTMPStream
SWF_URL = "http://www.gaminglive.tv/lib/flowplayer/flash/flowplayer.commercial-3.2.18.swf"
API_URL = "http://api.gaminglive.tv/{0}/{1}"
VOD_RTMP_URL = "rtmp://gamingfs.fplive.net/gaming/{0}/"
QUALITY_WEIGHTS = {
"source": 5,
"live": 5,
"1080": 4,
"720": 3,
"480": 2,
"medium": 2,
"360": 1,
"low": 1
}
_url_re = re.compile("""
http(s)?://(\w+\.)?gaminglive\.tv
/(?P<type>channels|videos)/(?P<name>[^/]+)
""", re.VERBOSE)
_quality_re = re.compile("[^/]+-(?P<quality>[^/]+)")
_channel_schema = validate.Schema(
{
validate.optional("state"): {
"stream": {
"qualities": [validate.text],
"rootUrl": validate.url(scheme="rtmp")
}
}
},
validate.get("state")
)
_vod_schema = validate.Schema(
{
"name": validate.text,
"channel_slug": validate.text,
"title": validate.text,
"created_at": validate.transform(int)
},
)
class GamingLive(Plugin):
@classmethod
def can_handle_url(self, url):
return _url_re.match(url)
@classmethod
def stream_weight(cls, key):
weight = QUALITY_WEIGHTS.get(key)
if weight:
return weight, "gaminglive"
return Plugin.stream_weight(key)
def _get_quality(self, label):
match = _quality_re.match(label)
if match:
return match.group("quality")
return "live"
def _create_rtmp_stream(self, rtmp, playpath, live):
return RTMPStream(self.session, {
"rtmp": rtmp,
"playpath": playpath,
"pageUrl": self.url,
"swfVfy": SWF_URL,
"live": live
})
def _get_live_streams(self, name):
res = http.get(API_URL.format("channels", name))
json = http.json(res, schema=_channel_schema)
if not json:
return
streams = {}
for quality in json["stream"]["qualities"]:
streams[self._get_quality(quality)] = self._create_rtmp_stream(json["stream"]["rootUrl"], quality, True)
return streams
def _get_vod_streams(self, name):
res = http.get(API_URL.format("videos", name))
json = http.json(res, schema=_vod_schema)
if not json:
return
streams = {}
streams["source"] = self._create_rtmp_stream(VOD_RTMP_URL.format(json["channel_slug"]), json["name"], True)
return streams
def _get_streams(self):
match = _url_re.match(self.url)
type = match.group("type")
if type == "channels":
return self._get_live_streams(match.group("name"))
elif type == "videos":
return self._get_vod_streams(match.group("name"))
__plugin__ = GamingLive
livestreamer-1.12.2/src/livestreamer/plugins/furstream.py 0000644 0001750 0001750 00000001702 12521217321 024725 0 ustar chrippa chrippa 0000000 0000000 import re
from livestreamer.plugin import Plugin
from livestreamer.plugin.api import http, validate
from livestreamer.stream import RTMPStream
_url_re = re.compile("^http(s)?://(\w+\.)?furstre\.am/stream/.+")
_stream_url_re = re.compile("<source src=\"([^\"]+)\"")
_schema = validate.Schema(
validate.transform(_stream_url_re.search),
validate.any(
None,
validate.all(
validate.get(1),
validate.url(
scheme="rtmp"
)
)
)
)
class Furstream(Plugin):
@classmethod
def can_handle_url(cls, url):
return _url_re.match(url)
def _get_streams(self):
stream_url = http.get(self.url, schema=_schema)
if not stream_url:
return
stream = RTMPStream(self.session, {
"rtmp": stream_url,
"pageUrl": self.url,
"live": True
})
return dict(live=stream)
__plugin__ = Furstream
livestreamer-1.12.2/src/livestreamer/plugins/filmon_us.py 0000644 0001750 0001750 00000010406 12521217321 024711 0 ustar chrippa chrippa 0000000 0000000 import re
from livestreamer.compat import urlparse
from livestreamer.plugin import Plugin
from livestreamer.plugin.api import http, validate
from livestreamer.plugin.api.utils import parse_json, parse_query
from livestreamer.stream import RTMPStream, HTTPStream
SWF_LIVE_URL = "https://www.filmon.com/tv/modules/FilmOnTV/files/flashapp/filmon/FilmonPlayer.swf"
SWF_VIDEO_URL = "http://www.filmon.us/application/themes/base/flash/MediaPlayer.swf"
_url_re = re.compile("http(s)?://(\w+\.)?filmon.us")
_live_export_re = re.compile(
"<iframe src=\"(https://www.filmon.com/channel/export[^\"]+)\""
)
_live_json_re = re.compile("var startupChannel = (.+);")
_replay_json_re = re.compile("var standByVideo = encodeURIComponent\('(.+)'\);")
_history_re = re.compile(
"helpers.common.flash.flashplayerinstall\({url:'([^']+)',"
)
_video_flashvars_re = re.compile(
"<embed width=\"486\" height=\"326\" flashvars=\"([^\"]+)\""
)
_live_schema = validate.Schema({
"streams": [{
"name": validate.text,
"quality": validate.text,
"url": validate.url(scheme="rtmp")
}]
})
_schema = validate.Schema(
validate.union({
"export_url": validate.all(
validate.transform(_live_export_re.search),
validate.any(
None,
validate.get(1),
)
),
"video_flashvars": validate.all(
validate.transform(_video_flashvars_re.search),
validate.any(
None,
validate.all(
validate.get(1),
validate.transform(parse_query),
{
"_111pix_serverURL": validate.url(scheme="rtmp"),
"en_flash_providerName": validate.text
}
)
)
),
"history_video": validate.all(
validate.transform(_history_re.search),
validate.any(
None,
validate.all(
validate.get(1),
validate.url(scheme="http")
)
)
),
"standby_video": validate.all(
validate.transform(_replay_json_re.search),
validate.any(
None,
validate.all(
validate.get(1),
validate.transform(parse_json),
[{
"streamName": validate.url(scheme="http")
}]
)
)
)
})
)
class Filmon_us(Plugin):
@classmethod
def can_handle_url(self, url):
return _url_re.match(url)
def _get_live_stream(self, export_url):
res = http.get(export_url)
match = _live_json_re.search(res.text)
if not match:
return
json = parse_json(match.group(1), schema=_live_schema)
streams = {}
for stream in json["streams"]:
stream_name = stream["quality"]
parsed = urlparse(stream["url"])
stream = RTMPStream(self.session, {
"rtmp": stream["url"],
"app": "{0}?{1}".format(parsed.path[1:], parsed.query),
"playpath": stream["name"],
"swfVfy": SWF_LIVE_URL,
"pageUrl": self.url,
"live": True
})
streams[stream_name] = stream
return streams
def _get_streams(self):
res = http.get(self.url, schema=_schema)
if res["export_url"]:
return self._get_live_stream(res["export_url"])
elif res["video_flashvars"]:
stream = RTMPStream(self.session, {
"rtmp": res["video_flashvars"]["_111pix_serverURL"],
"playpath": res["video_flashvars"]["en_flash_providerName"],
"swfVfy": SWF_VIDEO_URL,
"pageUrl": self.url
})
return dict(video=stream)
elif res["standby_video"]:
for stream in res["standby_video"]:
stream = HTTPStream(self.session, stream["streamName"])
return dict(replay=stream)
elif res["history_video"]:
stream = HTTPStream(self.session, res["history_video"])
return dict(history=stream)
return
__plugin__ = Filmon_us
livestreamer-1.12.2/src/livestreamer/plugins/filmon.py 0000644 0001750 0001750 00000010742 12521217321 024205 0 ustar chrippa chrippa 0000000 0000000 import re
from livestreamer.compat import urlparse
from livestreamer.plugin import Plugin
from livestreamer.plugin.api import http, validate
from livestreamer.stream import HLSStream, RTMPStream
CHINFO_URL = "http://www.filmon.com/ajax/getChannelInfo"
SWF_URL = "http://www.filmon.com/tv/modules/FilmOnTV/files/flashapp/filmon/FilmonPlayer.swf"
VODINFO_URL = "http://www.filmon.com/vod/info/{0}"
AJAX_HEADERS = {
"Referer": "http://www.filmon.com",
"X-Requested-With": "XMLHttpRequest",
"User-Agent": "Mozilla/5.0"
}
QUALITY_WEIGHTS = {
"high": 720,
"low": 480
}
STREAM_TYPES = ("hls", "rtmp")
_url_re = re.compile("http(s)?://(\w+\.)?filmon.com/(channel|tv|vod)/")
_channel_id_re = re.compile("/channels/(\d+)/extra_big_logo.png")
_vod_id_re = re.compile("movie_id=(\d+)")
_channel_schema = validate.Schema({
"streams": [{
"name": validate.text,
"quality": validate.text,
"url": validate.url(scheme=validate.any("http", "rtmp"))
}]
})
_vod_schema = validate.Schema(
{
"data": {
"streams": {
validate.text: {
"name": validate.text,
"url": validate.url(scheme=validate.any("http", "rtmp"))
}
}
}
},
validate.get("data")
)
def ajax(*args, **kwargs):
kwargs["headers"] = AJAX_HEADERS
return http.post(*args, **kwargs)
class Filmon(Plugin):
@classmethod
def can_handle_url(cls, url):
return _url_re.match(url)
@classmethod
def stream_weight(cls, key):
weight = QUALITY_WEIGHTS.get(key)
if weight:
return weight, "filmon"
return Plugin.stream_weight(key)
def _create_rtmp_stream(self, stream, live=True):
rtmp = stream["url"]
playpath = stream["name"]
parsed = urlparse(rtmp)
if parsed.query:
app = "{0}?{1}".format(parsed.path[1:], parsed.query)
else:
app = parsed.path[1:]
if playpath.endswith(".mp4"):
playpath = "mp4:" + playpath
params = {
"rtmp": rtmp,
"pageUrl": self.url,
"swfUrl": SWF_URL,
"playpath": playpath,
"app": app,
}
if live:
params["live"] = True
return RTMPStream(self.session, params)
def _get_live_streams(self, channel_id):
params = {"channel_id": channel_id}
for stream_type in STREAM_TYPES:
cookies = {"flash-player-type": stream_type}
res = ajax(CHINFO_URL, cookies=cookies, data=params)
channel = http.json(res, schema=_channel_schema)
# TODO: Replace with "yield from" when dropping Python 2.
for stream in self._parse_live_streams(channel):
yield stream
def _parse_live_streams(self, channel):
for stream in channel["streams"]:
name = stream["quality"]
scheme = urlparse(stream["url"]).scheme
if scheme == "http":
try:
streams = HLSStream.parse_variant_playlist(self.session, stream["url"])
for __, stream in streams.items():
yield name, stream
except IOError as err:
self.logger.error("Failed to extract HLS stream '{0}': {1}", name, err)
elif scheme == "rtmp":
yield name, self._create_rtmp_stream(stream)
def _get_vod_streams(self, movie_id):
for stream_type in STREAM_TYPES:
cookies = {"flash-player-type": stream_type}
res = ajax(VODINFO_URL.format(movie_id), cookies=cookies)
vod = http.json(res, schema=_vod_schema)
# TODO: Replace with "yield from" when dropping Python 2.
for stream in self._parse_vod_streams(vod):
yield stream
def _parse_vod_streams(self, vod):
for name, stream in vod["streams"].items():
scheme = urlparse(stream["url"]).scheme
if scheme == "http":
yield name, HLSStream(self.session, stream["url"])
elif scheme == "rtmp":
yield name, self._create_rtmp_stream(stream, live=False)
def _get_streams(self):
res = http.get(self.url)
match = _vod_id_re.search(res.text)
if match:
return self._get_vod_streams(match.group(1))
match = _channel_id_re.search(res.text)
if match:
return self._get_live_streams(match.group(1))
__plugin__ = Filmon
livestreamer-1.12.2/src/livestreamer/plugins/euronews.py 0000644 0001750 0001750 00000002474 12521217321 024573 0 ustar chrippa chrippa 0000000 0000000 import re
from itertools import chain
from livestreamer.compat import urlparse
from livestreamer.plugin import Plugin
from livestreamer.plugin.api import http
from livestreamer.stream import HLSStream, HTTPStream
from livestreamer.plugin.api.support_plugin import common_jwplayer as jwplayer
_url_re = re.compile("http(s)?://(\w+\.)?euronews.com")
class Euronews(Plugin):
@classmethod
def can_handle_url(self, url):
return _url_re.match(url)
def _create_stream(self, source):
url = source["file"]
if urlparse(url).path.endswith("m3u8"):
streams = HLSStream.parse_variant_playlist(self.session, url)
# TODO: Replace with "yield from" when dropping Python 2.
for stream in streams.items():
yield stream
else:
name = source.get("label", "vod")
yield name, HTTPStream(self.session, url)
def _get_streams(self):
res = http.get(self.url)
playlist = jwplayer.parse_playlist(res)
if not playlist:
return
for item in playlist:
streams = map(self._create_stream, item["sources"])
# TODO: Replace with "yield from" when dropping Python 2.
for stream in chain.from_iterable(streams):
yield stream
__plugin__ = Euronews
livestreamer-1.12.2/src/livestreamer/plugins/drdk.py 0000644 0001750 0001750 00000010172 12521217321 023642 0 ustar chrippa chrippa 0000000 0000000 """Plugin for Denmark's public service channel DR (Danmarks Radio)."""
import re
from livestreamer.plugin import Plugin
from livestreamer.plugin.api import http, validate
from livestreamer.stream import HLSStream, HDSStream
LIVE_CHANNELS_API_URL = "http://www.dr.dk/tv/external/channels?mediaType=tv"
VOD_API_URL = "http://www.dr.dk/mu/programcard/expanded/{0}"
STREAMING_TYPES = {
"HDS": HDSStream.parse_manifest,
"HLS": HLSStream.parse_variant_playlist
}
_url_re = re.compile(r"""
http(s)?://(www\.)?dr.dk
(?:
/[TtVv]+/
(?:
live/(?P<channel>[^/]+)
)?
(?:
se/(.+/)?(?P<program>[^/&?]+)
)?
)
""", re.VERBOSE)
_channels_schema = validate.Schema(
{
"Data": [{
"Slug": validate.text,
"StreamingServers": validate.all(
[{
"LinkType": validate.text,
"Qualities": [
validate.all(
{
"Streams": validate.all(
[
validate.all(
{"Stream": validate.text},
validate.get("Stream")
)
],
validate.get(0)
)
},
validate.get("Streams")
)
],
"Server": validate.text
}],
validate.filter(lambda s: s["LinkType"] in STREAMING_TYPES)
)
}]
},
validate.get("Data", {})
)
_video_schema = validate.Schema(
{ "Data": [{
"Assets": validate.all(
[{ validate.optional("Links"): validate.all(
[{
"Target": validate.text,
"Uri": validate.text
}],
validate.filter(lambda l: l["Target"] in STREAMING_TYPES)
)}],
validate.filter(lambda a: "Links" in a)
)
}]},
validate.get("Data", {}),
validate.get(0, {}),
validate.get("Assets", {}),
validate.get(0, {}),
validate.get("Links", []),
)
class DRDK(Plugin):
@classmethod
def can_handle_url(cls, url):
return _url_re.match(url)
def _get_streams(self):
match = _url_re.match(self.url)
if not match:
return
if match.group("channel"):
return self._get_live_streams(match.group("channel"))
else:
return self._get_vod_streams(match.group("program"))
def _get_vod_streams(self, program):
res = http.get(VOD_API_URL.format(program))
video = http.json(res, schema=_video_schema)
streams = {}
for link in video:
type = link["Target"]
url = link["Uri"]
parser = STREAMING_TYPES[type]
try:
streams.update(parser(self.session, url))
except IOError as err:
self.logger.error("Failed to load {0} streams: {1}", type, err)
return streams
def _get_live_streams(self, slug):
res = http.get(LIVE_CHANNELS_API_URL)
res = http.json(res, schema=_channels_schema)
for channel in filter(lambda c: c["Slug"] == slug, res):
servers = channel["StreamingServers"]
return self._parse_streaming_servers(servers)
def _parse_streaming_servers(self, servers):
streams = {}
for server in servers:
type = server["LinkType"]
base_url = server["Server"]
qualities = server["Qualities"]
parser = STREAMING_TYPES[type]
for quality in qualities:
try:
url = "{0}/{1}".format(base_url, quality)
streams.update(parser(self.session, url))
except IOError as err:
self.logger.error("Failed to load {0} streams: {1}", type, err)
return streams
__plugin__ = DRDK
livestreamer-1.12.2/src/livestreamer/plugins/douyutv.py 0000644 0001750 0001750 00000003636 12521217321 024444 0 ustar chrippa chrippa 0000000 0000000 import re
from livestreamer.plugin import Plugin
from livestreamer.plugin.api import http, validate
from livestreamer.stream import HTTPStream
API_URL = "http://www.douyutv.com/api/client/room/{0}"
SHOW_STATUS_ONLINE = 1
SHOW_STATUS_OFFLINE = 2
STREAM_WEIGHTS = {
"middle": 540,
"source": 1080
}
_url_re = re.compile("""
http(s)?://(www\.)?douyutv.com
/(?P<channel>[^/]+)
""", re.VERBOSE)
_room_schema = validate.Schema(
{
"data": validate.any(None, {
"show_status": validate.all(
validate.text,
validate.transform(int)
),
"rtmp_url": validate.text,
"rtmp_live": validate.text,
"rtmp_multi_bitrate": validate.all(
validate.any([], {
validate.text: validate.text
}),
validate.transform(dict)
)
})
},
validate.get("data")
)
class Douyutv(Plugin):
@classmethod
def can_handle_url(self, url):
return _url_re.match(url)
@classmethod
def stream_weight(cls, stream):
if stream in STREAM_WEIGHTS:
return STREAM_WEIGHTS[stream], "douyutv"
return Plugin.stream_weight(stream)
def _get_streams(self):
match = _url_re.match(self.url)
channel = match.group("channel")
res = http.get(API_URL.format(channel))
room = http.json(res, schema=_room_schema)
if not room:
return
if room["show_status"] != SHOW_STATUS_ONLINE:
return
url = "{room[rtmp_url]}/{room[rtmp_live]}".format(room=room)
stream = HTTPStream(self.session, url)
yield "source", stream
for name, url in room["rtmp_multi_bitrate"].items():
url = "{room[rtmp_url]}/{url}".format(room=room, url=url)
stream = HTTPStream(self.session, url)
yield name, stream
__plugin__ = Douyutv
livestreamer-1.12.2/src/livestreamer/plugins/dommune.py 0000644 0001750 0001750 00000001512 12521217321 024360 0 ustar chrippa chrippa 0000000 0000000 """Plugin for DOMMUNE, simply extracts current live YouTube stream."""
import re
from livestreamer.plugin import Plugin
from livestreamer.plugin.api import http, validate
DATA_URL = "http://www.dommune.com/freedommunezero2012/live/data/data.json"
_url_re = re.compile("http(s)?://(\w+\.)?dommune.com")
_data_schema = validate.Schema({
"channel": validate.text,
"channel2": validate.text
})
class Dommune(Plugin):
@classmethod
def can_handle_url(cls, url):
return _url_re.match(url)
def _get_streams(self):
res = http.get(DATA_URL)
data = http.json(res, schema=_data_schema)
video_id = data["channel"] or data["channel2"]
if not video_id:
return
url = "http://youtu.be/{0}".format(video_id)
return self.session.streams(url)
__plugin__ = Dommune
livestreamer-1.12.2/src/livestreamer/plugins/dmcloud_embed.py 0000644 0001750 0001750 00000001421 12521217321 025476 0 ustar chrippa chrippa 0000000 0000000 import re
from livestreamer.plugin import Plugin
from livestreamer.plugin.api import http
HEADERS = {
"User-Agent": ("Mozilla/5.0 (Windows NT 6.1; Win64; x64; rv:25.0) "
"Gecko/20100101 Firefox/25.0")
}
URLS = [
re.compile("http(s)?://(\w+\.)?action24.gr")
]
_embed_re = re.compile("http(s)?://api.dmcloud.net/player/embed/[\w\?=&\/;\-]+")
class DMCloudEmbed(Plugin):
@classmethod
def can_handle_url(self, url):
for site in URLS:
if site.match(url):
return True
def _get_streams(self):
res = http.get(self.url, headers=HEADERS)
match = _embed_re.search(res.text)
if match:
url = match.group(0)
return self.session.streams(url)
__plugin__ = DMCloudEmbed
livestreamer-1.12.2/src/livestreamer/plugins/dmcloud.py 0000644 0001750 0001750 00000004351 12521217321 024347 0 ustar chrippa chrippa 0000000 0000000 import re
from livestreamer.compat import urlparse
from livestreamer.plugin import Plugin
from livestreamer.plugin.api import http, validate
from livestreamer.stream import RTMPStream, HTTPStream, HLSStream
from livestreamer.utils import parse_json, rtmpparse, swfdecompress
_url_re = re.compile("http(s)?://api.dmcloud.net/player/embed/[^/]+/[^/]+")
_rtmp_re = re.compile(b"customURL[^h]+(https://.*?)\\\\")
_info_re = re.compile("var info = (.*);")
_schema = validate.Schema(
{
"mode": validate.text,
validate.optional("mp4_url"): validate.url(scheme="http"),
validate.optional("ios_url"): validate.url(scheme="http"),
validate.optional("swf_url"): validate.url(scheme="http"),
}
)
class DMCloud(Plugin):
@classmethod
def can_handle_url(self, url):
return _url_re.match(url)
def _get_rtmp_stream(self, swfurl):
res = http.get(swfurl)
swf = swfdecompress(res.content)
match = _rtmp_re.search(swf)
if not match:
return
res = http.get(match.group(1))
rtmp, playpath = rtmpparse(res.text)
params = {
"rtmp": rtmp,
"pageUrl": self.url,
"playpath": playpath,
"swfUrl": swfurl,
"live": True
}
return RTMPStream(self.session, params)
def _get_streams(self):
res = http.get(self.url)
match = _info_re.search(res.text)
if not match:
return
info = parse_json(match.group(1), schema=_schema)
stream_name = info["mode"]
mp4_url = info.get("mp4_url")
ios_url = info.get("ios_url")
swf_url = info.get("swf_url")
if mp4_url:
stream = HTTPStream(self.session, mp4_url)
yield stream_name, stream
if ios_url:
if urlparse(ios_url).path.endswith(".m3u8"):
streams = HLSStream.parse_variant_playlist(self.session, ios_url)
# TODO: Replace with "yield from" when dropping Python 2.
for stream in streams.items():
yield stream
if swf_url:
stream = self._get_rtmp_stream(swf_url)
if stream:
yield stream_name, stream
__plugin__ = DMCloud
livestreamer-1.12.2/src/livestreamer/plugins/disney_de.py 0000644 0001750 0001750 00000002065 12521217321 024663 0 ustar chrippa chrippa 0000000 0000000 """Plugin for Disney (Channel) Germany
Supports:
- http://video.disney.de/sehen/*
- http://disneychannel.de/sehen/*
- http://disneychannel.de/livestream
"""
import re
from livestreamer.plugin import Plugin
from livestreamer.plugin.api import http
from livestreamer.plugin.api.utils import parse_json
from livestreamer.stream import HLSStream
_url_re = re.compile("http(s)?://(\w+\.)?disney(channel)?.de/")
# stream urls are in `Grill.burger`->stack->data->externals->data
_stream_hls_re = re.compile("\"hlsStreamUrl\":\s*(\"[^\"]+\")")
_stream_data_re = re.compile("\"dataUrl\":\s*(\"[^\"]+\")")
class DisneyDE(Plugin):
@classmethod
def can_handle_url(cls, url):
return _url_re.match(url)
def _get_streams(self):
res = http.get(self.url)
match = (_stream_hls_re.search(res.text) or
_stream_data_re.search(res.text))
if not match:
return
stream_url = parse_json(match.group(1))
return HLSStream.parse_variant_playlist(self.session, stream_url)
__plugin__ = DisneyDE
livestreamer-1.12.2/src/livestreamer/plugins/dailymotion.py 0000644 0001750 0001750 00000013615 12521217321 025253 0 ustar chrippa chrippa 0000000 0000000 import re
from functools import reduce
from livestreamer.compat import urlparse, range
from livestreamer.plugin import Plugin
from livestreamer.plugin.api import http, validate
from livestreamer.stream import HDSStream, HTTPStream, RTMPStream
from livestreamer.stream.playlist import FLVPlaylist
COOKIES = {
"family_filter": "off",
"ff": "off"
}
QUALITY_MAP = {
"ld": "240p",
"sd": "360p",
"hq": "480p",
"hd720": "720p",
"hd1080": "1080p",
"custom": "live",
"auto": "hds",
"source": "hds"
}
STREAM_INFO_URL = "http://www.dailymotion.com/sequence/full/{0}"
_rtmp_re = re.compile("""
(?P<host>rtmp://[^/]+)
/(?P<app>[^/]+)
/(?P<playpath>.+)
""", re.VERBOSE)
_url_re = re.compile("""
http(s)?://(\w+\.)?
dailymotion.com
(/embed)?/(video|live)
/(?P<media_id>[^_?/]+)
""", re.VERBOSE)
_media_inner_schema = validate.Schema([{
"layerList": [{
"name": validate.text,
validate.optional("sequenceList"): [{
"layerList": validate.all(
[{
"name": validate.text,
validate.optional("param"): dict
}],
validate.filter(lambda l: l["name"] in ("video", "reporting"))
)
}]
}]
}])
_media_schema = validate.Schema(
validate.any(
_media_inner_schema,
validate.all(
{"sequence": _media_inner_schema},
validate.get("sequence")
)
)
)
_vod_playlist_schema = validate.Schema({
"duration": float,
"fragments": [[int, float]],
"template": validate.text
})
_vod_manifest_schema = validate.Schema({
"alternates": [{
"height": int,
"template": validate.text,
validate.optional("failover"): [validate.text]
}]
})
class DailyMotion(Plugin):
@classmethod
def can_handle_url(self, url):
return _url_re.match(url)
def _get_streams_from_media(self, media_id):
res = http.get(STREAM_INFO_URL.format(media_id), cookies=COOKIES)
media = http.json(res, schema=_media_schema)
params = extra_params = swf_url = None
for __ in media:
for __ in __["layerList"]:
for __ in __.get("sequenceList", []):
for layer in __["layerList"]:
name = layer["name"]
if name == "video":
params = layer.get("param")
elif name == "reporting":
extra_params = layer.get("param", {})
extra_params = extra_params.get("extraParams", {})
if not params:
return
if extra_params:
swf_url = extra_params.get("videoSwfURL")
mode = params.get("mode")
if mode == "live":
return self._get_live_streams(params, swf_url)
elif mode == "vod":
return self._get_vod_streams(params)
def _get_live_streams(self, params, swf_url):
for key, quality in QUALITY_MAP.items():
key_url = "{0}URL".format(key)
url = params.get(key_url)
if not url:
continue
try:
res = http.get(url, exception=IOError)
except IOError:
continue
if quality == "hds":
streams = HDSStream.parse_manifest(self.session, res.url)
for name, stream in streams.items():
if key == "source":
name += "+"
yield name, stream
elif res.text.startswith("rtmp"):
match = _rtmp_re.match(res.text)
if not match:
continue
stream = RTMPStream(self.session, {
"rtmp": match.group("host"),
"app": match.group("app"),
"playpath": match.group("playpath"),
"swfVfy": swf_url,
"live": True
})
yield quality, stream
def _create_flv_playlist(self, template):
res = http.get(template)
playlist = http.json(res, schema=_vod_playlist_schema)
parsed = urlparse(template)
url_template = "{0}://{1}{2}".format(
parsed.scheme, parsed.netloc, playlist["template"]
)
segment_max = reduce(lambda i,j: i + j[0], playlist["fragments"], 0)
substreams = [HTTPStream(self.session,
url_template.replace("$fragment$", str(i)))
for i in range(1, segment_max + 1)]
return FLVPlaylist(self.session,
duration=playlist["duration"],
flatten_timestamps=True,
skip_header=True,
streams=substreams)
def _get_vod_streams(self, params):
manifest_url = params.get("autoURL")
if not manifest_url:
return
res = http.get(manifest_url)
if res.headers.get("Content-Type") == "application/f4m+xml":
streams = HDSStream.parse_manifest(self.session, res.url)
# TODO: Replace with "yield from" when dropping Python 2.
for __ in streams.items():
yield __
else:
manifest = http.json(res, schema=_vod_manifest_schema)
for params in manifest["alternates"]:
name = "{0}p".format(params["height"])
stream = self._create_flv_playlist(params["template"])
yield name, stream
failovers = params.get("failover", [])
for failover in failovers:
stream = self._create_flv_playlist(failover)
yield name, stream
def _get_streams(self):
match = _url_re.match(self.url)
media_id = match.group("media_id")
return self._get_streams_from_media(media_id)
__plugin__ = DailyMotion
livestreamer-1.12.2/src/livestreamer/plugins/cybergame.py 0000644 0001750 0001750 00000004335 12521217321 024660 0 ustar chrippa chrippa 0000000 0000000 import re
from livestreamer.compat import urlparse
from livestreamer.plugin import Plugin
from livestreamer.plugin.api import http, validate
from livestreamer.stream import RTMPStream
PLAYLIST_URL = "http://api.cybergame.tv/p/playlist.smil"
_url_re = re.compile("""
http(s)?://(\w+\.)?cybergame.tv
(?:
/videos/(?P<video_id>\d+)
)?
(?:
/(?P<channel>[^/&?]+)
)?
""", re.VERBOSE)
_playlist_schema = validate.Schema(
validate.union({
"base": validate.all(
validate.xml_find("./head/meta"),
validate.get("base"),
validate.url(scheme="rtmp")
),
"videos": validate.all(
validate.xml_findall(".//video"),
[
validate.union({
"src": validate.all(
validate.get("src"),
validate.text
),
"height": validate.all(
validate.get("height"),
validate.text,
validate.transform(int)
)
})
]
)
})
)
class Cybergame(Plugin):
@classmethod
def can_handle_url(self, url):
return _url_re.match(url)
def _get_playlist(self, **params):
res = http.get(PLAYLIST_URL, params=params)
playlist = http.xml(res, schema=_playlist_schema)
streams = {}
for video in playlist["videos"]:
name = "{0}p".format(video["height"])
stream = RTMPStream(self.session, {
"rtmp": "{0}/{1}".format(playlist["base"], video["src"]),
"app": urlparse(playlist["base"]).path[1:],
"pageUrl": self.url,
"rtmp": playlist["base"],
"playpath": video["src"],
"live": True
})
streams[name] = stream
return streams
def _get_streams(self):
match = _url_re.match(self.url)
video_id = match.group("video_id")
channel = match.group("channel")
if video_id:
return self._get_playlist(vod=video_id)
elif channel:
return self._get_playlist(channel=channel)
__plugin__ = Cybergame
livestreamer-1.12.2/src/livestreamer/plugins/crunchyroll.py 0000644 0001750 0001750 00000022325 12521217321 025265 0 ustar chrippa chrippa 0000000 0000000 import random
import re
import string
import datetime
from livestreamer.plugin import Plugin, PluginError, PluginOptions
from livestreamer.plugin.api import http, validate
from livestreamer.stream import HLSStream
API_URL = "https://api.crunchyroll.com/{0}.0.json"
API_HEADERS = {
"User-Agent": "Mozilla/5.0 (iPhone; iPhone OS 8.3.0; en_US)",
"Host": "api.crunchyroll.com",
"Accept-Encoding": "gzip, deflate",
"Accept": "*/*",
"Content-Type": "application/x-www-form-urlencoded"
}
API_VERSION = "2313.8"
API_LOCALE = "enUS"
API_ACCESS_TOKEN = "QWjz212GspMHH9h"
API_DEVICE_TYPE = "com.crunchyroll.iphone"
STREAM_WEIGHTS = {
"low": 240,
"mid": 420,
"high": 720,
"ultra": 1080,
}
def parse_timestamp(ts):
"""Takes ISO 8601 format(string) and converts into a utc datetime(naive)"""
return (
datetime.datetime.strptime(ts[:-7], "%Y-%m-%dT%H:%M:%S") +
datetime.timedelta(hours=int(ts[-5:-3]), minutes=int(ts[-2:])) *
int(ts[-6:-5] + "1")
)
_url_re = re.compile("""
http(s)?://(\w+\.)?crunchyroll\.
(?:
com|de|es|fr|co.jp
)
/[^/&?]+
/[^/&?]+-(?P<media_id>\d+)
""", re.VERBOSE)
_api_schema = validate.Schema({
"error": bool,
validate.optional("code"): validate.text,
validate.optional("message"): validate.text,
validate.optional("data"): object,
})
_media_schema = validate.Schema(
{
"stream_data": validate.any(
None,
{
"streams": validate.all(
[{
"quality": validate.text,
"url": validate.url(
scheme="http",
path=validate.endswith(".m3u8")
)
}],
validate.filter(lambda s: s["quality"] != "adaptive")
)
}
)
},
validate.get("stream_data")
)
_login_schema = validate.Schema({
"auth": validate.text,
"expires": validate.all(
validate.text,
validate.transform(parse_timestamp)
),
"user": {
"username": validate.text
}
})
_session_schema = validate.Schema(
{
"session_id": validate.text
},
validate.get("session_id")
)
class CrunchyrollAPIError(Exception):
"""Exception thrown by the Crunchyroll API when an error occurs"""
def __init__(self, msg, code):
Exception.__init__(self, msg)
self.msg = msg
self.code = code
class CrunchyrollAPI(object):
def __init__(self, session_id=None, auth=None):
"""Abstract the API to access to Crunchyroll data.
Can take saved credentials to use on it's calls to the API.
"""
self.session_id = session_id
self.auth = auth
def _api_call(self, entrypoint, params, schema=None):
"""Makes a call against the api.
:param entrypoint: API method to call.
:param params: parameters to include in the request data.
:param schema: schema to use to validate the data
"""
url = API_URL.format(entrypoint)
# Default params
params = dict(params)
params.update({
"version": API_VERSION,
"locale": API_LOCALE,
})
if self.session_id:
params["session_id"] = self.session_id
# The certificate used by Crunchyroll cannot be verified in some environments.
res = http.get(url, params=params, headers=API_HEADERS, verify=False)
json_res = http.json(res, schema=_api_schema)
if json_res["error"]:
err_msg = json_res.get("message", "Unknown error")
err_code = json_res.get("code", "unknown_error")
raise CrunchyrollAPIError(err_msg, err_code)
data = json_res.get("data")
if schema:
data = schema.validate(data, name="API response")
return data
def start_session(self, device_id, **kwargs):
"""Starts a session against Crunchyroll's server.
Is recommended that you call this method before making any other calls
to make sure you have a valid session against the server.
"""
params = {
"device_id": device_id,
"device_type": API_DEVICE_TYPE,
"access_token": API_ACCESS_TOKEN,
}
if self.auth:
params["auth"] = self.auth
return self._api_call("start_session", params, **kwargs)
def login(self, username, password, **kwargs):
"""Authenticates the session to be able to access restricted data from
the server (e.g. premium restricted videos).
"""
params = {
"account": username,
"password": password
}
return self._api_call("login", params, **kwargs)
def get_info(self, media_id, fields=None, **kwargs):
"""Returns the data for a certain media item.
:param media_id: id that identifies the media item to be accessed.
:param fields: list of the media"s field to be returned. By default the
API returns some fields, but others are not returned unless they are
explicity asked for. I have no real documentation on the fields, but
they all seem to start with the "media." prefix (e.g. media.name,
media.stream_data).
"""
params = {
"media_id": media_id
}
if fields:
params["fields"] = ",".join(fields)
return self._api_call("info", params, **kwargs)
class Crunchyroll(Plugin):
options = PluginOptions({
"username": None,
"password": None,
"purge_credentials": None,
})
@classmethod
def can_handle_url(self, url):
return _url_re.match(url)
@classmethod
def stream_weight(cls, key):
weight = STREAM_WEIGHTS.get(key)
if weight:
return weight, "crunchyroll"
return Plugin.stream_weight(key)
def _get_streams(self):
api = self._create_api()
match = _url_re.match(self.url)
media_id = int(match.group("media_id"))
try:
info = api.get_info(media_id, fields=["media.stream_data"],
schema=_media_schema)
except CrunchyrollAPIError as err:
raise PluginError(u"Media lookup error: {0}".format(err.msg))
if not info:
return
# TODO: Use dict comprehension here after dropping Python 2.6 support.
return dict(
(stream["quality"], HLSStream(self.session, stream["url"]))
for stream in info["streams"]
)
def _get_device_id(self):
"""Returns the saved device id or creates a new one and saves it."""
device_id = self.cache.get("device_id")
if not device_id:
# Create a random device id and cache it for a year
char_set = string.ascii_letters + string.digits
device_id = "".join(random.sample(char_set, 32))
self.cache.set("device_id", device_id, 365 * 24 * 60 * 60)
return device_id
def _create_api(self):
"""Creates a new CrunchyrollAPI object, initiates it's session and
tries to authenticate it either by using saved credentials or the
user's username and password.
"""
if self.options.get("purge_credentials"):
self.cache.set("session_id", None, 0)
self.cache.set("auth", None, 0)
current_time = datetime.datetime.utcnow()
device_id = self._get_device_id()
api = CrunchyrollAPI(
self.cache.get("session_id"), self.cache.get("auth")
)
self.logger.debug("Creating session")
try:
api.session_id = api.start_session(device_id, schema=_session_schema)
except CrunchyrollAPIError as err:
if err.code == "bad_session":
self.logger.debug("Current session has expired, creating a new one")
api = CrunchyrollAPI()
api.session_id = api.start_session(device_id, schema=_session_schema)
else:
raise err
# Save session and hope it lasts for a few hours
self.cache.set("session_id", api.session_id, 4 * 60 * 60)
self.logger.debug("Session created")
if api.auth:
self.logger.debug("Using saved credentials")
elif self.options.get("username"):
try:
self.logger.info("Attempting to login using username and password")
login = api.login(
self.options.get("username"),
self.options.get("password"),
schema=_login_schema
)
api.auth = login["auth"]
self.logger.info("Successfully logged in as '{0}'",
login["user"]["username"])
expires = (login["expires"] - current_time).total_seconds()
self.cache.set("auth", login["auth"], expires)
except CrunchyrollAPIError as err:
raise PluginError(u"Authentication error: {0}".format(err.msg))
else:
self.logger.warning(
"No authentication provided, you won't be able to access "
"premium restricted content"
)
return api
__plugin__ = Crunchyroll
livestreamer-1.12.2/src/livestreamer/plugins/connectcast.py 0000644 0001750 0001750 00000001425 12521217321 025223 0 ustar chrippa chrippa 0000000 0000000 import re
import json
from livestreamer.plugin import Plugin
from livestreamer.plugin.api import http, validate
from livestreamer.stream import HDSStream
SWF_URL = "https://www.connectcast.tv/jwplayer/jwplayer.flash.swf"
_url_re = re.compile("http(s)?://(\w+\.)?connectcast.tv/")
_manifest_re = re.compile(".*data-playback=\"([^\"]*)\".*")
class ConnectCast(Plugin):
@classmethod
def can_handle_url(self, url):
return _url_re.match(url)
def _get_streams(self):
res = http.get(self.url)
match = _manifest_re.search(res.text)
manifest = match.group(1)
streams = {}
streams.update(
HDSStream.parse_manifest(self.session, manifest, pvswf=SWF_URL)
)
return streams
__plugin__ = ConnectCast
livestreamer-1.12.2/src/livestreamer/plugins/common_swf.py 0000644 0001750 0001750 00000002157 12521217321 025071 0 ustar chrippa chrippa 0000000 0000000 from collections import namedtuple
from io import BytesIO
from livestreamer.utils import swfdecompress
from livestreamer.packages.flashmedia.types import U16LE, U32LE
__all__ = ["parse_swf"]
Rect = namedtuple("Rect", "data")
Tag = namedtuple("Tag", "type data")
SWF = namedtuple("SWF", "frame_size frame_rate frame_count tags")
def read_rect(fd):
header = ord(fd.read(1))
nbits = header >> 3
nbytes = int(((5 + 4 * nbits) + 7) / 8)
data = fd.read(nbytes - 1)
return Rect(data)
def read_tag(fd):
header = U16LE.read(fd)
tag_type = header >> 6
tag_length = header & 0x3f
if tag_length == 0x3f:
tag_length = U32LE.read(fd)
tag_data = fd.read(tag_length)
return Tag(tag_type, tag_data)
def read_tags(fd):
while True:
try:
yield read_tag(fd)
except IOError:
break
def parse_swf(data):
data = swfdecompress(data)
fd = BytesIO(data[8:])
frame_size = read_rect(fd)
frame_rate = U16LE.read(fd)
frame_count = U16LE.read(fd)
tags = list(read_tags(fd))
return SWF(frame_size, frame_rate, frame_count, tags)
livestreamer-1.12.2/src/livestreamer/plugins/common_jwplayer.py 0000644 0001750 0001750 00000001616 12521217321 026126 0 ustar chrippa chrippa 0000000 0000000 import re
from functools import partial
from livestreamer.plugin.api import validate
from livestreamer.plugin.api.utils import parse_json
__all__ = ["parse_playlist"]
_playlist_re = re.compile("\(?\{.*playlist: (\[.*\]),.*?\}\)?;", re.DOTALL)
_js_to_json = partial(re.compile("(\w+):\s").sub, r'"\1":')
_playlist_schema = validate.Schema(
validate.transform(_playlist_re.search),
validate.any(
None,
validate.all(
validate.get(1),
validate.transform(_js_to_json),
validate.transform(parse_json),
[{
"sources": [{
"file": validate.text,
validate.optional("label"): validate.text
}]
}]
)
)
)
def parse_playlist(res):
"""Attempts to parse a JWPlayer playlist in a HTTP response body."""
return _playlist_schema.validate(res.text)
livestreamer-1.12.2/src/livestreamer/plugins/chaturbate.py 0000644 0001750 0001750 00000001640 12521217321 025040 0 ustar chrippa chrippa 0000000 0000000 import re
from livestreamer.plugin import Plugin
from livestreamer.plugin.api import http, validate
from livestreamer.stream import HLSStream
_url_re = re.compile("http(s)?://(\w+.)?chaturbate.com/[^/?&]+")
_playlist_url_re = re.compile("html \+= \"src='(?P<url>[^']+)'\";")
_schema = validate.Schema(
validate.transform(_playlist_url_re.search),
validate.any(
None,
validate.all(
validate.get("url"),
validate.url(
scheme="http",
path=validate.endswith(".m3u8")
)
)
)
)
class Chaturbate(Plugin):
@classmethod
def can_handle_url(self, url):
return _url_re.match(url)
def _get_streams(self):
playlist_url = http.get(self.url, schema=_schema)
if not playlist_url:
return
return HLSStream.parse_variant_playlist(self.session, playlist_url)
__plugin__ = Chaturbate
livestreamer-1.12.2/src/livestreamer/plugins/beattv.py 0000644 0001750 0001750 00000024136 12521217321 024210 0 ustar chrippa chrippa 0000000 0000000 import re
from collections import namedtuple
from io import BytesIO
try:
from Crypto.Cipher import AES
CAN_DECRYPT = True
except ImportError:
CAN_DECRYPT = False
from livestreamer.compat import range
from livestreamer.exceptions import StreamError
from livestreamer.packages.flashmedia.tag import (
AACAudioData, AudioData, AVCVideoData, RawData, Tag, VideoData
)
from livestreamer.packages.flashmedia.tag import (
AAC_PACKET_TYPE_RAW, AAC_PACKET_TYPE_SEQUENCE_HEADER,
AUDIO_BIT_RATE_16, AUDIO_CODEC_ID_AAC, AUDIO_RATE_44_KHZ, AUDIO_TYPE_STEREO,
AVC_PACKET_TYPE_NALU, AVC_PACKET_TYPE_SEQUENCE_HEADER,
TAG_TYPE_AUDIO, TAG_TYPE_VIDEO, VIDEO_CODEC_ID_AVC,
VIDEO_FRAME_TYPE_INTER_FRAME, VIDEO_FRAME_TYPE_KEY_FRAME
)
from livestreamer.packages.flashmedia.types import U8, U16BE, U32BE
from livestreamer.plugin import Plugin
from livestreamer.plugin.api import http, validate
from livestreamer.stream import Stream, StreamIOIterWrapper
from livestreamer.stream.flvconcat import FLVTagConcat
from livestreamer.stream.segmented import (
SegmentedStreamReader, SegmentedStreamWriter, SegmentedStreamWorker
)
HEADERS = {"User-Agent": "Mozilla/5.0"}
BEAT_PROGRAM = "http://www.be-at.tv/{0}.program"
BEAT_URL = "http://www.be-at.tv/{0}/{1}/{2}.{3}"
QUALITY_MAP = {
"audio_mono": 0,
"audio_stereo": 1,
"mobile_low": 5,
"mobile_medium": 6,
"web_medium": 10,
"web_high": 11,
"web_hd": 12
}
_url_re = re.compile("http(s)?://(\w+\.)?be-at.tv/")
_schema = validate.Schema(
validate.any(
None,
{
"status": int,
"media": [{
"duration": validate.any(float, int),
"offset": validate.any(float, int),
"id": int,
"parts": [{
"duration": validate.any(float, int),
"id": int,
"offset": validate.any(float, int),
validate.optional("recording"): int,
validate.optional("start"): validate.any(float, int)
}]
}]
}
)
)
Chunk = namedtuple("Chunk", "recording quality sequence extension")
class BeatFLVTagConcat(FLVTagConcat):
def __init__(self, *args, **kwargs):
FLVTagConcat.__init__(self, *args, **kwargs)
def decrypt_data(self, key, iv, data):
decryptor = AES.new(key, AES.MODE_CBC, iv)
return decryptor.decrypt(data)
def iter_tags(self, fd=None, buf=None, skip_header=None):
flags = U8.read(fd)
quality = flags & 15
version = flags >> 4
lookup_size = U16BE.read(fd)
enc_table = fd.read(lookup_size)
key = b""
iv = b""
for i in range(16):
key += fd.read(1)
iv += fd.read(1)
if not (key and iv):
return
dec_table = self.decrypt_data(key, iv, enc_table)
dstream = BytesIO(dec_table)
# Decode lookup table (ported from K-S-V BeatConvert.php)
while True:
flags = U8.read(dstream)
if not flags:
break
typ = flags >> 4
encrypted = (flags & 4) > 0
keyframe = (flags & 2) > 0
config = (flags & 1) > 0
time = U32BE.read(dstream)
data_length = U32BE.read(dstream)
if encrypted:
raw_length = U32BE.read(dstream)
else:
raw_length = data_length
# Decrypt encrypted tags
data = fd.read(data_length)
if encrypted:
data = self.decrypt_data(key, iv, data)
data = data[:raw_length]
# Create video tag
if typ == 1:
if version == 2:
if config:
avc = AVCVideoData(AVC_PACKET_TYPE_SEQUENCE_HEADER,
data=data)
else:
avc = AVCVideoData(AVC_PACKET_TYPE_NALU, data=data)
if keyframe:
videodata = VideoData(VIDEO_FRAME_TYPE_KEY_FRAME,
VIDEO_CODEC_ID_AVC, avc)
else:
videodata = VideoData(VIDEO_FRAME_TYPE_INTER_FRAME,
VIDEO_CODEC_ID_AVC, avc)
else:
videodata = RawData(data)
yield Tag(TAG_TYPE_VIDEO, time, videodata)
# Create audio tag
if typ == 2:
if version == 2:
if config:
aac = AACAudioData(AAC_PACKET_TYPE_SEQUENCE_HEADER,
data)
else:
aac = AACAudioData(AAC_PACKET_TYPE_RAW, data)
audiodata = AudioData(codec=AUDIO_CODEC_ID_AAC,
rate=AUDIO_RATE_44_KHZ,
bits=AUDIO_BIT_RATE_16,
type=AUDIO_TYPE_STEREO,
data=aac)
else:
audiodata = RawData(data)
yield Tag(TAG_TYPE_AUDIO, time, audiodata)
class BeatStreamWriter(SegmentedStreamWriter):
def __init__(self, *args, **kwargs):
SegmentedStreamWriter.__init__(self, *args, **kwargs)
self.concater = BeatFLVTagConcat(flatten_timestamps=True)
def fetch(self, chunk, retries=None):
if self.closed or not retries:
return
try:
url = BEAT_URL.format(chunk.recording,
chunk.quality,
chunk.sequence,
chunk.extension)
return self.session.http.get(url,
headers=HEADERS,
timeout=self.timeout,
exception=StreamError)
except StreamError as err:
self.logger.error(
"Failed to open chunk {0}/{1}/{2}: {3}",
chunk.recording, chunk.quality, chunk.sequence, err
)
return self.fetch(chunk, retries - 1)
def write(self, chunk, res, chunk_size=8192):
try:
fd = StreamIOIterWrapper(res.iter_content(chunk_size))
for data in self.concater.iter_chunks(fd=fd, skip_header=True):
self.reader.buffer.write(data)
if self.closed:
return
self.logger.debug("Download of chunk {0}/{1}/{2} complete",
chunk.recording,
chunk.quality,
chunk.sequence)
except IOError as err:
self.logger.error("Failed to read chunk {0}/{1}/{2}: {3}",
chunk.recording,
chunk.quality,
chunk.sequence, err)
class BeatStreamWorker(SegmentedStreamWorker):
def __init__(self, *args, **kwargs):
SegmentedStreamWorker.__init__(self, *args, **kwargs)
def iter_segments(self):
quality = QUALITY_MAP[self.stream.quality]
for part in self.stream.parts:
duration = part["duration"]
if not part.get("recording"):
recording = part["id"]
extension = "part"
else:
recording = part["recording"]
extension = "rec"
chunks = int(duration / 12) + 1
start = int(part.get("start", 0) / 12)
for sequence in range(start, chunks + start):
if self.closed:
return
self.logger.debug("Adding chunk {0}/{1}/{2} to queue",
recording, quality, sequence)
yield Chunk(recording, quality, sequence, extension)
class BeatStreamReader(SegmentedStreamReader):
__worker__ = BeatStreamWorker
__writer__ = BeatStreamWriter
def __init__(self, stream, *args, **kwargs):
self.logger = stream.session.logger.new_module("stream.beat")
SegmentedStreamReader.__init__(self, stream, *args, **kwargs)
class BeatStream(Stream):
__shortname__ = "beat"
def __init__(self, session, parts, quality):
Stream.__init__(self, session)
self.parts = parts
self.quality = quality
def __repr__(self):
return ("<BeatStream({0!r}, {1!r}>").format(len(self.parts),
self.quality)
def __json__(self):
return dict(parts=self.parts, quality=self.quality,
**Stream.__json__(self))
def open(self):
if not CAN_DECRYPT:
raise StreamError(
"pyCrypto needs to be installed to decrypt this stream"
)
reader = BeatStreamReader(self)
reader.open()
return reader
class BeatTV(Plugin):
@classmethod
def can_handle_url(self, url):
return _url_re.match(url)
@classmethod
def stream_weight(cls, key):
weight = QUALITY_MAP.get(key)
if weight:
return weight, "beat"
return Plugin.stream_weight(key)
def _get_stream_info(self, url):
res = http.get(url, headers=HEADERS)
match = re.search("embed.swf\?p=(\d+)", res.text)
if not match:
return
program = match.group(1)
res = http.get(BEAT_PROGRAM.format(program), headers=HEADERS)
return http.json(res, schema=_schema)
def _get_streams(self):
info = self._get_stream_info(self.url)
if not info or info["status"] == 0:
return
parts = []
for media in info["media"]:
if not media["id"]:
continue
for part in media["parts"]:
if not part["duration"]:
continue
parts.append(part)
if not parts:
return
streams = {}
for quality in QUALITY_MAP:
streams[quality] = BeatStream(self.session, parts, quality)
return streams
__plugin__ = BeatTV
livestreamer-1.12.2/src/livestreamer/plugins/bambuser.py 0000644 0001750 0001750 00000003631 12521217321 024520 0 ustar chrippa chrippa 0000000 0000000 import re
from random import random
from livestreamer.plugin import Plugin, PluginError
from livestreamer.plugin.api import http, validate
from livestreamer.stream import HTTPStream, RTMPStream
API_CLIENT_NAME = "Bambuser AS2"
API_CONTEXT = "b_broadcastpage"
API_KEY = "005f64509e19a868399060af746a00aa"
API_URL_VIDEO = "http://player-c.api.bambuser.com/getVideo.json"
_url_re = re.compile("http(s)?://(\w+.)?bambuser.com/v/(?P<video_id>\d+)")
_video_schema = validate.Schema({
validate.optional("error"): validate.text,
validate.optional("result"): {
"id": validate.text,
"size": validate.text,
"url": validate.url(
scheme=validate.any("rtmp", "http")
)
}
})
class Bambuser(Plugin):
@classmethod
def can_handle_url(self, url):
return _url_re.match(url)
def _get_streams(self):
match = _url_re.match(self.url)
video_id = match.group("video_id")
params = {
"client_name": API_CLIENT_NAME,
"context": API_CONTEXT,
"raw_user_input": 1,
"api_key": API_KEY,
"vid": video_id,
"r": random()
}
res = http.get(API_URL_VIDEO, params=params)
video = http.json(res, schema=_video_schema)
error = video.get("error")
if error:
raise PluginError(error)
result = video.get("result")
if not result:
return
url = result["url"]
if url.startswith("http"):
stream = HTTPStream(self.session, url)
elif url.startswith("rtmp"):
stream = RTMPStream(self.session, {
"rtmp": url,
"playpath": result["id"],
"pageUrl": self.url,
"live": True
})
width, height = result["size"].split("x")
name = "{0}p".format(height)
return {name: stream}
__plugin__ = Bambuser
livestreamer-1.12.2/src/livestreamer/plugins/azubutv.py 0000644 0001750 0001750 00000015432 12521217321 024422 0 ustar chrippa chrippa 0000000 0000000 import re
from io import BytesIO
from time import sleep
from livestreamer.exceptions import PluginError
from livestreamer.packages.flashmedia import AMFPacket, AMFMessage
from livestreamer.packages.flashmedia.types import AMF3ObjectBase
from livestreamer.plugin import Plugin
from livestreamer.plugin.api import http, validate
from livestreamer.stream import AkamaiHDStream
AMF_GATEWAY = "http://c.brightcove.com/services/messagebroker/amf"
AMF_MESSAGE_PREFIX = "af6b88c640c8d7b4cc75d22f7082ad95603bc627"
STREAM_NAMES = ["360p", "480p", "720p", "source"]
HTTP_HEADERS = {
"User-Agent": ("Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 "
"(KHTML, like Gecko) Chrome/36.0.1944.9 Safari/537.36")
}
_url_re = re.compile("http(s)?://(\w+\.)?azubu.tv/[^/]+")
_viewerexp_schema = validate.Schema(
validate.attr({
"programmedContent": {
"videoPlayer": validate.attr({
"mediaDTO": validate.attr({
"renditions": {
int: validate.attr({
"encodingRate": int,
"defaultURL": validate.text
})
}
})
})
}
})
)
@AMF3ObjectBase.register("com.brightcove.experience.ViewerExperienceRequest")
class ViewerExperienceRequest(AMF3ObjectBase):
__members__ = ["contentOverrides",
"experienceId",
"URL",
"playerKey",
"deliveryType",
"TTLToken"]
def __init__(self, URL, contentOverrides, experienceId, playerKey, TTLToken=""):
self.URL = URL
self.deliveryType = float("nan")
self.contentOverrides = contentOverrides
self.experienceId = experienceId
self.playerKey = playerKey
self.TTLToken = TTLToken
@AMF3ObjectBase.register("com.brightcove.experience.ContentOverride")
class ContentOverride(AMF3ObjectBase):
__members__ = ["featuredRefId",
"contentRefIds",
"contentId",
"contentType",
"contentIds",
"featuredId",
"contentRefId",
"target"]
def __init__(self, contentId=float("nan"), contentRefId=None, contentType=0,
target="videoPlayer"):
self.contentType = contentType
self.contentId = contentId
self.target = target
self.contentIds = None
self.contentRefId = contentRefId
self.contentRefIds = None
self.contentType = 0
self.featuredId = float("nan")
self.featuredRefId = None
class AzubuTV(Plugin):
@classmethod
def can_handle_url(cls, url):
return _url_re.match(url)
@classmethod
def stream_weight(cls, stream):
if stream == "source":
weight = 1080
else:
weight, group = Plugin.stream_weight(stream)
return weight, "azubutv"
def _create_amf_request(self, key, video_player, player_id):
if video_player.startswith("ref:"):
content_override = ContentOverride(contentRefId=video_player[4:])
else:
content_override = ContentOverride(contentId=int(video_player))
viewer_exp_req = ViewerExperienceRequest(self.url,
[content_override],
int(player_id), key)
req = AMFPacket(version=3)
req.messages.append(AMFMessage(
"com.brightcove.experience.ExperienceRuntimeFacade.getDataForExperience",
"/1",
[AMF_MESSAGE_PREFIX, viewer_exp_req]
))
return req
def _send_amf_request(self, req, key):
headers = {
"content-type": "application/x-amf"
}
res = http.post(AMF_GATEWAY, data=bytes(req.serialize()),
headers=headers, params=dict(playerKey=key))
return AMFPacket.deserialize(BytesIO(res.content))
def _get_player_params(self, retries=5):
try:
res = http.get(self.url, headers=HTTP_HEADERS)
except PluginError as err:
# The server sometimes gives us 404 for no reason
if "404" in str(err) and retries:
sleep(1)
return self._get_player_params(retries - 1)
else:
raise
match = re.search("<param name=\"playerKey\" value=\"(.+)\" />", res.text)
if not match:
# The HTML returned sometimes doesn't contain the parameters
if not retries:
raise PluginError("Missing key 'playerKey' in player params")
else:
sleep(1)
return self._get_player_params(retries - 1)
key = match.group(1)
match = re.search("AZUBU.setVar\(\"firstVideoRefId\", \"(.+)\"\);", res.text)
if not match:
# The HTML returned sometimes doesn't contain the parameters
if not retries:
raise PluginError("Unable to find video reference")
else:
sleep(1)
return self._get_player_params(retries - 1)
video_player = "ref:" + match.group(1)
match = re.search("<param name=\"playerID\" value=\"(\d+)\" />", res.text)
if not match:
# The HTML returned sometimes doesn't contain the parameters
if not retries:
raise PluginError("Missing key 'playerID' in player params")
else:
sleep(1)
return self._get_player_params(retries - 1)
player_id = match.group(1)
match = re.search("<!-- live on -->", res.text)
if not match:
match = re.search("<div id=\"channel_live\">", res.text)
is_live = not not match
return key, video_player, player_id, is_live
def _parse_result(self, res):
res = _viewerexp_schema.validate(res)
player = res.programmedContent["videoPlayer"]
renditions = sorted(player.mediaDTO.renditions.values(),
key=lambda r: r.encodingRate or 100000000)
streams = {}
for stream_name, rendition in zip(STREAM_NAMES, renditions):
stream = AkamaiHDStream(self.session, rendition.defaultURL)
streams[stream_name] = stream
return streams
def _get_streams(self):
key, video_player, player_id, is_live = self._get_player_params()
if not is_live:
return
req = self._create_amf_request(key, video_player, player_id)
res = self._send_amf_request(req, key)
streams = {}
for message in res.messages:
if message.target_uri == "/1/onResult":
streams = self._parse_result(message.value)
return streams
__plugin__ = AzubuTV
livestreamer-1.12.2/src/livestreamer/plugins/artetv.py 0000644 0001750 0001750 00000005706 12521217321 024232 0 ustar chrippa chrippa 0000000 0000000 """Plugin for Arte.tv, bi-lingual art and culture channel."""
import re
from itertools import chain
from livestreamer.compat import urlparse
from livestreamer.plugin import Plugin
from livestreamer.plugin.api import http, validate
from livestreamer.stream import HLSStream, HTTPStream, RTMPStream
SWF_URL = "http://www.arte.tv/player/v2/jwplayer6/mediaplayer.6.6.swf"
_url_re = re.compile("http(s)?://(\w+\.)?arte.tv/")
_json_re = re.compile("arte_vp_(?:live-)?url='([^']+)'")
_schema = validate.Schema(
validate.transform(_json_re.search),
validate.any(
None,
validate.all(
validate.get(1),
validate.url(scheme="http")
)
)
)
_video_schema = validate.Schema({
"videoJsonPlayer": {
"VSR": validate.any(
[],
{
validate.text: {
"height": int,
"mediaType": validate.text,
"url": validate.text,
validate.optional("streamer"): validate.text
},
},
),
"VTY": validate.text
}
})
class ArteTV(Plugin):
@classmethod
def can_handle_url(self, url):
return _url_re.match(url)
def _create_stream(self, stream, is_live):
stream_name = "{0}p".format(stream["height"])
stream_type = stream["mediaType"]
stream_url = stream["url"]
if stream_type in ("hls", "mp4"):
if urlparse(stream_url).path.endswith("m3u8"):
try:
streams = HLSStream.parse_variant_playlist(self.session, stream_url)
# TODO: Replace with "yield from" when dropping Python 2.
for stream in streams.items():
yield stream
except IOError as err:
self.logger.error("Failed to extract HLS streams: {0}", err)
else:
yield stream_name, HTTPStream(self.session, stream_url)
elif stream_type == "rtmp":
params = {
"rtmp": stream["streamer"],
"playpath": stream["url"],
"swfVfy": SWF_URL,
"pageUrl": self.url,
}
if is_live:
params["live"] = True
else:
params["playpath"] = "mp4:{0}".format(params["playpath"])
stream = RTMPStream(self.session, params)
yield stream_name, stream
def _get_streams(self):
json_url = http.get(self.url, schema=_schema)
if not json_url:
return
res = http.get(json_url)
video = http.json(res, schema=_video_schema)
if not video["videoJsonPlayer"]["VSR"]:
return
is_live = video["videoJsonPlayer"]["VTY"] == "LIVE"
vsr = video["videoJsonPlayer"]["VSR"].values()
streams = (self._create_stream(stream, is_live) for stream in vsr)
return chain.from_iterable(streams)
__plugin__ = ArteTV
livestreamer-1.12.2/src/livestreamer/plugins/ard_mediathek.py 0000644 0001750 0001750 00000010371 12521217321 025500 0 ustar chrippa chrippa 0000000 0000000 import re
from livestreamer.plugin import Plugin
from livestreamer.plugin.api import http, validate
from livestreamer.stream import HTTPStream, HDSStream, RTMPStream
MEDIA_URL = "http://www.ardmediathek.de/play/media/{0}"
SWF_URL = "http://www.ardmediathek.de/ard/static/player/base/flash/PluginFlash.swf"
HDCORE_PARAMETER = "?hdcore=3.3.0"
QUALITY_MAP = {
"auto": "auto",
3: "544p",
2: "360p",
1: "288p",
0: "144p"
}
_url_re = re.compile("http(s)?://(\w+\.)?ardmediathek.de/tv")
_media_id_re = re.compile("/play/config/(\d+)")
_media_schema = validate.Schema({
"_mediaArray": [{
"_mediaStreamArray": [{
validate.optional("_server"): validate.text,
"_stream": validate.any(validate.text, [validate.text]),
"_quality": validate.any(int, validate.text)
}]
}]
})
_smil_schema = validate.Schema(
validate.union({
"base": validate.all(
validate.xml_find("head/meta"),
validate.get("base"),
validate.url(scheme="http")
),
"videos": validate.all(
validate.xml_findall("body/seq/video"),
[validate.get("src")]
)
})
)
class ard_mediathek(Plugin):
@classmethod
def can_handle_url(cls, url):
return _url_re.match(url)
def _get_http_streams(self, info):
name = QUALITY_MAP.get(info["_quality"], "vod")
urls = info["_stream"]
if not isinstance(info["_stream"], list):
urls = [urls]
for url in urls:
stream = HTTPStream(self.session, url)
yield name, stream
def _get_hds_streams(self, info):
# Needs the hdcore parameter added
url = info["_stream"] + HDCORE_PARAMETER
return HDSStream.parse_manifest(self.session, url, pvswf=SWF_URL).items()
def _get_rtmp_streams(self, info):
name = QUALITY_MAP.get(info["_quality"], "live")
params = {
"rtmp": info["_server"].strip(),
"playpath": info["_stream"],
"pageUrl": self.url,
"swfVfy": SWF_URL,
"live": True
}
stream = RTMPStream(self.session, params)
yield name, stream
def _get_smil_streams(self, info):
res = http.get(info["_stream"])
smil = http.xml(res, "SMIL config", schema=_smil_schema)
for video in smil["videos"]:
url = "{0}/{1}{2}".format(smil["base"], video, HDCORE_PARAMETER)
streams = HDSStream.parse_manifest(self.session, url, pvswf=SWF_URL)
# TODO: Replace with "yield from" when dropping Python 2.
for stream in streams.items():
yield stream
def _get_streams(self):
res = http.get(self.url)
match = _media_id_re.search(res.text)
if match:
media_id = match.group(1)
else:
return
res = http.get(MEDIA_URL.format(media_id))
media = http.json(res, schema=_media_schema)
for media in media["_mediaArray"]:
for stream in media["_mediaStreamArray"]:
server = stream.get("_server", "").strip()
stream_ = stream["_stream"]
if isinstance(stream_, list):
if not stream_:
continue
stream_ = stream_[0]
stream_ = stream_.strip()
if server.startswith("rtmp://"):
parser = self._get_rtmp_streams
parser_name = "RTMP"
elif stream_.endswith(".f4m"):
parser = self._get_hds_streams
parser_name = "HDS"
elif stream_.endswith(".smil"):
parser = self._get_smil_streams
parser_name = "SMIL"
elif stream_.startswith("http"):
parser = self._get_http_streams
parser_name = "HTTP"
try:
# TODO: Replace with "yield from" when dropping Python 2.
for stream in parser(stream):
yield stream
except IOError as err:
self.logger.error("Failed to extract {0} streams: {1}",
parser_name, err)
__plugin__ = ard_mediathek
livestreamer-1.12.2/src/livestreamer/plugins/ard_live.py 0000644 0001750 0001750 00000002670 12521217321 024507 0 ustar chrippa chrippa 0000000 0000000 import re
from functools import partial
from livestreamer.plugin import Plugin
from livestreamer.plugin.api import http, validate
from livestreamer.stream import HLSStream, HDSStream
STREAM_INFO_URL = "http://live.daserste.de/{0}/livestream.xml"
SWF_URL = "http://live.daserste.de/lib/br-player/swf/main.swf"
STREAMING_TYPES = {
"streamingUrlLive": (
"HDS", partial(HDSStream.parse_manifest, pvswf=SWF_URL)
),
"streamingUrlIPhone": (
"HLS", HLSStream.parse_variant_playlist
)
}
_url_re = re.compile("http(s)?://live.daserste.de/(?P<channel>[^/?]+)?")
_livestream_schema = validate.Schema(
validate.xml_findall("video/*"),
validate.filter(lambda e: e.tag in STREAMING_TYPES),
validate.map(lambda e: (STREAMING_TYPES.get(e.tag), e.text)),
validate.transform(dict),
)
class ard_live(Plugin):
@classmethod
def can_handle_url(cls, url):
return _url_re.match(url)
def _get_streams(self):
match = _url_re.match(self.url)
channel = match.group("channel")
res = http.get(STREAM_INFO_URL.format(channel))
urls = http.xml(res, schema=_livestream_schema)
streams = {}
for (name, parser), url in urls.items():
try:
streams.update(parser(self.session, url))
except IOError as err:
self.logger.warning("Unable to extract {0} streams: {1}", name, err)
return streams
__plugin__ = ard_live
livestreamer-1.12.2/src/livestreamer/plugins/alieztv.py 0000644 0001750 0001750 00000003725 12521217321 024402 0 ustar chrippa chrippa 0000000 0000000 import re
from os.path import splitext
from livestreamer.compat import urlparse, unquote
from livestreamer.plugin import Plugin
from livestreamer.plugin.api import http, validate
from livestreamer.stream import HTTPStream, RTMPStream
_url_re = re.compile("""
http(s)?://(\w+\.)?aliez.tv
(?:
/live/[^/]+
)?
(?:
/video/\d+/[^/]+
)?
""", re.VERBOSE)
_file_re = re.compile("\"?file\"?:\s+['\"]([^'\"]+)['\"]")
_swf_url_re = re.compile("swfobject.embedSWF\(\"([^\"]+)\",")
_schema = validate.Schema(
validate.union({
"urls": validate.all(
validate.transform(_file_re.findall),
validate.map(unquote),
[validate.url()]
),
"swf": validate.all(
validate.transform(_swf_url_re.search),
validate.any(
None,
validate.all(
validate.get(1),
validate.url(
scheme="http",
path=validate.endswith("swf")
)
)
)
)
})
)
class Aliez(Plugin):
@classmethod
def can_handle_url(self, url):
return _url_re.match(url)
def _get_streams(self):
res = http.get(self.url, schema=_schema)
streams = {}
for url in res["urls"]:
parsed = urlparse(url)
if parsed.scheme.startswith("rtmp"):
params = {
"rtmp": url,
"pageUrl": self.url,
"live": True
}
if res["swf"]:
params["swfVfy"] = res["swf"]
stream = RTMPStream(self.session, params)
streams["live"] = stream
elif parsed.scheme.startswith("http"):
name = splitext(parsed.path)[1][1:]
stream = HTTPStream(self.session, url)
streams[name] = stream
return streams
__plugin__ = Aliez
livestreamer-1.12.2/src/livestreamer/plugins/aftonbladet.py 0000644 0001750 0001750 00000005701 12521217321 025203 0 ustar chrippa chrippa 0000000 0000000 """Plugin for swedish news paper Aftonbladet's streaming service."""
import re
from livestreamer.plugin import Plugin
from livestreamer.plugin.api import http, validate
from livestreamer.stream import HDSStream, HLSStream
PLAYLIST_URL_FORMAT = "http://{address}/{path}/{filename}"
STREAM_TYPES = {
"hds": HDSStream.parse_manifest,
"hls": HLSStream.parse_variant_playlist
}
STREAM_FORMATS = ("m3u8", "f4m")
VIDEO_INFO_URL = "http://aftonbladet-play-static-ext.cdn.drvideo.aptoma.no/actions/video"
METADATA_URL = "http://aftonbladet-play-metadata.cdn.drvideo.aptoma.no/video/{0}.json"
_embed_re = re.compile("<iframe src=\"(http://tv.aftonbladet.se[^\"]+)\"")
_aptoma_id_re = re.compile("<div id=\"drvideo\".+data-aptomaId=\"([^\"]+)\"")
_live_re = re.compile("data-isLive=\"true\"")
_url_re = re.compile("http(s)?://(\w+.)?.aftonbladet.se")
_video_schema = validate.Schema(
{
"formats": validate.all(
{
validate.text: {
validate.text: validate.all(
dict,
validate.filter(lambda k,v: k in STREAM_FORMATS),
{
validate.text: [{
"address": validate.text,
"filename": validate.text,
"path": validate.text
}]
},
)
}
},
validate.filter(lambda k,v: k in STREAM_TYPES)
)
}
)
class Aftonbladet(Plugin):
@classmethod
def can_handle_url(cls, url):
return _url_re.match(url)
def _get_streams(self):
res = http.get(self.url)
match = _embed_re.search(res.text)
if match:
res = http.get(match.group(1))
match = _aptoma_id_re.search(res.text)
if not match:
return
aptoma_id = match.group(1)
if not _live_re.search(res.text):
res = http.get(METADATA_URL.format(aptoma_id))
metadata = http.json(res)
video_id = metadata["videoId"]
else:
video_id = aptoma_id
res = http.get(VIDEO_INFO_URL, params=dict(id=video_id))
video = http.json(res, schema=_video_schema)
streams = {}
for fmt, providers in video["formats"].items():
for name, provider in providers.items():
for ext, playlists in provider.items():
for playlist in playlists:
url = PLAYLIST_URL_FORMAT.format(**playlist)
parser = STREAM_TYPES[fmt]
try:
streams.update(parser(self.session, url))
except IOError as err:
self.logger.error("Failed to extract {0} streams: {1}",
fmt.upper(), err)
return streams
__plugin__ = Aftonbladet
livestreamer-1.12.2/src/livestreamer/plugins/afreecatv.py 0000644 0001750 0001750 00000003503 12521217321 024656 0 ustar chrippa chrippa 0000000 0000000 import re
from livestreamer.plugin import Plugin
from livestreamer.plugin.api import http, validate
from livestreamer.plugin.api.utils import parse_query
from livestreamer.stream import RTMPStream
VIEW_LIVE_API_URL = "http://api.afreeca.tv/live/view_live.php"
_url_re = re.compile("http(s)?://(\w+\.)?afreeca.tv/(?P<channel>[\w\-_]+)")
_flashvars_re = re.compile('<param name="flashvars" value="([^"]+)" />')
_flashvars_schema = validate.Schema(
validate.transform(_flashvars_re.findall),
validate.get(0),
validate.transform(parse_query),
validate.any(
{
"s": validate.text,
"id": validate.text
},
{}
)
)
_view_live_schema = validate.Schema(
{
"channel": {
"strm": [{
"brt": validate.text,
"bps": validate.text,
"purl": validate.url(scheme="rtmp")
}]
},
},
validate.get("channel"),
validate.get("strm")
)
class AfreecaTV(Plugin):
@classmethod
def can_handle_url(cls, url):
return _url_re.match(url)
def _get_streams(self):
flashvars = http.get(self.url, schema=_flashvars_schema)
if not flashvars:
return
params = {
"rt": "json",
"lc": "en_US",
"pt": "view",
"bpw": "",
"bid": flashvars["id"],
"adok": "",
"bno": ""
}
res = http.get(VIEW_LIVE_API_URL, params=params)
streams = http.json(res, schema=_view_live_schema)
for stream in streams:
stream_name = "{0}p".format(stream["bps"])
stream_params = {
"rtmp": stream["purl"],
"live": True
}
yield stream_name, RTMPStream(self.session, stream_params)
__plugin__ = AfreecaTV
livestreamer-1.12.2/src/livestreamer/plugins/afreeca.py 0000644 0001750 0001750 00000005367 12521217321 024316 0 ustar chrippa chrippa 0000000 0000000 import re
from livestreamer.plugin import Plugin
from livestreamer.plugin.api import http, validate
from livestreamer.stream import RTMPStream, HLSStream
CHANNEL_INFO_URL = "http://live.afreeca.com:8057/api/get_broad_state_list.php"
KEEP_ALIVE_URL = "{server}/stream_keepalive.html"
STREAM_INFO_URLS = {
"rtmp": "http://sessionmanager01.afreeca.tv:6060/broad_stream_assign.html",
"hls": "http://resourcemanager.afreeca.tv:9090/broad_stream_assign.html"
}
CHANNEL_RESULT_ERROR = 0
CHANNEL_RESULT_OK = 1
_url_re = re.compile("http(s)?://(\w+\.)?afreeca.com/(?P<username>\w+)")
_channel_schema = validate.Schema(
{
"CHANNEL": {
"RESULT": validate.transform(int),
"BROAD_INFOS": [{
"list": [{
"nBroadNo": validate.text
}]
}]
}
},
validate.get("CHANNEL")
)
_stream_schema = validate.Schema(
{
validate.optional("view_url"): validate.url(
scheme=validate.any("rtmp", "http")
)
}
)
class AfreecaTV(Plugin):
@classmethod
def can_handle_url(self, url):
return _url_re.match(url)
def _get_channel_info(self, username):
headers = {
"Referer": self.url
}
data = {
"uid": username
}
res = http.post(CHANNEL_INFO_URL, data=data, headers=headers)
return http.json(res, schema=_channel_schema)
def _get_stream_info(self, broadcast, type):
params = {
"return_type": "gs_cdn",
"broad_key": "{broadcast}-flash-hd-{type}".format(**locals())
}
res = http.get(STREAM_INFO_URLS[type], params=params)
return http.json(res, schema=_stream_schema)
def _get_hls_stream(self, broadcast):
info = self._get_stream_info(broadcast, "hls")
if "view_url" in info:
return HLSStream(self.session, info["view_url"])
def _get_rtmp_stream(self, broadcast):
info = self._get_stream_info(broadcast, "rtmp")
if "view_url" in info:
params = dict(rtmp=info["view_url"])
return RTMPStream(self.session, params=params, redirect=True)
def _get_streams(self):
match = _url_re.match(self.url)
username = match.group("username")
channel = self._get_channel_info(username)
if channel["RESULT"] != CHANNEL_RESULT_OK:
return
broadcast = channel["BROAD_INFOS"][0]["list"][0]["nBroadNo"]
if not broadcast:
return
flash_stream = self._get_rtmp_stream(broadcast)
if flash_stream:
yield "live", flash_stream
mobile_stream = self._get_hls_stream(broadcast)
if mobile_stream:
yield "live", mobile_stream
__plugin__ = AfreecaTV
livestreamer-1.12.2/src/livestreamer/plugins/__init__.py 0000644 0001750 0001750 00000000362 12521217321 024455 0 ustar chrippa chrippa 0000000 0000000 """
New plugins should use livestreamer.plugin.Plugin instead
of this module, but this is kept here for backwards
compatibility.
"""
from ..exceptions import PluginError, NoStreamsError, NoPluginError
from ..plugin import Plugin
livestreamer-1.12.2/src/livestreamer/plugin/ 0000755 0001750 0001750 00000000000 12521217500 022157 5 ustar chrippa chrippa 0000000 0000000 livestreamer-1.12.2/src/livestreamer/plugin/plugin.py 0000644 0001750 0001750 00000022333 12521217321 024033 0 ustar chrippa chrippa 0000000 0000000 import operator
import re
from functools import partial
from ..cache import Cache
from ..exceptions import PluginError, NoStreamsError
from ..options import Options
QUALITY_WEIGTHS_EXTRA = {
"other": {
"live": 1080,
},
"tv": {
"hd": 1080,
"sd": 576,
},
"quality": {
"ehq": 720,
"hq": 576,
"sq": 360,
},
}
FILTER_OPERATORS = {
"<": operator.lt,
"<=": operator.le,
">": operator.gt,
">=": operator.ge,
}
def stream_weight(stream):
for group, weights in QUALITY_WEIGTHS_EXTRA.items():
if stream in weights:
return weights[stream], group
match = re.match("^(\d+)([k]|[p])?([\+])?$", stream)
if match:
if match.group(2) == "k":
bitrate = int(match.group(1))
# FIXME: This is a crude attempt at making a bitrate's
# weight end up similar to the weight of a resolution.
# Someone who knows math, please fix.
weight = bitrate / 2.8
return weight, "bitrate"
elif match.group(2) == "p":
weight = int(match.group(1))
if match.group(3) == "+":
weight += 1
return weight, "pixels"
return 0, "none"
def iterate_streams(streams):
for name, stream in streams:
if isinstance(stream, list):
for sub_stream in stream:
yield (name, sub_stream)
else:
yield (name, stream)
def stream_type_priority(stream_types, stream):
stream_type = type(stream[1]).shortname()
try:
prio = stream_types.index(stream_type)
except ValueError:
prio = 99
return prio
def stream_sorting_filter(expr, stream_weight):
match = re.match(r"(?P<op><=|>=|<|>)?(?P<value>[\w\+]+)", expr)
if not match:
raise PluginError("Invalid filter expression: {0}".format(expr))
op, value = match.group("op", "value")
op = FILTER_OPERATORS.get(op, operator.eq)
filter_weight, filter_group = stream_weight(value)
def func(quality):
weight, group = stream_weight(quality)
if group == filter_group:
return not op(weight, filter_weight)
return True
return func
class Plugin(object):
"""A plugin can retrieve stream information from the URL specified.
:param url: URL that the plugin will operate on
"""
cache = None
logger = None
module = "unknown"
options = Options()
session = None
@classmethod
def bind(cls, session, module):
cls.cache = Cache(filename="plugin-cache.json",
key_prefix=module)
cls.logger = session.logger.new_module("plugin." + module)
cls.module = module
cls.session = session
def __init__(self, url):
self.url = url
@classmethod
def can_handle_url(cls, url):
raise NotImplementedError
@classmethod
def set_option(cls, key, value):
cls.options.set(key, value)
@classmethod
def get_option(cls, key):
return cls.options.get(key)
@classmethod
def stream_weight(cls, stream):
return stream_weight(stream)
@classmethod
def default_stream_types(cls, streams):
stream_types = ["rtmp", "hls", "hds", "http"]
for name, stream in iterate_streams(streams):
stream_type = type(stream).shortname()
if stream_type not in stream_types:
stream_types.append(stream_type)
return stream_types
@classmethod
def broken(cls, issue=None):
def func(*args, **kwargs):
msg = (
"This plugin has been marked as broken. This is likely due to "
"changes to the service preventing a working implementation. "
)
if issue:
msg += "More info: https://github.com/chrippa/livestreamer/issues/{0}".format(issue)
raise PluginError(msg)
def decorator(*args, **kwargs):
return func
return decorator
def streams(self, stream_types=None, sorting_excludes=None):
"""Attempts to extract available streams.
Returns a :class:`dict` containing the streams, where the key is
the name of the stream, most commonly the quality and the value
is a :class:`Stream` object.
The result can contain the synonyms **best** and **worst** which
points to the streams which are likely to be of highest and
lowest quality respectively.
If multiple streams with the same name are found, the order of
streams specified in *stream_types* will determine which stream
gets to keep the name while the rest will be renamed to
"<name>_<stream type>".
The synonyms can be fine tuned with the *sorting_excludes*
parameter. This can be either of these types:
- A list of filter expressions in the format
*[operator]<value>*. For example the filter ">480p" will
exclude streams ranked higher than "480p" from the list
used in the synonyms ranking. Valid operators are >, >=, <
and <=. If no operator is specified then equality will be
tested.
- A function that is passed to filter() with a list of
stream names as input.
:param stream_types: A list of stream types to return.
:param sorting_excludes: Specify which streams to exclude from
the best/worst synonyms.
.. versionchanged:: 1.4.2
Added *priority* parameter.
.. versionchanged:: 1.5.0
Renamed *priority* to *stream_types* and changed behaviour
slightly.
.. versionchanged:: 1.5.0
Added *sorting_excludes* parameter.
.. versionchanged:: 1.6.0
*sorting_excludes* can now be a list of filter expressions
or a function that is passed to filter().
"""
try:
ostreams = self._get_streams()
if isinstance(ostreams, dict):
ostreams = ostreams.items()
# Flatten the iterator to a list so we can reuse it.
if ostreams:
ostreams = list(ostreams)
except NoStreamsError:
return {}
except (IOError, OSError, ValueError) as err:
raise PluginError(err)
if not ostreams:
return {}
if stream_types is None:
stream_types = self.default_stream_types(ostreams)
# Add streams depending on stream type and priorities
sorted_streams = sorted(iterate_streams(ostreams),
key=partial(stream_type_priority,
stream_types))
streams = {}
for name, stream in sorted_streams:
stream_type = type(stream).shortname()
if stream_type not in stream_types:
continue
existing = streams.get(name)
if existing:
existing_stream_type = type(existing).shortname()
if existing_stream_type != stream_type:
name = "{0}_{1}".format(name, stream_type)
if name in streams:
name = "{0}_alt".format(name)
num_alts = len(list(filter(lambda n: n.startswith(name), streams.keys())))
# We shouldn't need more than 2 alt streams
if num_alts >= 2:
continue
elif num_alts > 0:
name = "{0}{1}".format(name, num_alts + 1)
# Validate stream name and discard the stream if it's bad.
match = re.match("([A-z0-9_+]+)", name)
if match:
name = match.group(1)
else:
self.logger.debug("The stream '{0}' has been ignored "
"since it is badly named.", name)
continue
# Force lowercase name and replace space with underscore.
streams[name.lower()] = stream
# Create the best/worst synonmys
stream_weight_only = lambda s: (self.stream_weight(s)[0] or
(len(streams) == 1 and 1))
stream_names = filter(stream_weight_only, streams.keys())
sorted_streams = sorted(stream_names, key=stream_weight_only)
if isinstance(sorting_excludes, list):
for expr in sorting_excludes:
filter_func = stream_sorting_filter(expr, self.stream_weight)
sorted_streams = list(filter(filter_func, sorted_streams))
elif callable(sorting_excludes):
sorted_streams = list(filter(sorting_excludes, sorted_streams))
if len(sorted_streams) > 0:
best = sorted_streams[-1]
worst = sorted_streams[0]
streams["best"] = streams[best]
streams["worst"] = streams[worst]
return streams
def get_streams(self, *args, **kwargs):
"""Deprecated since version 1.9.0.
Has been renamed to :func:`Plugin.streams`, this is an alias
for backwards compatibility.
"""
return self.streams(*args, **kwargs)
def _get_streams(self):
raise NotImplementedError
__all__ = ["Plugin"]
livestreamer-1.12.2/src/livestreamer/plugin/__init__.py 0000644 0001750 0001750 00000000245 12521217321 024272 0 ustar chrippa chrippa 0000000 0000000 from .plugin import Plugin
from ..exceptions import PluginError
from ..options import Options as PluginOptions
__all__ = ["Plugin", "PluginError", "PluginOptions"]
livestreamer-1.12.2/src/livestreamer/plugin/api/ 0000755 0001750 0001750 00000000000 12521217500 022730 5 ustar chrippa chrippa 0000000 0000000 livestreamer-1.12.2/src/livestreamer/plugin/api/validate.py 0000644 0001750 0001750 00000030367 12521217321 025105 0 ustar chrippa chrippa 0000000 0000000 """This module provides an API to validate and to some extent
manipulate data structures, such as JSON and XML parsing results.
Example usage:
>>> validate(int, 5)
5
>>> validate({text: int}, {'foo': '1'})
ValueError: Type of '1' should be 'int' but is 'str'
>>> validate({'foo': transform(int)}, {'foo': '1'})
{'foo': 1}
"""
from xml.etree import ElementTree as ET
from copy import copy as copy_obj
try:
from functools import singledispatch
except ImportError:
from singledispatch import singledispatch
from ...compat import is_py2, urlparse
from ...exceptions import PluginError
__all__ = [
"any", "all", "filter", "get", "getattr", "hasattr", "length", "optional",
"transform", "text", "union", "url", "startswith", "endswith",
"xml_element", "xml_find", "xml_findall", "xml_findtext",
"validate", "Schema", "SchemaContainer"
]
#: Alias for text type on each Python version
text = is_py2 and basestring or str
# References to original functions that we override in this module
_all = all
_getattr = getattr
_hasattr = hasattr
_filter = filter
_map = map
_re_match_attr = ("group", "groups", "groupdict", "re")
def _is_re_match(value):
return _all(_hasattr(value, a) for a in _re_match_attr)
class any(tuple):
"""At least one of the schemas must be valid."""
def __new__(cls, *args):
return super(any, cls).__new__(cls, args)
class all(tuple):
"""All schemas must be valid."""
def __new__(cls, *args):
return super(all, cls).__new__(cls, args)
class SchemaContainer(object):
def __init__(self, schema):
self.schema = schema
class transform(object):
"""Applies function to value to transform it."""
def __init__(self, func):
# text is an alias for basestring on Python 2, which cannot be
# instantiated and therefore can't be used to transform the value,
# so we force to unicode instead.
if is_py2 and func == text:
func = unicode
self.func = func
class optional(object):
"""An optional key used in a dict or union-dict."""
def __init__(self, key):
self.key = key
class union(SchemaContainer):
"""Extracts multiple validations based on the same value."""
class attr(SchemaContainer):
"""Validates an object's attributes."""
class xml_element(object):
"""A XML element."""
def __init__(self, tag=None, text=None, attrib=None):
self.tag = tag
self.text = text
self.attrib = attrib
def length(length):
"""Checks value for minimum length using len()."""
def min_len(value):
if not len(value) >= length:
raise ValueError(
"Minimum length is {0} but value is {1}".format(length, len(value))
)
return True
return min_len
def startswith(string):
"""Checks if the string value starts with another string."""
def starts_with(value):
validate(text, value)
if not value.startswith(string):
raise ValueError("'{0}' does not start with '{1}'".format(value, string))
return True
return starts_with
def endswith(string):
"""Checks if the string value ends with another string."""
def ends_with(value):
validate(text, value)
if not value.endswith(string):
raise ValueError("'{0}' does not end with '{1}'".format(value, string))
return True
return ends_with
def get(item, default=None):
"""Get item from value (value[item]).
If the item is not found, return the default.
Handles XML elements, regex matches and anything that has __getitem__.
"""
def getter(value):
if ET.iselement(value):
value = value.attrib
try:
# Use .group() if this is a regex match object
if _is_re_match(value):
return value.group(item)
else:
return value[item]
except (KeyError, IndexError):
return default
except (TypeError, AttributeError) as err:
raise ValueError(err)
return transform(getter)
def getattr(attr, default=None):
"""Get a named attribute from an object.
When a default argument is given, it is returned when the attribute
doesn't exist.
"""
def getter(value):
return _getattr(value, attr, default)
return transform(getter)
def hasattr(attr):
"""Verifies that the object has an attribute with the given name."""
def has_attr(value):
return _hasattr(value, attr)
return has_attr
def filter(func):
"""Filters out unwanted items using the specified function.
Supports both dicts and sequences, key/value pairs are
expanded when applied to a dict.
"""
def expand_kv(kv):
return func(*kv)
def filter_values(value):
cls = type(value)
if isinstance(value, dict):
return cls(_filter(expand_kv, value.items()))
else:
return cls(_filter(func, value))
return transform(filter_values)
def map(func):
"""Apply function to each value inside the sequence or dict.
Supports both dicts and sequences, key/value pairs are
expanded when applied to a dict.
"""
# text is an alias for basestring on Python 2, which cannot be
# instantiated and therefore can't be used to transform the value,
# so we force to unicode instead.
if is_py2 and text == func:
func = unicode
def expand_kv(kv):
return func(*kv)
def map_values(value):
cls = type(value)
if isinstance(value, dict):
return cls(_map(expand_kv, value.items()))
else:
return cls(_map(func, value))
return transform(map_values)
def url(**attributes):
"""Parses an URL and validates its attributes."""
def check_url(value):
validate(text, value)
parsed = urlparse(value)
if not parsed.netloc:
raise ValueError("'{0}' is not a valid URL".format(value))
for name, schema in attributes.items():
if not _hasattr(parsed, name):
raise ValueError("Invalid URL attribute '{0}'".format(name))
try:
validate(schema, _getattr(parsed, name))
except ValueError as err:
raise ValueError(
"Unable to validate URL attribute '{0}': {1}".format(
name, err
)
)
return True
# Convert "http" to be either any("http", "https") for convenience
if attributes.get("scheme") == "http":
attributes["scheme"] = any("http", "https")
return check_url
def xml_find(xpath):
"""Find a XML element via xpath."""
def xpath_find(value):
validate(ET.iselement, value)
value = value.find(xpath)
if value is None:
raise ValueError("XPath '{0}' did not return an element".format(xpath))
return validate(ET.iselement, value)
return transform(xpath_find)
def xml_findall(xpath):
"""Find a list of XML elements via xpath."""
def xpath_findall(value):
validate(ET.iselement, value)
return value.findall(xpath)
return transform(xpath_findall)
def xml_findtext(xpath):
"""Find a XML element via xpath and extract its text."""
return all(
xml_find(xpath),
getattr("text"),
)
@singledispatch
def validate(schema, value):
if callable(schema):
if schema(value):
return value
else:
raise ValueError("{0}({1!r}) is not true".format(schema.__name__, value))
if schema == value:
return value
else:
raise ValueError("{0!r} does not equal {1!r}".format(value, schema))
@validate.register(any)
def validate_any(schema, value):
errors = []
for subschema in schema:
try:
return validate(subschema, value)
except ValueError as err:
errors.append(err)
else:
err = " or ".join(_map(str, errors))
raise ValueError(err)
@validate.register(all)
def validate_all(schemas, value):
for schema in schemas:
value = validate(schema, value)
return value
@validate.register(transform)
def validate_transform(schema, value):
validate(callable, schema.func)
return schema.func(value)
@validate.register(list)
@validate.register(tuple)
@validate.register(set)
@validate.register(frozenset)
def validate_sequence(schema, value):
validate(type(schema), value)
return type(schema)(validate(any(*schema), v) for v in value)
@validate.register(dict)
def validate_dict(schema, value):
validate(type(schema), value)
new = type(schema)()
for key, subschema in schema.items():
if isinstance(key, optional):
if key.key not in value:
continue
key = key.key
if type(key) in (type, transform, any, all, union):
for subkey, subvalue in value.items():
new[validate(key, subkey)] = validate(subschema, subvalue)
break
else:
if key not in value:
raise ValueError("Key '{0}' not found in {1!r}".format(key, value))
try:
new[key] = validate(subschema, value[key])
except ValueError as err:
raise ValueError("Unable to validate key '{0}': {1}".format(key, err))
return new
@validate.register(type)
def validate_type(schema, value):
if isinstance(value, schema):
return value
else:
raise ValueError(
"Type of {0!r} should be '{1}' but is '{2}'".format(
value, schema.__name__, type(value).__name__
)
)
@validate.register(xml_element)
def validate_xml_element(schema, value):
validate(ET.iselement, value)
new = ET.Element(value.tag, attrib=value.attrib)
if schema.attrib is not None:
try:
new.attrib = validate(schema.attrib, value.attrib)
except ValueError as err:
raise ValueError("Unable to validate XML attributes: {0}".format(err))
if schema.tag is not None:
try:
new.tag = validate(schema.tag, value.tag)
except ValueError as err:
raise ValueError("Unable to validate XML tag: {0}".format(err))
if schema.text is not None:
try:
new.text = validate(schema.text, value.text)
except ValueError as err:
raise ValueError("Unable to validate XML text: {0}".format(err))
for child in value:
new.append(child)
return new
@validate.register(attr)
def validate_attr(schema, value):
new = copy_obj(value)
for attr, schema in schema.schema.items():
if not _hasattr(value, attr):
raise ValueError("Attribute '{0}' not found on object '{1}'".format(
attr, value
))
setattr(new, attr, validate(schema, _getattr(value, attr)))
return new
@singledispatch
def validate_union(schema, value):
raise ValueError("Invalid union type: {0}".format(type(schema).__name__))
@validate_union.register(dict)
def validate_union_dict(schema, value):
new = type(schema)()
for key, schema in schema.items():
optional_ = isinstance(key, optional)
if optional_:
key = key.key
try:
new[key] = validate(schema, value)
except ValueError as err:
if optional_:
continue
raise ValueError("Unable to validate union '{0}': {1}".format(key, err))
return new
@validate_union.register(list)
@validate_union.register(tuple)
@validate_union.register(set)
@validate_union.register(frozenset)
def validate_union_sequence(schemas, value):
return type(schemas)(validate(schema, value) for schema in schemas)
@validate.register(union)
def validate_unions(schema, value):
return validate_union(schema.schema, value)
class Schema(object):
"""Wraps a validator schema into a object."""
def __init__(self, *schemas):
self.schema = all(*schemas)
def validate(self, value, name="result", exception=PluginError):
try:
return validate(self.schema, value)
except ValueError as err:
raise exception("Unable to validate {0}: {1}".format(name, err))
@validate.register(Schema)
def validate_schema(schema, value):
return schema.validate(value, exception=ValueError)
livestreamer-1.12.2/src/livestreamer/plugin/api/utils.py 0000644 0001750 0001750 00000000243 12521217321 024442 0 ustar chrippa chrippa 0000000 0000000 """Useful wrappers and other tools."""
__all__ = ["parse_json", "parse_xml", "parse_query"]
from ...utils import parse_qsd as parse_query, parse_json, parse_xml
livestreamer-1.12.2/src/livestreamer/plugin/api/support_plugin.py 0000644 0001750 0001750 00000002735 12521217321 026404 0 ustar chrippa chrippa 0000000 0000000 import os
import inspect
import sys
__all__ = ["load_support_plugin"]
def load_support_plugin(name):
"""Loads a plugin from the same directory as the calling plugin.
The path used is extracted from the last call in module scope,
therefore this must be called only from module level in the
originating plugin or the correct plugin path will not be found.
"""
# Get the path of the caller module
stack = list(filter(lambda f: f[3] == "<module>", inspect.stack()))
prev_frame = stack[0]
path = os.path.dirname(prev_frame[1])
# Major hack. If we are frozen by bbfreeze the stack trace will
# contain relative paths. We therefore use the __file__ variable
# in this module to correct it.
if not os.path.isabs(path):
prefix = os.path.normpath(__file__ + "../../../../../")
path = os.path.join(prefix, path)
# importlib is the preferred way of importing a module, but it's
# only available on Python 3.1+.
if sys.version_info[0] == 3 and sys.version_info[1] >= 3:
import importlib
loader = importlib.find_loader(name, [path])
if loader:
module = loader.load_module()
else:
raise ImportError("No module named '{0}'".format(name))
else:
import imp
fd, filename, desc = imp.find_module(name, [path])
try:
module = imp.load_module(name, fd, filename, desc)
finally:
if fd: fd.close()
return module
livestreamer-1.12.2/src/livestreamer/plugin/api/mapper.py 0000644 0001750 0001750 00000003131 12521217321 024565 0 ustar chrippa chrippa 0000000 0000000 from functools import partial
from itertools import product
from operator import eq
class StreamMapper(object):
"""The stream mapper can be used to simplify the process of creating
stream objects from data.
:param cmp: This callable is used to compare each mapping's key
with a value.
"""
def __init__(self, cmp=eq):
self._map = []
self._cmp = cmp
def map(self, key, func, *args, **kwargs):
"""Creates a key-function mapping.
The return value from the function should be either
- A tuple containing a name and stream
- A iterator of tuples containing a name and stream
Any extra arguments will be passed to the function.
"""
self._map.append((key, partial(func, *args, **kwargs)))
def _cmp_filter(self, args):
value, (key, func) = args
return self._cmp(key, value)
def _mapped_func(self, args):
value, (key, func) = args
return func(value)
def __call__(self, values):
"""Runs through each value and transform it with a mapped function."""
values = product(values, self._map)
for value in map(self._mapped_func, filter(self._cmp_filter, values)):
if isinstance(value, tuple) and len(value) == 2:
yield value
else:
try:
# TODO: Replace with "yield from" when dropping Python 2.
for __ in value:
yield __
except TypeError:
# Non-iterable returned
continue
livestreamer-1.12.2/src/livestreamer/plugin/api/http_session.py 0000644 0001750 0001750 00000011274 12521217321 026032 0 ustar chrippa chrippa 0000000 0000000 from requests import Session, __build__ as requests_version
from requests.adapters import HTTPAdapter
from requests.exceptions import RequestException
try:
from requests.packages.urllib3.util import Timeout
TIMEOUT_ADAPTER_NEEDED = requests_version < 0x020300
except ImportError:
TIMEOUT_ADAPTER_NEEDED = False
try:
from requests.packages import urllib3
# We tell urllib3 to disable warnings about unverified HTTPS requests,
# because in some plugins we have to do unverified requests intentionally.
urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
except (ImportError, AttributeError):
pass
from ...exceptions import PluginError
from ...utils import parse_json, parse_xml
__all__ = ["HTTPSession"]
def _parse_keyvalue_list(val):
for keyvalue in val.split(";"):
try:
key, value = keyvalue.split("=", 1)
yield key.strip(), value.strip()
except ValueError:
continue
class HTTPAdapterWithReadTimeout(HTTPAdapter):
"""This is a backport of the timeout behaviour from requests 2.3.0+
where timeout is applied to both connect and read."""
def get_connection(self, *args, **kwargs):
conn = HTTPAdapter.get_connection(self, *args, **kwargs)
# Override the urlopen method on this connection
if not hasattr(conn.urlopen, "wrapped"):
orig_urlopen = conn.urlopen
def urlopen(*args, **kwargs):
timeout = kwargs.pop("timeout", None)
if isinstance(timeout, Timeout):
timeout = Timeout.from_float(timeout.connect_timeout)
return orig_urlopen(*args, timeout=timeout, **kwargs)
conn.urlopen = urlopen
conn.urlopen.wrapped = True
return conn
class HTTPSession(Session):
def __init__(self, *args, **kwargs):
Session.__init__(self, *args, **kwargs)
self.timeout = 20.0
if TIMEOUT_ADAPTER_NEEDED:
self.mount("http://", HTTPAdapterWithReadTimeout())
self.mount("https://", HTTPAdapterWithReadTimeout())
@classmethod
def json(cls, res, *args, **kwargs):
"""Parses JSON from a response."""
return parse_json(res.text, *args, **kwargs)
@classmethod
def xml(cls, res, *args, **kwargs):
"""Parses XML from a response."""
return parse_xml(res.text, *args, **kwargs)
def parse_cookies(self, cookies, **kwargs):
"""Parses a semi-colon delimited list of cookies.
Example: foo=bar;baz=qux
"""
for name, value in _parse_keyvalue_list(cookies):
self.cookies.set(name, value, **kwargs)
def parse_headers(self, headers):
"""Parses a semi-colon delimited list of headers.
Example: foo=bar;baz=qux
"""
for name, value in _parse_keyvalue_list(headers):
self.headers[name] = value
def parse_query_params(self, cookies, **kwargs):
"""Parses a semi-colon delimited list of query parameters.
Example: foo=bar;baz=qux
"""
for name, value in _parse_keyvalue_list(cookies):
self.params[name] = value
def resolve_url(self, url):
"""Resolves any redirects and returns the final URL."""
return self.get(url, stream=True).url
def request(self, method, url, *args, **kwargs):
acceptable_status = kwargs.pop("acceptable_status", [])
exception = kwargs.pop("exception", PluginError)
headers = kwargs.pop("headers", {})
params = kwargs.pop("params", {})
proxies = kwargs.pop("proxies", self.proxies)
raise_for_status = kwargs.pop("raise_for_status", True)
schema = kwargs.pop("schema", None)
session = kwargs.pop("session", None)
timeout = kwargs.pop("timeout", self.timeout)
if session:
headers.update(session.headers)
params.update(session.params)
try:
res = Session.request(self, method, url,
headers=headers,
params=params,
timeout=timeout,
proxies=proxies,
*args, **kwargs)
if raise_for_status and res.status_code not in acceptable_status:
res.raise_for_status()
except (RequestException, IOError) as rerr:
err = exception("Unable to open URL: {url} ({err})".format(url=url,
err=rerr))
err.err = rerr
raise err
if schema:
res = schema.validate(res.text, name="response text", exception=PluginError)
return res
livestreamer-1.12.2/src/livestreamer/plugin/api/__init__.py 0000644 0001750 0001750 00000001412 12521217321 025040 0 ustar chrippa chrippa 0000000 0000000 import sys
from types import ModuleType as module
from .http_session import HTTPSession
from .mapper import StreamMapper
from .support_plugin import load_support_plugin
__all__ = ["HTTPSession", "StreamMapper", "load_support_plugin", "http"]
class SupportPlugin(module):
"""Custom module to allow calling load_support_plugin()
using a import statement.
Usage::
>>> from livestreamer.plugin.api.support_plugin import myplugin_extra
"""
__path__ = __path__
__file__ = __file__
def __getattr__(self, name):
if not name.startswith("__"):
return load_support_plugin(name)
support_plugin_path = "livestreamer.plugin.api.support_plugin"
sys.modules[support_plugin_path] = SupportPlugin("support_plugin")
http = None
livestreamer-1.12.2/src/livestreamer/packages/ 0000755 0001750 0001750 00000000000 12521217500 022437 5 ustar chrippa chrippa 0000000 0000000 livestreamer-1.12.2/src/livestreamer/packages/pbs.py 0000644 0001750 0001750 00000033761 12521217321 023610 0 ustar chrippa chrippa 0000000 0000000 #===============================================================================
# Copyright (C) 2011-2012 by Andrew Moffat
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in
# all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
# THE SOFTWARE.
#===============================================================================
import subprocess as subp
import sys
import traceback
import os
import re
from glob import glob as original_glob
from types import ModuleType
from functools import partial
import warnings
import platform
__version__ = "0.110"
__project_url__ = "https://github.com/amoffat/pbs"
IS_PY3 = sys.version_info[0] == 3
if IS_PY3:
raw_input = input
unicode = str
else:
pass
DEFAULT_ENCODING = "utf-8"
class ErrorReturnCode(Exception):
truncate_cap = 200
def __init__(self, full_cmd, stdout, stderr):
self.full_cmd = full_cmd
self.stdout = stdout
self.stderr = stderr
if self.stdout is None: tstdout = "<redirected>"
else:
tstdout = self.stdout[:self.truncate_cap]
out_delta = len(self.stdout) - len(tstdout)
if out_delta:
tstdout += ("... (%d more, please see e.stdout)" % out_delta).encode()
if self.stderr is None: tstderr = "<redirected>"
else:
tstderr = self.stderr[:self.truncate_cap]
err_delta = len(self.stderr) - len(tstderr)
if err_delta:
tstderr += ("... (%d more, please see e.stderr)" % err_delta).encode()
msg = "\n\nRan: %r\n\nSTDOUT:\n\n %s\n\nSTDERR:\n\n %s" %\
(full_cmd, tstdout.decode(DEFAULT_ENCODING, "replace"),
tstderr.decode(DEFAULT_ENCODING, "replace"))
super(ErrorReturnCode, self).__init__(msg)
class CommandNotFound(Exception): pass
rc_exc_regex = re.compile("ErrorReturnCode_(\d+)")
rc_exc_cache = {}
def get_rc_exc(rc):
rc = int(rc)
try: return rc_exc_cache[rc]
except KeyError: pass
name = "ErrorReturnCode_%d" % rc
exc = type(name, (ErrorReturnCode,), {})
rc_exc_cache[rc] = exc
return exc
def which(program):
def is_exe(fpath):
return os.path.exists(fpath) and os.access(fpath, os.X_OK)
fpath, fname = os.path.split(program)
if fpath:
if is_exe(program): return program
else:
for path in os.environ["PATH"].split(os.pathsep):
exe_file = os.path.join(path, program)
if is_exe(exe_file):
return exe_file
return None
def resolve_program(program):
path = which(program)
if not path:
# our actual command might have a dash in it, but we can't call
# that from python (we have to use underscores), so we'll check
# if a dash version of our underscore command exists and use that
# if it does
if "_" in program: path = which(program.replace("_", "-"))
if not path: return None
return path
def glob(arg):
return original_glob(arg) or arg
def create_command(cmd):
return Command._create(cmd)
class RunningCommand(object):
def __init__(self, command_ran, process, call_args, stdin=None):
self.command_ran = command_ran
self.process = process
self._stdout = None
self._stderr = None
self.call_args = call_args
# we're running in the background, return self and let us lazily
# evaluate
if self.call_args["bg"]:
return
# we're running this command as a with context, don't do anything
# because nothing was started to run from Command.__call__
if self.call_args["with"]: return
# run and block
if stdin: stdin = stdin.encode(DEFAULT_ENCODING)
self._stdout, self._stderr = self.process.communicate(stdin)
self._handle_exit_code(self.process.wait())
def __enter__(self):
# we don't actually do anything here because anything that should
# have been done would have been done in the Command.__call__ call.
# essentially all that has to happen is the comand be pushed on
# the prepend stack.
pass
def __exit__(self, typ, value, traceback):
if self.call_args["with"] and Command._prepend_stack:
Command._prepend_stack.pop()
def __str__(self):
if IS_PY3: return self.__unicode__()
else: return unicode(self).encode(DEFAULT_ENCODING)
def __unicode__(self):
if self.process:
if self.call_args["bg"]: self.wait()
if self._stdout: return self.stdout()
else: return ""
def __eq__(self, other):
return unicode(self) == unicode(other)
__hash__ = None # Avoid DeprecationWarning in Python < 3
def __contains__(self, item):
return item in str(self)
def __getattr__(self, p):
# let these three attributes pass through to the Popen object
if p in ("send_signal", "terminate", "kill"):
if self.process: return getattr(self.process, p)
else: raise AttributeError
return getattr(unicode(self), p)
def __repr__(self):
return "<RunningCommand %r, pid:%d, special_args:%r" % (
self.command_ran, self.process.pid, self.call_args)
def __long__(self):
return long(str(self).strip())
def __float__(self):
return float(str(self).strip())
def __int__(self):
return int(str(self).strip())
def stdout(self):
if self.call_args["bg"]: self.wait()
return self._stdout.decode(DEFAULT_ENCODING, "replace")
def stderr(self):
if self.call_args["bg"]: self.wait()
return self._stderr.decode(DEFAULT_ENCODING, "replace")
def wait(self):
self._stdout, self._stderr = self.process.communicate()
self._handle_exit_code(self.process.wait())
return str(self)
def _handle_exit_code(self, rc):
if rc not in self.call_args["ok_code"]:
raise get_rc_exc(rc)(self.command_ran, self._stdout, self._stderr)
def __len__(self):
return len(str(self))
class Command(object):
_prepend_stack = []
call_args = {
"fg": False, # run command in foreground
"bg": False, # run command in background
"with": False, # prepend the command to every command after it
"out": None, # redirect STDOUT
"err": None, # redirect STDERR
"err_to_out": None, # redirect STDERR to STDOUT
"in": None,
"env": os.environ,
"cwd": None,
# this is for commands that may have a different exit status than the
# normal 0. this can either be an integer or a list/tuple of ints
"ok_code": 0,
}
@classmethod
def _create(cls, program):
path = resolve_program(program)
if not path: raise CommandNotFound(program)
return cls(path)
def __init__(self, path):
self._path = path
self._partial = False
self._partial_baked_args = []
self._partial_call_args = {}
def __getattribute__(self, name):
# convenience
getattr = partial(object.__getattribute__, self)
if name.startswith("_"): return getattr(name)
if name == "bake": return getattr("bake")
return getattr("bake")(name)
@staticmethod
def _extract_call_args(kwargs):
kwargs = kwargs.copy()
call_args = Command.call_args.copy()
for parg, default in call_args.items():
key = "_" + parg
if key in kwargs:
call_args[parg] = kwargs[key]
del kwargs[key]
return call_args, kwargs
def _format_arg(self, arg):
if IS_PY3:
arg = str(arg)
else:
try:
arg = unicode(arg, DEFAULT_ENCODING).encode(DEFAULT_ENCODING)
except TypeError:
arg = unicode(arg).encode(DEFAULT_ENCODING)
if self._partial:
escaped = arg.replace('"', '\\"')
escaped = escaped.replace("$", "\$")
escaped = escaped.replace("`", "\`")
arg = '"{0}"'.format(escaped)
return arg
def _compile_args(self, args, kwargs):
processed_args = []
# aggregate positional args
for arg in args:
if isinstance(arg, (list, tuple)):
if not arg:
warnings.warn("Empty list passed as an argument to %r. \
If you're using glob.glob(), please use pbs.glob() instead." % self.path, stacklevel=3)
for sub_arg in arg: processed_args.append(self._format_arg(sub_arg))
else: processed_args.append(self._format_arg(arg))
# aggregate the keyword arguments
for k,v in kwargs.items():
# we're passing a short arg as a kwarg, example:
# cut(d="\t")
if len(k) == 1:
processed_args.append("-"+k)
if v is not True: processed_args.append(self._format_arg(v))
# we're doing a long arg
else:
k = k.replace("_", "-")
if v is True: processed_args.append("--"+k)
else: processed_args.append("--%s=%s" % (k, self._format_arg(v)))
return processed_args
def bake(self, *args, **kwargs):
fn = Command(self._path)
fn._partial = True
call_args, kwargs = self._extract_call_args(kwargs)
pruned_call_args = call_args
for k,v in Command.call_args.items():
try:
if pruned_call_args[k] == v:
del pruned_call_args[k]
except KeyError: continue
fn._partial_call_args.update(self._partial_call_args)
fn._partial_call_args.update(pruned_call_args)
fn._partial_baked_args.extend(self._partial_baked_args)
fn._partial_baked_args.extend(fn._compile_args(args, kwargs))
return fn
def __str__(self):
if IS_PY3: return self.__unicode__()
else: return unicode(self).encode(DEFAULT_ENCODING)
def __repr__(self):
return str(self)
def __unicode__(self):
baked_args = " ".join(self._partial_baked_args)
if baked_args: baked_args = " " + baked_args
return self._path + baked_args
def __eq__(self, other):
try: return str(self) == str(other)
except: return False
__hash__ = None # Avoid DeprecationWarning in Python < 3
def __enter__(self):
Command._prepend_stack.append([self._path])
def __exit__(self, typ, value, traceback):
Command._prepend_stack.pop()
def __call__(self, *args, **kwargs):
kwargs = kwargs.copy()
args = list(args)
cmd = []
# aggregate any with contexts
for prepend in self._prepend_stack: cmd.extend(prepend)
cmd.append(self._path)
call_args, kwargs = self._extract_call_args(kwargs)
call_args.update(self._partial_call_args)
# here we normalize the ok_code to be something we can do
# "if return_code in call_args["ok_code"]" on
if not isinstance(call_args["ok_code"], (tuple, list)):
call_args["ok_code"] = [call_args["ok_code"]]
# set pipe to None if we're outputting straight to CLI
pipe = None if call_args["fg"] else subp.PIPE
# check if we're piping via composition
input_stream = pipe
input_data = None
if args:
first_arg = args.pop(0)
if isinstance(first_arg, RunningCommand):
# it makes sense that if the input pipe of a command is running
# in the background, then this command should run in the
# background as well
if first_arg.call_args["bg"]:
call_args["bg"] = True
input_stream = first_arg.process.stdout
else:
input_data = first_arg.stdout()
else: args.insert(0, first_arg)
processed_args = self._compile_args(args, kwargs)
# makes sure our arguments are broken up correctly
split_args = self._partial_baked_args + processed_args
final_args = split_args
cmd.extend(final_args)
command_ran = " ".join(cmd)
# with contexts shouldn't run at all yet, they prepend
# to every command in the context
if call_args["with"]:
Command._prepend_stack.append(cmd)
return RunningCommand(command_ran, None, call_args)
# stdin from string
input = call_args["in"]
if input:
input_data = input
# stdout redirection
stdout = pipe
out = call_args["out"]
if out:
if hasattr(out, "write"): stdout = out
else: stdout = open(str(out), "w")
# stderr redirection
stderr = pipe
err = call_args["err"]
if err:
if hasattr(err, "write"): stderr = err
else: stderr = open(str(err), "w")
if call_args["err_to_out"]: stderr = subp.STDOUT
# leave shell=False
process = subp.Popen(cmd, shell=False, env=call_args["env"],
cwd=call_args["cwd"],
stdin=input_stream, stdout=stdout, stderr=stderr)
return RunningCommand(command_ran, process, call_args, input_data)
livestreamer-1.12.2/src/livestreamer/packages/__init__.py 0000644 0001750 0001750 00000000000 12521217321 024537 0 ustar chrippa chrippa 0000000 0000000 livestreamer-1.12.2/src/livestreamer/packages/flashmedia/ 0000755 0001750 0001750 00000000000 12521217500 024534 5 ustar chrippa chrippa 0000000 0000000 livestreamer-1.12.2/src/livestreamer/packages/flashmedia/util.py 0000644 0001750 0001750 00000004253 12521217321 026070 0 ustar chrippa chrippa 0000000 0000000 #!/usr/bin/env python
from .compat import bytes, is_py2, string_types
import struct
def byte(ordinal):
if isinstance(ordinal, string_types):
ordinal = ord(ordinal)
return bytes((ordinal,))
class flagproperty(object):
def __init__(self, flags, attr, boolean=False):
self.flags = flags
self.attr = attr
self.boolean = boolean
def __get__(self, obj, cls):
flags = getattr(obj, self.flags)
val = getattr(flags.bit, self.attr)
if self.boolean:
val = bool(val)
return val
def __set__(self, obj, val):
flags = getattr(obj, self.flags)
setattr(flags.bit, self.attr, int(val))
def lang_to_iso639(lang):
res = [0, 0, 0]
for i in reversed(range(3)):
res[i] = chr(0x60 + (lang & 0x1f))
lang = lang >> 5
return "".join(res)
def iso639_to_lang(iso639):
res = 0
for i in range(3):
c = ord(iso639[i]) - 0x60
res = res << 5
res = res | c
return res
def pack_many_into(buf, offset, types, values):
for packer, value in zip(types, values):
packer.pack_into(buf, offset, value)
offset += packer.size
return offset
def pack_bytes_into(buf, offset, data):
size = len(data)
fmt = str(size) + "s"
struct.pack_into(fmt, buf, offset, data)
return offset + size
def unpack_many_from(buf, offset, types):
rval = tuple()
for unpacker in types:
rval += unpacker.unpack_from(buf, offset)
offset += unpacker.size
return rval
def chunked_read(fd, length, chunk_size=8192, exception=IOError):
chunks = []
data_left = length
while data_left > 0:
try:
data = fd.read(min(8192, data_left))
except IOError as err:
raise exception("Failed to read data: {0}".format(str(err)))
if not data:
raise exception("End of stream before required data could be read")
data_left -= len(data)
chunks.append(data)
return b"".join(chunks)
__all__ = ["byte", "flagproperty", "lang_to_iso639",
"iso639_to_lang", "pack_many_into", "pack_bytes_into",
"unpack_many_from", "chunked_read"]
livestreamer-1.12.2/src/livestreamer/packages/flashmedia/types.py 0000644 0001750 0001750 00000131352 12521217321 026260 0 ustar chrippa chrippa 0000000 0000000 from .compat import OrderedDict, is_py2, str, bytes, integer_types, string_types
from .util import pack_bytes_into
from collections import namedtuple
from struct import Struct, error as struct_error
from inspect import getargspec
(SCRIPT_DATA_TYPE_NUMBER, SCRIPT_DATA_TYPE_BOOLEAN,
SCRIPT_DATA_TYPE_STRING, SCRIPT_DATA_TYPE_OBJECT,
SCRIPT_DATA_TYPE_RESERVED, SCRIPT_DATA_TYPE_NULL,
SCRIPT_DATA_TYPE_UNDEFINED, SCRIPT_DATA_TYPE_REFERENCE,
SCRIPT_DATA_TYPE_ECMAARRAY, SCRIPT_DATA_TYPE_OBJECTEND,
SCRIPT_DATA_TYPE_STRICTARRAY, SCRIPT_DATA_TYPE_DATE,
SCRIPT_DATA_TYPE_LONGSTRING) = range(13)
SCRIPT_DATA_TYPE_AMF3 = 0x11
(AMF3_TYPE_UNDEFINED, AMF3_TYPE_NULL, AMF3_TYPE_FALSE, AMF3_TYPE_TRUE,
AMF3_TYPE_INTEGER, AMF3_TYPE_DOUBLE, AMF3_TYPE_STRING, AMF3_TYPE_XML_DOC,
AMF3_TYPE_DATE, AMF3_TYPE_ARRAY, AMF3_TYPE_OBJECT, AMF3_TYPE_XML,
AMF3_TYPE_BYTE_ARRAY, AMF3_TYPE_VECTOR_INT, AMF3_TYPE_VECTOR_UINT,
AMF3_TYPE_VECTOR_DOUBLE, AMF3_TYPE_VECTOR_OBJECT, AMF3_TYPE_DICT) = range(0x12)
AMF3_EMPTY_STRING = 0x01
AMF3_DYNAMIC_OBJECT = 0x0b
AMF3_CLOSE_DYNAMIC_OBJECT = 0x01
AMF3_CLOSE_DYNAMIC_ARRAY = 0x01
AMF3_MIN_INTEGER = -268435456
AMF3_MAX_INTEGER = 268435455
class PrimitiveType(Struct):
def __call__(self, *args):
return self.pack(*args)
def read(self, fd):
data = fd.read(self.size)
if len(data) != self.size:
raise IOError("Unable to read required amount of data")
return self.unpack(data)[0]
class PrimitiveClassType(PrimitiveType):
def __init__(self, format, cls):
self.cls = cls
PrimitiveType.__init__(self, format)
def pack(self, val):
return PrimitiveType.pack(self, *val)
def pack_into(self, buf, offset, val):
return PrimitiveType.pack_into(self, buf, offset, *val)
def unpack(self, data):
vals = PrimitiveType.unpack(self, data)
rval = self.cls(*vals)
return (rval,)
def unpack_from(self, buf, offset):
vals = PrimitiveType.unpack_from(self, buf, offset)
rval = self.cls(*vals)
return (rval,)
class DynamicType(object):
def __new__(cls, *args, **kwargs):
return cls.pack(*args, **kwargs)
@classmethod
def size(cls, val):
raise NotImplementedError
@classmethod
def pack(cls, val):
raise NotImplementedError
@classmethod
def pack_into(cls, buf, offset, val):
raise NotImplementedError
@classmethod
def read(cls, fd):
raise NotImplementedError
@classmethod
def unpack_from(cls, buf, offset):
raise NotImplementedError
@classmethod
def unpack(cls, buf):
return cls.unpack_from(buf, 0)
class TwosComplement(PrimitiveType):
def __init__(self, primitive):
self.primitive = primitive
bits = self.primitive.size * 8
self.maxval = 1 << bits
self.midval = self.maxval >> 1
self.upper = self.midval - 1
self.lower = -self.midval
@property
def size(self):
return 3
def pack(self, val):
if val < self.lower or val > self.upper:
msg = "{0} format requires {1} <= number <= {2}".format(self.primitive.format,
self.lower, self.upper)
raise struct_error(msg)
if val < 0:
val = val + self.maxval
return self.primitive.pack(val)
def pack_into(self, buf, offset, val):
if val < self.lower or val > self.upper:
msg = "{0} format requires {1} <= number <= {2}".format(self.primitive.format,
self.lower, self.upper)
raise struct_error(msg)
if val < 0:
val = val + self.maxval
return self.primitive.pack_into(buf, offset, val)
def unpack(self, data):
val = self.primitive.unpack(data)[0]
if val & self.midval:
val = val - self.maxval
return (val,)
def unpack_from(self, buf, offset):
val = self.primitive.unpack_from(buf, offset)[0]
if val & self.midval:
val = val - self.maxval
return (val,)
class HighLowCombo(PrimitiveType):
def __init__(self, format, highbits, reverse=True):
PrimitiveType.__init__(self, format)
self.highbits = highbits
self.lowmask = (1 << highbits) - 1
self.reverse = reverse
self.lower = 0
self.upper = (1 << (self.size * 8)) - 1
def pack(self, val):
if val < self.lower or val > self.upper:
msg = "{0} format requires {1} <= number <= {2}".format(self.format,
self.lower, self.upper)
raise struct_error(msg)
if self.reverse:
high = val >> self.highbits
low = val & self.lowmask
else:
high = val & self.lowmask
low = val >> self.highbits
return PrimitiveType.pack(self, high, low)
def pack_into(self, buf, offset, val):
if val < self.lower or val > self.upper:
msg = "{0} format requires {1} <= number <= {2}".format(self.format,
self.lower, self.upper)
raise struct_error(msg)
if self.reverse:
high = val >> self.highbits
low = val & self.lowmask
else:
high = val & self.lowmask
low = val >> self.highbits
return PrimitiveType.pack_into(self, buf, offset, high, low)
def unpack(self, data):
high, low = PrimitiveType.unpack(self, data)
if self.reverse:
ret = high << self.highbits
ret |= low
else:
ret = high
ret |= low << self.highbits
return (ret,)
def unpack_from(self, buf, offset):
high, low = PrimitiveType.unpack_from(self, buf, offset)
if self.reverse:
ret = high << self.highbits
ret |= low
else:
ret = high
ret |= low << self.highbits
return (ret,)
class FixedPoint(PrimitiveType):
def __init__(self, format, bits):
self.divider = float(1 << bits)
PrimitiveType.__init__(self, format)
def pack(self, val):
val *= self.divider
return PrimitiveType.pack(self, int(val))
def pack_into(self, buf, offset, val):
val *= self.divider
return PrimitiveType.pack_into(self, buf, offset, int(val))
def unpack(self, data):
val = PrimitiveType.unpack(self, data)[0]
val /= self.divider
return (val,)
def unpack_from(self, buf, offset):
val = PrimitiveType.unpack_from(self, buf, offset)[0]
val /= self.divider
return (val,)
class PaddedBytes(PrimitiveType):
def __init__(self, size, padding):
self.padded_size = size
self.padding = bytes(padding, "ascii")
@property
def size(self):
return self.padded_size
def pack(self, val):
rval = bytes(val[:self.size], "ascii")
if len(rval) < self.size:
paddinglen = self.size - len(rval)
rval += self.padding * paddinglen
return rval
def pack_into(self, buf, offset, val):
rval = bytes(val[:self.size], "ascii")
offset = pack_bytes_into(buf, offset, rval)
if len(rval) < self.size:
paddinglen = self.size - len(rval)
offset = pack_bytes_into(buf, offset, self.padding * paddinglen)
def unpack(self, data):
return (str(data.rstrip(self.padding), "ascii"),)
def unpack_from(self, buf, offset):
data = buf[offset:offset + self.padded_size]
return (str(data.rstrip(self.padding), "ascii"),)
""" 8-bit integer """
U8 = PrimitiveType("B")
S8 = PrimitiveType("b")
""" 16-bit integer """
U16BE = PrimitiveType(">H")
S16BE = PrimitiveType(">h")
U16LE = PrimitiveType("<H")
S16LE = PrimitiveType("<h")
""" 24-bit integer """
U24BE = HighLowCombo(">HB", 8, True)
S24BE = TwosComplement(U24BE)
U24LE = HighLowCombo("<HB", 16, False)
S24LE = TwosComplement(U24LE)
""" 32-bit integer """
U32BE = PrimitiveType(">I")
S32BE = PrimitiveType(">i")
U32LE = PrimitiveType("<I")
S32LE = PrimitiveType("<i")
""" 64-bit integer """
U64BE = PrimitiveType(">Q")
U64LE = PrimitiveType("<Q")
""" Fixed point numbers """
U8_8BE = FixedPoint(">H", 8)
S8_8BE = FixedPoint(">h", 8)
U16_16BE = FixedPoint("<I", 16)
S16_16BE = FixedPoint("<i", 16)
U8_8LE = FixedPoint("<H", 8)
S8_8LE = FixedPoint("<h", 8)
U16_16LE = FixedPoint("<I", 16)
S16_16LE = FixedPoint("<i", 16)
DoubleLE = PrimitiveType("<d")
DoubleBE = PrimitiveType(">d")
""" Various types """
FourCC = PaddedBytes(4, " ")
""" Script data types """
ScriptDataNumber = DoubleBE
ScriptDataBoolean = PrimitiveType("?")
class U3264(DynamicType):
@classmethod
def size(cls, val, version):
if version == 1:
return U64BE.size
else:
return U32BE.size
@classmethod
def pack(cls, val, version):
if version == 1:
return U64BE(val)
else:
return U32BE(val)
@classmethod
def pack_into(cls, buf, offset, val, version):
if version == 1:
prim = U64BE
else:
prim = U32BE
prim.pack_into(buf, offset, val)
return offset + prim.size
@classmethod
def read(cls, fd, version):
if version == 1:
return U64BE.read(fd)
else:
return U32BE.read(fd)
@classmethod
def unpack_from(cls, buf, offset, version):
if version == 1:
prim = U64BE
else:
prim = U32BE
rval = prim.unpack_from(buf, offset)
offset += prim.size
return (rval, offset)
class String(DynamicType):
@classmethod
def size(cls, *args, **kwargs):
return len(cls.pack(*args, **kwargs))
@classmethod
def pack(cls, val, encoding="utf8", errors="ignore"):
rval = val.encode(encoding, errors)
return rval
@classmethod
def pack_into(cls, buf, offset, val,
encoding="utf8", errors="ignore"):
return pack_bytes_into(buf, offset,
val.encode(encoding, errors))
class CString(String):
EndMarker = b"\x00"
@classmethod
def pack(cls, *args, **kwargs):
rval = String.pack(*args, **kwargs)
rval += CString.EndMarker
return rval
@classmethod
def pack_into(cls, buf, offset, *args, **kwargs):
offset = String.pack_into(buf, offset, *args, **kwargs)
U8.pack_into(buf, offset, 0)
return offset + 1
@classmethod
def read(cls, fd, encoding="utf8", errors="ignore"):
rval = b""
while True:
ch = fd.read(1)
if len(ch) == 0 or ch == CString.EndMarker:
break
rval += ch
return rval.decode(encoding, errors)
@classmethod
def unpack_from(cls, buf, offset, encoding="utf8", errors="ignore"):
end = buf[offset:].find(b"\x00")
rval = buf[offset:offset + end].decode(encoding, errors)
offset += end + 1
return (rval, offset)
class ScriptDataType(object):
__identifier__ = 0
class ScriptDataString(String):
__size_primitive__ = U16BE
@classmethod
def pack(cls, val, *args, **kwargs):
rval = String.pack(val, *args, **kwargs)
size = cls.__size_primitive__(len(rval))
return size + rval
@classmethod
def pack_into(cls, buf, offset, val, *args, **kwargs):
noffset = String.pack_into(buf, offset + cls.__size_primitive__.size,
val, *args, **kwargs)
cls.__size_primitive__.pack_into(buf, offset,
(noffset - offset) - cls.__size_primitive__.size)
return noffset
@classmethod
def read(cls, fd, encoding="utf8", errors="ignore"):
size = cls.__size_primitive__.read(fd)
data = fd.read(size)
return data.decode(encoding, errors)
@classmethod
def unpack_from(cls, buf, offset, encoding="utf8", errors="ignore"):
size = cls.__size_primitive__.unpack_from(buf, offset)[0]
offset += cls.__size_primitive__.size
data = buf[offset:offset + size].decode(encoding, errors)
offset += size
return (data, offset)
class ScriptDataLongString(ScriptDataString):
__size_primitive__ = U32BE
class ScriptDataObjectEnd(Exception):
pass
class ScriptDataObject(OrderedDict, ScriptDataType):
__identifier__ = SCRIPT_DATA_TYPE_OBJECT
@classmethod
def size(cls, val):
size = 3
for key, value in val.items():
size += ScriptDataString.size(key)
size += ScriptDataValue.size(value)
return size
@classmethod
def pack(cls, val):
rval = b""
for key, value in val.items():
rval += ScriptDataString(key)
rval += ScriptDataValue.pack(value)
# Zero length key + object end identifier ends object
rval += ScriptDataString("")
rval += U8(SCRIPT_DATA_TYPE_OBJECTEND)
return rval
@classmethod
def pack_into(cls, buf, offset, val):
for key, value in val.items():
offset = ScriptDataString.pack_into(buf, offset, key)
offset = ScriptDataValue.pack_into(buf, offset, value)
# Zero length key + object end identifier ends object
offset = ScriptDataString.pack_into(buf, offset, "")
U8.pack_into(buf, offset, SCRIPT_DATA_TYPE_OBJECTEND)
return offset + U8.size
@classmethod
def read(cls, fd):
rval = cls()
while True:
try:
key = ScriptDataString.read(fd)
value = ScriptDataValue.read(fd)
except ScriptDataObjectEnd:
break
if len(key) == 0:
break
rval[key] = value
return rval
@classmethod
def unpack_from(cls, buf, offset):
rval = cls()
while True:
try:
key, offset = ScriptDataString.unpack_from(buf, offset)
value, offset = ScriptDataValue.unpack_from(buf, offset)
except ScriptDataObjectEnd:
offset += 1
break
if len(key) == 0:
break
rval[key] = value
return (rval, offset)
class ScriptDataECMAArray(ScriptDataObject):
__identifier__ = SCRIPT_DATA_TYPE_ECMAARRAY
@classmethod
def size(cls, val):
return 4 + ScriptDataObject.size(val)
@classmethod
def pack(cls, val):
rval = U32BE(len(val))
rval += ScriptDataObject.pack(val)
return rval
@classmethod
def pack_into(cls, buf, offset, val):
U32BE.pack_into(buf, offset, len(val))
return ScriptDataObject.pack_into(buf, offset + U32BE.size,
val)
@classmethod
def read(cls, fd):
U32BE.read(fd) # Length
val = ScriptDataObject.read(fd)
return cls(val)
@classmethod
def unpack_from(cls, buf, offset):
U32BE.unpack_from(buf, offset) # Length
offset += U32BE.size
val, offset = ScriptDataObject.unpack_from(buf, offset)
return (cls(val), offset)
class ScriptDataStrictArray(DynamicType):
@classmethod
def size(cls, val):
size = 4
for sdval in val:
size += ScriptDataValue.size(sdval)
return size
@classmethod
def pack(cls, val):
rval = U32BE(len(val))
for sdval in val:
rval += ScriptDataValue.pack(sdval)
return rval
@classmethod
def pack_into(cls, buf, offset, val):
U32BE.pack_into(buf, offset, len(val))
offset += U32BE.size
for sdval in val:
offset = ScriptDataValue.pack_into(buf, offset, sdval)
return offset
@classmethod
def read(cls, fd):
length = U32BE.read(fd)
rval = []
for i in range(length):
val = ScriptDataValue.read(fd)
rval.append(val)
return rval
@classmethod
def unpack_from(cls, buf, offset):
length = U32BE.unpack_from(buf, offset)[0]
offset += U32BE.size
rval = []
for i in range(length):
val, offset = ScriptDataValue.unpack_from(buf, offset)
rval.append(val)
return (rval, offset)
ScriptDataDate = namedtuple("ScriptDataDate", ["timestamp", "offset"])
ScriptDataDateStruct = PrimitiveClassType(">dh", ScriptDataDate)
ScriptDataDate.__identifier__ = SCRIPT_DATA_TYPE_DATE
ScriptDataDate.__packer__ = ScriptDataDateStruct
ScriptDataReference = namedtuple("ScriptDataReference", ["reference"])
ScriptDataReferenceStruct = PrimitiveClassType(">H", ScriptDataReference)
ScriptDataReference.__identifier__ = SCRIPT_DATA_TYPE_REFERENCE
ScriptDataReference.__packer__ = ScriptDataReferenceStruct
class ScriptDataValue(DynamicType, ScriptDataType):
# key: identifier, value: unpacker class
PrimitiveReaders = {
SCRIPT_DATA_TYPE_NUMBER: ScriptDataNumber,
SCRIPT_DATA_TYPE_BOOLEAN: ScriptDataBoolean,
SCRIPT_DATA_TYPE_REFERENCE: ScriptDataReferenceStruct,
SCRIPT_DATA_TYPE_DATE: ScriptDataDateStruct,
}
DynamicReaders = {
SCRIPT_DATA_TYPE_STRING: ScriptDataString,
SCRIPT_DATA_TYPE_LONGSTRING: ScriptDataLongString,
SCRIPT_DATA_TYPE_OBJECT: ScriptDataObject,
SCRIPT_DATA_TYPE_ECMAARRAY: ScriptDataECMAArray,
SCRIPT_DATA_TYPE_STRICTARRAY: ScriptDataStrictArray,
}
Readers = PrimitiveReaders.copy()
Readers.update(DynamicReaders)
@classmethod
def size(cls, val):
size = 1
if isinstance(val, bool):
size += ScriptDataBoolean.size
elif isinstance(val, (int, float)):
size += ScriptDataNumber.size
elif isinstance(val, list):
size += ScriptDataStrictArray.size(val)
elif isinstance(val, string_types):
if len(val) > 0xFFFF:
size += ScriptDataLongString.size(val)
else:
size += ScriptDataString.size(val)
elif isinstance(val, ScriptDataType):
cls = type(val)
size += cls.size(val)
elif type(val) in (ScriptDataDate, ScriptDataReference):
cls = type(val)
packer = cls.__packer__
size += packer.size
elif isinstance(val, AMF3ObjectBase):
size += U8.size
size += AMF3Value.size(val)
return size
@classmethod
def pack(cls, val):
rval = b""
if isinstance(val, bool):
rval += U8(SCRIPT_DATA_TYPE_BOOLEAN)
rval += ScriptDataBoolean(val)
elif isinstance(val, (int, float)):
rval += U8(SCRIPT_DATA_TYPE_NUMBER)
rval += ScriptDataNumber(val)
elif isinstance(val, list):
rval += U8(SCRIPT_DATA_TYPE_STRICTARRAY)
rval += ScriptDataStrictArray(val)
elif isinstance(val, string_types):
if len(val) > 0xFFFF:
rval += U8(SCRIPT_DATA_TYPE_LONGSTRING)
rval += ScriptDataLongString(val)
else:
rval += U8(SCRIPT_DATA_TYPE_STRING)
rval += ScriptDataString(val)
elif val is None:
rval += U8(SCRIPT_DATA_TYPE_NULL)
elif isinstance(val, ScriptDataType):
cls = type(val)
rval += U8(cls.__identifier__)
rval += cls.pack(val)
elif type(val) in (ScriptDataDate, ScriptDataReference):
cls = type(val)
packer = cls.__packer__
rval += U8(cls.__identifier__)
rval += packer.pack(val)
elif isinstance(val, AMF3ObjectBase):
rval += U8(SCRIPT_DATA_TYPE_AMF3)
rval += AMF3Value.pack(val)
else:
raise ValueError("Unable to pack value of type {0}".format(type(val)))
return rval
@classmethod
def pack_into(cls, buf, offset, val):
if isinstance(val, bool):
U8.pack_into(buf, offset, SCRIPT_DATA_TYPE_BOOLEAN)
offset += U8.size
ScriptDataBoolean.pack_into(buf, offset, val)
offset += ScriptDataBoolean.size
elif isinstance(val, (int, float)):
U8.pack_into(buf, offset, SCRIPT_DATA_TYPE_NUMBER)
offset += U8.size
ScriptDataNumber.pack_into(buf, offset, val)
offset += ScriptDataNumber.size
elif isinstance(val, list):
U8.pack_into(buf, offset, SCRIPT_DATA_TYPE_STRICTARRAY)
offset += U8.size
offset = ScriptDataStrictArray.pack_into(buf, offset, val)
elif isinstance(val, string_types):
if len(val) > 0xFFFF:
U8.pack_into(buf, offset, SCRIPT_DATA_TYPE_LONGSTRING)
offset += U8.size
offset = ScriptDataLongString.pack_into(buf, offset, val)
else:
U8.pack_into(buf, offset, SCRIPT_DATA_TYPE_STRING)
offset += U8.size
offset = ScriptDataString.pack_into(buf, offset, val)
elif val is None:
U8.pack_into(buf, offset, SCRIPT_DATA_TYPE_NULL)
elif isinstance(val, ScriptDataType):
cls = type(val)
U8.pack_into(buf, offset, cls.__identifier__)
offset += U8.size
offset = cls.pack_into(buf, offset, val)
elif type(val) in (ScriptDataDate, ScriptDataReference):
cls = type(val)
packer = cls.__packer__
U8.pack_into(buf, offset, cls.__identifier__)
offset += U8.size
packer.pack_into(buf, offset, val)
offset += packer.size
else:
raise ValueError("Unable to pack value of type {0}".format(type(val)))
return offset
@classmethod
def read(cls, fd, marker=None):
if marker is None:
type_ = U8.read(fd)
else:
type_ = marker
if type_ == SCRIPT_DATA_TYPE_AMF3:
return AMF3Value.read(fd)
elif type_ in ScriptDataValue.Readers:
return ScriptDataValue.Readers[type_].read(fd)
elif type_ == SCRIPT_DATA_TYPE_OBJECTEND:
raise ScriptDataObjectEnd
elif (type_ == SCRIPT_DATA_TYPE_NULL or
type_ == SCRIPT_DATA_TYPE_UNDEFINED):
return None
else:
raise IOError("Unhandled script data type: {0}".format(type_))
@classmethod
def unpack_from(cls, buf, offset):
type_ = U8.unpack_from(buf, offset)[0]
offset += U8.size
if type_ in ScriptDataValue.DynamicReaders:
return ScriptDataValue.Readers[type_].unpack_from(buf, offset)
elif type_ in ScriptDataValue.PrimitiveReaders:
reader = ScriptDataValue.PrimitiveReaders[type_]
rval = reader.unpack_from(buf, offset)[0]
offset += reader.size
return (rval, offset)
elif type_ == SCRIPT_DATA_TYPE_OBJECTEND:
raise ScriptDataObjectEnd
elif (type_ == SCRIPT_DATA_TYPE_NULL or
type_ == SCRIPT_DATA_TYPE_UNDEFINED):
return (None, offset)
else:
raise IOError("Unhandled script data type: {0}".format(hex(type_)))
class AMF0Value(ScriptDataValue):
pass
class AMF0String(ScriptDataString):
pass
AMF0Number = ScriptDataNumber
AMF3Double = ScriptDataNumber
class AMF3Type(ScriptDataType):
pass
class AMF3Integer(DynamicType, AMF3Type):
__identifier__ = AMF3_TYPE_INTEGER
@classmethod
def size(cls, val):
val &= 0x1fffffff
if val < 0x80:
return 1
elif val < 0x4000:
return 2
elif val < 0x200000:
return 3
elif val < 0x40000000:
return 4
@classmethod
def pack(cls, val):
size = cls.size(val)
buf = bytearray(size)
offset = cls.pack_into(buf, 0, val)
return bytes(buf[:offset])
@classmethod
def pack_into(cls, buf, offset, val):
val &= 0x1fffffff
if val < 0x80:
buf[offset] = val
offset += 1
elif val < 0x4000:
buf[offset] = (val >> 7 & 0x7f) | 0x80
buf[offset+1] = val & 0x7f
offset += 2
elif val < 0x200000:
buf[offset] = (val >> 14 & 0x7f) | 0x80
buf[offset+1] = (val >> 7 & 0x7f) | 0x80
buf[offset+2] = val & 0x7f
offset += 3
elif val < 0x40000000:
buf[offset] = (val >> 22 & 0x7f) | 0x80
buf[offset+1] = (val >> 15 & 0x7f) | 0x80
buf[offset+2] = (val >> 8 & 0x7f) | 0x80
buf[offset+3] = val & 0xff
offset += 4
return offset
@classmethod
def read(cls, fd):
rval, byte_count = 0, 0
byte = U8.read(fd)
while (byte & 0x80) != 0 and byte_count < 3:
rval <<= 7
rval |= byte & 0x7f
byte = U8.read(fd)
byte_count += 1
if byte_count < 3:
rval <<= 7
rval |= byte & 0x7F
else:
rval <<= 8
rval |= byte & 0xff
if (rval & 0x10000000) != 0:
rval -= 0x20000000
return rval
class AMF3String(String):
@classmethod
def size(cls, val, cache):
data = String.pack(val, "utf8", "ignore")
size = len(data)
if size == 0:
return U8.size
elif val in cache:
index = cache.index(val)
return AMF3Integer.size(index << 1)
else:
cache.append(val)
return AMF3Integer.size(size << 1 | 1) + size
@classmethod
def pack(cls, val, cache):
data = String.pack(val, "utf8", "ignore")
size = len(data)
if size == 0:
return U8(AMF3_EMPTY_STRING)
elif val in cache:
index = cache.index(val)
return AMF3Integer(index << 1)
else:
cache.append(val)
chunks = []
chunks.append(AMF3Integer(size << 1 | 1))
chunks.append(data)
return b"".join(chunks)
@classmethod
def read(cls, fd, cache):
header = AMF3Integer.read(fd)
if (header & 1) == 0:
index = header >> 1
return cache[index]
else:
size = header >> 1
data = fd.read(size)
rval = data.decode("utf8", "ignore")
if len(data) > 0:
cache.append(rval)
return rval
class AMF3ObjectBase(object):
__dynamic__ = False
__externalizable__ = False
__members__ = []
_registry = {}
def __init__(self, *args, **kwargs):
for key, value in kwargs.items():
setattr(self, key, value)
def __repr__(self):
return "<{0} {1!r}".format(self.__class__.__name__, self.__dict__)
@classmethod
def register(cls, name):
def deco(amfcls):
amfcls.__name__ = name
if not amfcls.__members__:
amfcls.__members__ = getargspec(amfcls.__init__).args[1:]
cls._registry[name] = amfcls
return amfcls
return deco
@classmethod
def lookup(cls, name):
return cls._registry.get(name, None)
@classmethod
def create(cls, name, externalizable, dynamic, members):
if is_py2:
name = name.encode("utf8")
amfcls = type(name, (cls,), {})
amfcls.__externalizable__ = externalizable
amfcls.__members__ = members
return amfcls
class AMF3Object(OrderedDict, AMF3ObjectBase):
__dynamic__ = True
class AMF3ObjectPacker(DynamicType, AMF3Type):
__identifier__ = AMF3_TYPE_OBJECT
@classmethod
def size(cls, val, str_cache, object_cache, traits_cache):
if val in object_cache:
index = object_cache.index(val)
return AMF3Integer.size(index << 1)
else:
object_cache.append(val)
size = 0
traits = type(val)
if traits in traits_cache:
index = traits_cache.index(traits)
size += AMF3Integer.size(index << 2 | 0x01)
else:
header = 0x03
if traits.__dynamic__:
header |= 0x02 << 2
if traits.__externalizable__:
header |= 0x01 << 2
header |= (len(traits.__members__)) << 4
size += AMF3Integer.size(header)
if isinstance(val, AMF3Object):
size += U8.size
else:
size += AMF3String.size(traits.__name__, cache=str_cache)
traits_cache.append(traits)
for member in traits.__members__:
size += AMF3String.size(member, cache=str_cache)
for member in traits.__members__:
value = getattr(val, member)
size += AMF3Value.size(value, str_cache=str_cache,
object_cache=object_cache,
traits_cache=traits_cache)
if traits.__dynamic__:
if isinstance(val, AMF3Object):
iterator = val.items()
else:
iterator = val.__dict__.items()
for key, value in iterator:
if key in traits.__members__:
continue
size += AMF3String.size(key, cache=str_cache)
size += AMF3Value.size(value, str_cache=str_cache,
object_cache=object_cache,
traits_cache=traits_cache)
size += U8.size
return size
@classmethod
def pack(cls, val, str_cache, object_cache, traits_cache):
chunks = []
if val in object_cache:
index = object_cache.index(val)
return AMF3Integer(index << 1)
else:
object_cache.append(val)
chunks = []
traits = type(val)
if traits in traits_cache:
index = traits_cache.index(traits)
chunks.append(AMF3Integer(index << 2 | 0x01))
else:
header = 0x03
if traits.__dynamic__:
header |= 0x02 << 2
if traits.__externalizable__:
header |= 0x01 << 2
header |= (len(traits.__members__)) << 4
chunks.append(AMF3Integer(header))
if isinstance(val, AMF3Object):
chunks.append(U8(AMF3_EMPTY_STRING))
else:
chunks.append(AMF3String(traits.__name__, cache=str_cache))
traits_cache.append(traits)
for member in traits.__members__:
chunks.append(AMF3String(member, cache=str_cache))
for member in traits.__members__:
value = getattr(val, member)
value = AMF3Value.pack(value, str_cache=str_cache,
object_cache=object_cache,
traits_cache=traits_cache)
chunks.append(value)
if traits.__dynamic__:
if isinstance(val, AMF3Object):
iterator = val.items()
else:
iterator = val.__dict__.items()
for key, value in iterator:
if key in traits.__members__:
continue
key = AMF3String(key, cache=str_cache)
value = AMF3Value.pack(value, str_cache=str_cache,
object_cache=object_cache,
traits_cache=traits_cache)
chunks.append(key)
chunks.append(value)
# Empty string is end of dynamic values
chunks.append(U8(AMF3_CLOSE_DYNAMIC_ARRAY))
return b"".join(chunks)
@classmethod
def read(cls, fd, str_cache, object_cache, traits_cache):
header = AMF3Integer.read(fd)
obj = None
if (header & 1) == 0:
index = header >> 1
obj = object_cache[index]
else:
header >>= 1
if (header & 1) == 0:
index = header >> 1
traits = traits_cache[index]
else:
externalizable = (header & 2) != 0
dynamic = (header & 4) != 0
members_len = header >> 3
class_name = AMF3String.read(fd, cache=str_cache)
members = []
for i in range(members_len):
member_name = AMF3String.read(fd, cache=str_cache)
members.append(member_name)
if len(class_name) == 0:
traits = AMF3Object
elif AMF3ObjectBase.lookup(class_name):
traits = AMF3ObjectBase.lookup(class_name)
traits.__members__ = members
traits.__dynamic__ = dynamic
traits_cache.append(traits)
else:
traits = AMF3ObjectBase.create(class_name, externalizable,
dynamic, members)
traits_cache.append(traits)
values = OrderedDict()
for member in traits.__members__:
value = AMF3Value.read(fd, str_cache=str_cache,
object_cache=object_cache,
traits_cache=traits_cache)
values[member] = value
if traits.__dynamic__:
key = AMF3String.read(fd, cache=str_cache)
while len(key) > 0:
value = AMF3Value.read(fd, str_cache=str_cache,
object_cache=object_cache,
traits_cache=traits_cache)
values[key] = value
key = AMF3String.read(fd, cache=str_cache)
if traits == AMF3Object:
obj = traits(values)
else:
obj = traits(**values)
return obj
class AMF3Array(OrderedDict):
def __init__(self, *args, **kwargs):
if args and isinstance(args[0], list):
OrderedDict.__init__(self, **kwargs)
for i, value in enumerate(args[0]):
self[i] = value
else:
OrderedDict.__init__(self, *args, **kwargs)
def dense_keys(self):
dense_keys = []
for i in range(len(self)):
if i in self:
dense_keys.append(i)
return dense_keys
def dense_values(self):
for key in self.dense_keys():
yield self[key]
class AMF3ArrayPacker(DynamicType, AMF3Type):
__identifier__ = AMF3_TYPE_ARRAY
@classmethod
def size(cls, val, str_cache, object_cache, traits_cache):
if val in object_cache:
index = object_cache.index(val)
return AMF3Integer.size(index << 1)
else:
object_cache.append(val)
size = 0
if isinstance(val, AMF3Array):
dense_keys = val.dense_keys()
length = len(dense_keys)
else:
length = len(val)
dense_keys = list(range(length))
header = length << 1 | 1
size += AMF3Integer.size(header)
if isinstance(val, AMF3Array):
for key, value in val.items():
if key in dense_keys:
continue
size += AMF3String.size(key, cache=str_cache)
size += AMF3Value.size(value, str_cache=str_cache,
object_cache=object_cache,
traits_cache=traits_cache)
size += U8.size
for key in dense_keys:
value = val[key]
size += AMF3Value.size(value, str_cache=str_cache,
object_cache=object_cache,
traits_cache=traits_cache)
return size
@classmethod
def pack(cls, val, str_cache, object_cache, traits_cache):
if val in object_cache:
index = object_cache.index(val)
return AMF3Integer(index << 1)
else:
object_cache.append(val)
chunks = []
if isinstance(val, AMF3Array):
dense_keys = val.dense_keys()
length = len(dense_keys)
else:
length = len(val)
dense_keys = list(range(length))
header = length << 1 | 1
chunks.append(AMF3Integer(header))
if isinstance(val, AMF3Array):
for key, value in val.items():
if key in dense_keys:
continue
chunks.append(AMF3String(key, cache=str_cache))
value = AMF3Value.pack(value, str_cache=str_cache,
object_cache=object_cache,
traits_cache=traits_cache)
chunks.append(value)
# Empty string is end of dynamic values
chunks.append(U8(AMF3_CLOSE_DYNAMIC_ARRAY))
for key in dense_keys:
value = val[key]
value = AMF3Value.pack(value, str_cache=str_cache,
object_cache=object_cache,
traits_cache=traits_cache)
chunks.append(value)
return b"".join(chunks)
@classmethod
def read(cls, fd, str_cache, object_cache, traits_cache):
header = AMF3Integer.read(fd)
obj = None
if (header & 1) == 0:
index = header >> 1
obj = object_cache[index]
else:
header >>= 1
obj = AMF3Array()
object_cache.append(obj)
key = AMF3String.read(fd, cache=str_cache)
while len(key) > 0:
value = AMF3Value.read(fd, str_cache=str_cache,
object_cache=object_cache,
traits_cache=traits_cache)
obj[key] = value
key = AMF3String.read(fd, cache=str_cache)
for i in range(header):
value = AMF3Value.read(fd, str_cache=str_cache,
object_cache=object_cache,
traits_cache=traits_cache)
obj[i] = value
return obj
class AMF3Date(object):
def __init__(self, time):
self.time = time
class AMF3DatePacker(DynamicType, AMF3Type):
__identifier__ = AMF3_TYPE_ARRAY
@classmethod
def size(cls, val, cache):
if val in cache:
index = cache.index(val)
return AMF3Integer.size(index << 1)
else:
cache.append(val)
return AMF3Double.size + U8.size
@classmethod
def pack(cls, val, cache):
if val in cache:
index = cache.index(val)
return AMF3Integer(index << 1)
else:
cache.append(val)
chunks = [U8(AMF3_TYPE_NULL),
AMF3Double(val.time)]
return b"".join(chunks)
@classmethod
def read(cls, fd, cache):
header = AMF3Integer.read(fd)
if (header & 1) == 0:
index = header >> 1
return cache[index]
else:
time = AMF3Double.read(fd)
date = AMF3Date(time)
cache.append(date)
return date
class AMF3Value(DynamicType):
PrimitiveReaders = {
AMF3_TYPE_DOUBLE: AMF3Double,
}
DynamicReaders = {
AMF3_TYPE_INTEGER: AMF3Integer,
}
Readers = PrimitiveReaders.copy()
Readers.update(DynamicReaders)
@classmethod
def size(cls, val, str_cache=None, object_cache=None, traits_cache=None):
if str_cache is None:
str_cache = []
if object_cache is None:
object_cache = []
if traits_cache is None:
traits_cache = []
size = U8.size
if isinstance(val, bool) and val in (False, True):
pass
elif val is None:
pass
elif isinstance(val, integer_types):
if val < AMF3_MIN_INTEGER or val > AMF3_MAX_INTEGER:
size += AMF3Double.size
else:
size += AMF3Integer.size(val)
elif isinstance(val, float):
size += AMF3Double.size
elif isinstance(val, (AMF3Array, list)):
size += AMF3ArrayPacker.size(val, str_cache=str_cache,
object_cache=object_cache,
traits_cache=traits_cache)
elif isinstance(val, string_types):
size += AMF3String.size(val, cache=str_cache)
elif isinstance(val, AMF3ObjectBase):
size += AMF3ObjectPacker.size(val, str_cache=str_cache,
object_cache=object_cache,
traits_cache=traits_cache)
elif isinstance(val, AMF3Date):
size += AMF3DatePacker.size(val, cache=object_cache)
else:
raise ValueError("Unable to pack value of type {0}".format(type(val)))
return size
@classmethod
def pack(cls, val, str_cache=None, object_cache=None, traits_cache=None):
if str_cache is None:
str_cache = []
if object_cache is None:
object_cache = []
if traits_cache is None:
traits_cache = []
chunks = []
if isinstance(val, bool):
if val is False:
chunks.append(U8(AMF3_TYPE_FALSE))
elif val is True:
chunks.append(U8(AMF3_TYPE_TRUE))
elif val is None:
chunks.append(U8(AMF3_TYPE_NULL))
elif isinstance(val, integer_types):
if val < AMF3_MIN_INTEGER or val > AMF3_MAX_INTEGER:
chunks.append(U8(AMF3_TYPE_DOUBLE))
chunks.append(AMF3Double(val))
else:
chunks.append(U8(AMF3_TYPE_INTEGER))
chunks.append(AMF3Integer(val))
elif isinstance(val, float):
chunks.append(U8(AMF3_TYPE_DOUBLE))
chunks.append(AMF3Double(val))
elif isinstance(val, (AMF3Array, list)):
chunks.append(U8(AMF3_TYPE_ARRAY))
chunks.append(AMF3ArrayPacker.pack(val, str_cache=str_cache,
object_cache=object_cache,
traits_cache=traits_cache))
elif isinstance(val, string_types):
chunks.append(U8(AMF3_TYPE_STRING))
chunks.append(AMF3String.pack(val, cache=str_cache))
elif isinstance(val, AMF3ObjectBase):
chunks.append(U8(AMF3_TYPE_OBJECT))
chunks.append(AMF3ObjectPacker.pack(val, str_cache=str_cache,
object_cache=object_cache,
traits_cache=traits_cache))
elif isinstance(val, AMF3Date):
chunks.append(U8(AMF3_TYPE_DATE))
chunks.append(AMF3DatePacker.pack(val, cache=object_cache))
else:
raise ValueError("Unable to pack value of type {0}".format(type(val)))
return b"".join(chunks)
@classmethod
def read(cls, fd, str_cache=None, object_cache=None, traits_cache=None):
type_ = U8.read(fd)
if str_cache is None:
str_cache = []
if object_cache is None:
object_cache = []
if traits_cache is None:
traits_cache = []
if type_ == AMF3_TYPE_UNDEFINED or type_ == AMF3_TYPE_NULL:
return None
elif type_ == AMF3_TYPE_FALSE:
return False
elif type_ == AMF3_TYPE_TRUE:
return True
elif type_ == AMF3_TYPE_STRING:
return AMF3String.read(fd, cache=str_cache)
elif type_ == AMF3_TYPE_ARRAY:
return AMF3ArrayPacker.read(fd, str_cache=str_cache,
object_cache=object_cache,
traits_cache=traits_cache)
elif type_ == AMF3_TYPE_OBJECT:
return AMF3ObjectPacker.read(fd, str_cache=str_cache, object_cache=object_cache,
traits_cache=traits_cache)
elif type_ == AMF3_TYPE_DATE:
return AMF3DatePacker.read(fd, cache=object_cache)
elif type_ in cls.Readers:
return cls.Readers[type_].read(fd)
else:
raise IOError("Unhandled AMF3 type: {0}".format(hex(type_)))
livestreamer-1.12.2/src/livestreamer/packages/flashmedia/tag.py 0000644 0001750 0001750 00000047427 12521217321 025700 0 ustar chrippa chrippa 0000000 0000000 #!/usr/bin/env python
from ctypes import BigEndianStructure, Union, c_uint8
from io import BytesIO
from .compat import *
from .error import *
from .packet import *
from .types import *
from .util import *
TAG_TYPE_AUDIO = 8
TAG_TYPE_VIDEO = 9
TAG_TYPE_SCRIPT = 18
AUDIO_CODEC_ID_PCM = 0
AUDIO_CODEC_ID_ADPCM = 1
AUDIO_CODEC_ID_MP3 = 2
AUDIO_CODEC_ID_PCM_LE = 3
AUDIO_CODEC_ID_NELLYMOSSER_16 = 4
AUDIO_CODEC_ID_NELLYMOSSER_8 = 5
AUDIO_CODEC_ID_NELLYMOSSER = 6
AUDIO_CODEC_ID_G711_A = 7
AUDIO_CODEC_ID_G711_MU = 8
AUDIO_CODEC_ID_AAC = 10
AUDIO_CODEC_ID_SPEEX = 11
AUDIO_CODEC_ID_MP3_8 = 14
AUDIO_CODEC_ID_DEVICE = 15
AUDIO_RATE_5_5_KHZ = 0
AUDIO_RATE_11_KHZ = 1
AUDIO_RATE_22_KHZ = 2
AUDIO_RATE_44_KHZ = 3
AUDIO_BIT_RATE_8 = 0
AUDIO_BIT_RATE_16 = 1
AUDIO_TYPE_MONO = 0
AUDIO_TYPE_STEREO = 1
AAC_PACKET_TYPE_SEQUENCE_HEADER = 0
AAC_PACKET_TYPE_RAW = 1
VIDEO_FRAME_TYPE_KEY_FRAME = 1
VIDEO_FRAME_TYPE_INTER_FRAME = 2
VIDEO_FRAME_TYPE_DIS_INTER_FRAME = 3
VIDEO_FRAME_TYPE_GEN_KEY_FRAME = 4
VIDEO_FRAME_TYPE_COMMAND_FRAME = 5
VIDEO_CODEC_ID_H263 = 2
VIDEO_CODEC_ID_SCREEN_VIDEO = 3
VIDEO_CODEC_ID_VP6 = 4
VIDEO_CODEC_ID_VP6A = 5
VIDEO_CODEC_ID_SCREEN_VIDEO_2 = 6
VIDEO_CODEC_ID_AVC = 7
AVC_PACKET_TYPE_SEQUENCE_HEADER = 0
AVC_PACKET_TYPE_NALU = 1
AVC_PACKET_TYPE_END_OF_SEQUENCE = 2
class TypeFlags(Union):
class Bits(BigEndianStructure):
_fields_ = [("rsv1", c_uint8, 5),
("audio", c_uint8, 1),
("rsv2", c_uint8, 1),
("video", c_uint8, 1)]
_fields_ = [("bit", Bits), ("byte", c_uint8)]
class TagFlags(Union):
class Bits(BigEndianStructure):
_fields_ = [("rsv", c_uint8, 2),
("filter", c_uint8, 1),
("type", c_uint8, 5)]
_fields_ = [("bit", Bits), ("byte", c_uint8)]
class AudioFlags(Union):
class Bits(BigEndianStructure):
_fields_ = [("codec", c_uint8, 4),
("rate", c_uint8, 2),
("bits", c_uint8, 1),
("type", c_uint8, 1)]
_fields_ = [("bit", Bits), ("byte", c_uint8)]
class VideoFlags(Union):
class Bits(BigEndianStructure):
_fields_ = [("type", c_uint8, 4),
("codec", c_uint8, 4)]
_fields_ = [("bit", Bits), ("byte", c_uint8)]
class Header(Packet):
exception = FLVError
def __init__(self, version=1, has_audio=False, has_video=False, data_offset=9, tag0_size=0):
self.version = version
self.flags = TypeFlags()
self.flags.bit.audio = int(has_audio)
self.flags.bit.video = int(has_video)
self.data_offset = data_offset
self.tag0_size = tag0_size
def __repr__(self):
reprformat = "<Header version={version} has_audio={has_audio} has_video={has_video} data_offset={offset}>"
return reprformat.format(version=self.version, offset=self.data_offset,
has_audio=self.has_audio, has_video=self.has_video)
@property
def size(self):
return 13
has_audio = flagproperty("flags", "audio", True)
has_video = flagproperty("flags", "video", True)
@classmethod
def _deserialize(cls, io):
head = io.read(3)
if head != b"FLV":
raise FLVError("Invalid FLV header")
version = U8.read(io)
flags = TypeFlags()
flags.byte = U8.read(io)
offset = U32BE.read(io)
tag0_size = U32BE.read(io)
return Header(version, bool(flags.bit.audio), bool(flags.bit.video),
offset, tag0_size)
@classmethod
def _deserialize_from(cls, buf, offset):
head = buf[offset:offset + 3]
offset += 3
if head != b"FLV":
raise FLVError("Invalid FLV header")
flags = TypeFlags()
(version, flags.byte, tag0_offset,
tag0_size) = unpack_many_from(buf, offset, (U8, U8, U32BE, U32BE))
rval = Header(version, bool(flags.bit.audio), bool(flags.bit.video),
tag0_offset, tag0_size)
offset += 10
return (rval, offset)
def _serialize(self, packet):
packet += b"FLV"
packet += U8(self.version)
packet += U8(self.flags.byte)
packet += U32BE(self.data_offset)
packet += U32BE(self.tag0_size)
def _serialize_into(self, packet, offset):
offset = pack_bytes_into(packet, offset, b"FLV")
offset = pack_many_into(packet, offset,
(U8, U8, U32BE, U32BE),
(self.version, self.flags.byte,
self.data_offset, self.tag0_size))
return offset
class Tag(Packet):
exception = FLVError
def __init__(self, typ=TAG_TYPE_SCRIPT, timestamp=0, data=None,
streamid=0, filter=False, padding=None):
self.flags = TagFlags()
self.flags.bit.rsv = 0
self.flags.bit.type = typ
self.flags.bit.filter = int(filter)
if not data:
data = RawData()
if not padding:
padding = b""
self.data = data
self.streamid = streamid
self.timestamp = timestamp
self.padding = padding
def __repr__(self):
reprformat = "<Tag type={type} timestamp={timestamp} streamid={streamid} filter={filter} data={data}>"
return reprformat.format(type=self.type, timestamp=self.timestamp,
streamid=self.streamid, filter=self.filter,
data=repr(self.data))
type = flagproperty("flags", "type")
filter = flagproperty("flags", "filter", True)
@property
def data_size(self):
return self.data.size
@property
def tag_size(self):
return 11 + self.data_size + len(self.padding)
@property
def size(self):
return 4 + self.tag_size
@classmethod
def _deserialize(cls, io, strict=False, raw_data=False):
header = io.read(11)
if len(header) < 11:
raise FLVError("Insufficient tag header")
(flagb, data_size, timestamp, timestamp_ext,
streamid) = unpack_many_from(header, 0, (U8, U24BE, U24BE, U8, U24BE))
flags = TagFlags()
flags.byte = flagb
timestamp |= timestamp_ext << 24
# Don't parse encrypted data
if flags.bit.filter == 1:
raw_data = True
if flags.bit.type in TagDataTypes:
datacls = TagDataTypes[flags.bit.type]
else:
raise FLVError("Unknown tag type!")
tag_data = chunked_read(io, data_size, exception=FLVError)
if data_size > 0 and not raw_data:
tag_data_io = BytesIO(tag_data)
data = datacls.deserialize(tag_data_io)
padding = tag_data_io.read()
else:
data = RawData(tag_data)
padding = b""
tag = Tag(flags.bit.type, timestamp, data,
streamid, bool(flags.bit.filter), padding)
tag_size = U32BE.read(io)
if strict and tag.tag_size != tag_size:
raise FLVError("Data size mismatch when deserialising tag")
return tag
@classmethod
def _deserialize_from(cls, buf, offset, strict=False,
raw_data=False):
(flagb, data_size, timestamp, timestamp_ext,
streamid) = unpack_many_from(buf, offset, (U8, U24BE, U24BE, U8, U24BE))
offset += 11
flags = TagFlags()
flags.byte = flagb
timestamp |= timestamp_ext << 24
# Don't parse encrypted data
if flags.bit.filter == 1:
raw_data = True
if flags.bit.type in TagDataTypes:
datacls = TagDataTypes[flags.bit.type]
else:
raise FLVError("Unknown tag type!")
if data_size > 0 and not raw_data:
data, doffset = datacls.deserialize_from(buf, offset, buf_size=data_size)
padding = buf[doffset:offset + data_size]
else:
data = RawData(buf[offset:offset + data_size])
padding = b""
offset += data_size
tag = Tag(flags.bit.type, timestamp, data,
streamid, bool(flags.bit.filter), padding)
tag_size = U32BE.unpack_from(buf, offset)[0]
offset += U32BE.size
if strict and tag.tag_size != tag_size:
raise FLVError("Data size mismatch when deserialising tag")
return (tag, offset)
def _serialize(self, packet, strict=True):
packet += U8(self.flags.byte)
packet += U24BE(self.data_size)
packet += U24BE(self.timestamp & 0xFFFFFF)
packet += U8((self.timestamp >> 24) & 0x7F)
packet += U24BE(self.streamid)
self.data.serialize(packet)
packet += self.padding
if strict and self.tag_size != len(packet):
raise FLVError("Data size mismatch when serialising tag")
packet += U32BE(self.tag_size)
def _serialize_into(self, packet, offset):
offset = pack_many_into(packet, offset,
(U8, U24BE, U24BE, U8, U24BE),
(self.flags.byte, self.data_size,
self.timestamp & 0xFFFFFF,
(self.timestamp >> 24) & 0x7F,
self.streamid))
offset = self.data.serialize_into(packet, offset)
offset = pack_bytes_into(packet, offset, self.padding)
U32BE.pack_into(packet, offset, self.tag_size)
offset += 4
return offset
class FrameData(TagData):
def __init__(self, type=1, data=b""):
self.type = type
self.data = data
def __repr__(self):
if not isinstance(self.data, Packet):
data = ("<{0}>").format(type(self.data).__name__)
else:
data = repr(self.data)
reprformat = "<{cls} type={type} data={data}>"
return reprformat.format(cls=type(self).__name__, type=self.type, data=data)
@property
def size(self):
return TagData.size.__get__(self) + 1
@classmethod
def _deserialize(cls, io):
typ = U8.read(io)
data = io.read()
return cls(typ, data)
@classmethod
def _deserialize_from(cls, buf, offset, buf_size=None):
if not buf_size:
buf_size = len(buf)
typ = U8.unpack_from(buf, offset)[0]
offset += U8.size
buf_size -= U8.size
data = buf[offset:offset + buf_size]
offset += buf_size
return (cls(typ, data), offset)
def _serialize(self, packet):
packet += U8(self.type)
packet += self.data
def _serialize_into(self, packet, offset):
U8.pack_into(packet, offset, self.type)
offset += U8.size
offset = pack_bytes_into(packet, offset, self.data)
return offset
class RawData(TagData):
def __init__(self, data=None):
if not data:
data = b""
self.data = data
def __repr__(self):
return "<RawData>"
@classmethod
def _deserialize(cls, io):
return cls(io.read())
@classmethod
def _deserialize_from(cls, buf, offset, buf_size=None):
if not data_size:
buf_size = len(buf)
data = buf[offset:offset + buf_size]
rval = cls(data)
offset += len(data)
return (rval, offset)
def _serialize(self, packet):
packet += self.data
def _serialize_into(self, packet, offset):
return pack_bytes_into(packet, offset, self.data)
class AudioData(TagData):
def __init__(self, codec=0, rate=0, bits=0, type=0, data=None):
self.flags = AudioFlags()
self.flags.bit.codec = codec
self.flags.bit.rate = rate
self.flags.bit.bits = bits
self.flags.bit.type = type
self.data = data
codec = flagproperty("flags", "codec")
rate = flagproperty("flags", "rate")
bits = flagproperty("flags", "bits")
type = flagproperty("flags", "type")
def __repr__(self):
if not isinstance(self.data, Packet):
data = ("<{0}>").format(type(self.data).__name__)
else:
data = repr(self.data)
reprformat = "<AudioData type={type} codec={codec} rate={rate} bits={bits} data={data}>"
return reprformat.format(type=self.type, codec=self.codec, rate=self.rate,
bits=self.bits, data=data)
@property
def size(self):
return TagData.size.__get__(self) + 1
@classmethod
def _deserialize(cls, io):
flags = AudioFlags()
flags.byte = U8.read(io)
if flags.bit.codec == AUDIO_CODEC_ID_AAC:
data = AACAudioData.deserialize(io)
else:
data = io.read()
return cls(flags.bit.codec, flags.bit.rate, flags.bit.bits,
flags.bit.type, data)
@classmethod
def _deserialize_from(cls, buf, offset, buf_size=None):
if not buf_size:
buf_size = len(buf)
flags = AudioFlags()
flags.byte = U8.unpack_from(buf, offset)[0]
offset += U8.size
buf_size -= U8.size
if flags.bit.codec == 10:
data, offset = AACAudioData.deserialize_from(buf, offset,
buf_size=buf_size)
else:
data = buf[offset:offset + buf_size]
offset += buf_size
obj = cls(flags.bit.codec, flags.bit.rate, flags.bit.bits,
flags.bit.type, data)
return (obj, offset)
def _serialize(self, packet):
packet += U8(self.flags.byte)
if isinstance(self.data, Packet):
self.data.serialize(packet)
else:
packet += self.data
def _serialize_into(self, packet, offset):
U8.pack_into(packet, offset, self.flags.byte)
offset += 1
if isinstance(self.data, Packet):
offset = self.data.serialize_into(packet, offset)
else:
offset = pack_bytes_into(packet, offset, self.data)
return offset
class AACAudioData(FrameData):
pass
class VideoData(TagData):
def __init__(self, type=0, codec=0, data=None):
self.flags = VideoFlags()
self.flags.bit.type = type
self.flags.bit.codec = codec
if not data:
data = b""
self.data = data
def __repr__(self):
if not isinstance(self.data, Packet):
data = ("<{0}>").format(type(self.data).__name__)
else:
data = repr(self.data)
reprformat = "<VideoData type={type} codec={codec} data={data}>"
return reprformat.format(type=self.type, codec=self.codec, data=data)
type = flagproperty("flags", "type")
codec = flagproperty("flags", "codec")
@property
def size(self):
return TagData.size.__get__(self) + 1
@classmethod
def _deserialize(cls, io):
flags = VideoFlags()
flags.byte = U8.read(io)
if flags.bit.type == VIDEO_FRAME_TYPE_COMMAND_FRAME:
data = VideoCommandFrame.deserialize(io)
else:
if flags.bit.codec == VIDEO_CODEC_ID_AVC:
data = AVCVideoData.deserialize(io)
else:
data = io.read()
return cls(flags.bit.type, flags.bit.codec, data)
@classmethod
def _deserialize_from(cls, buf, offset, buf_size=None):
if not buf_size:
buf_size = len(buf)
flags = VideoFlags()
flags.byte = U8.unpack_from(buf, offset)[0]
offset += U8.size
buf_size -= U8.size
if flags.bit.type == VIDEO_FRAME_TYPE_COMMAND_FRAME:
data, offset = VideoCommandFrame.deserialize_from(buf, offset,
buf_size=buf_size)
else:
if flags.bit.codec == VIDEO_CODEC_ID_AVC:
data, offset = AVCVideoData.deserialize_from(buf, offset,
buf_size=buf_size)
else:
data = buf[offset:offset + buf_size]
offset += buf_size
obj = cls(flags.bit.type, flags.bit.codec, data)
return (obj, offset)
def _serialize(self, packet):
packet += U8(self.flags.byte)
if isinstance(self.data, Packet):
self.data.serialize(packet)
else:
packet += self.data
def _serialize_into(self, packet, offset):
U8.pack_into(packet, offset, self.flags.byte)
offset += 1
if isinstance(self.data, Packet):
offset = self.data.serialize_into(packet, offset)
else:
offset = pack_bytes_into(packet, offset, self.data)
return offset
class VideoCommandFrame(FrameData):
pass
class AVCVideoData(TagData):
def __init__(self, type=1, composition_time=0, data=None):
self.type = type
self.composition_time = composition_time
if not data:
data = b""
self.data = data
def __repr__(self):
if not isinstance(self.data, Packet):
data = ("<{0}>").format(type(self.data).__name__)
else:
data = repr(self.data)
reprformat = "<AVCVideoData type={type} composition_time={composition_time} data={data}>"
return reprformat.format(type=self.type, composition_time=self.composition_time,
data=data)
@property
def size(self):
return TagData.size.__get__(self) + 4
@classmethod
def _deserialize(cls, io):
typ = U8.read(io)
composition_time = S24BE.read(io)
data = io.read()
return cls(typ, composition_time, data)
@classmethod
def _deserialize_from(cls, buf, offset, buf_size=None):
if not buf_size:
buf_size = None
typ = U8.unpack_from(buf, offset)[0]
offset += U8.size
composition_time = S24BE.unpack_from(buf, offset)[0]
offset += S24BE.size
buf_size -= U8.size + S24BE.size
data = buf[offset:offset + buf_size]
offset += len(data)
obj = cls(typ, composition_time, data)
return (obj, offset)
def _serialize(self, packet):
packet += U8(self.type)
packet += S24BE(self.composition_time)
packet += self.data
def _serialize_into(self, packet, offset):
offset = pack_many_into(packet, offset,
(U8, S24BE),
(self.type, self.composition_time))
offset = pack_bytes_into(packet, offset, self.data)
return offset
class ScriptData(TagData):
def __init__(self, name=None, value=None):
self.name = name
self.value = value
def __repr__(self):
reprformat = "<ScriptData name={name} value={value}>"
return reprformat.format(name=self.name, value=self.value)
@property
def size(self):
size = ScriptDataValue.size(self.name)
size += ScriptDataValue.size(self.value)
return size
@classmethod
def _deserialize(cls, io):
name = ScriptDataValue.read(io)
value = ScriptDataValue.read(io)
return ScriptData(name, value)
@classmethod
def _deserialize_from(cls, buf, offset, buf_size=None):
name, offset = ScriptDataValue.unpack_from(buf, offset)
value, offset = ScriptDataValue.unpack_from(buf, offset)
return (ScriptData(name, value), offset)
def _serialize(self, packet):
packet += ScriptDataValue.pack(self.name)
packet += ScriptDataValue.pack(self.value)
def _serialize_into(self, packet, offset):
offset = ScriptDataValue.pack_into(packet, offset, self.name)
offset = ScriptDataValue.pack_into(packet, offset, self.value)
return offset
TagDataTypes = {
TAG_TYPE_AUDIO: AudioData,
TAG_TYPE_VIDEO: VideoData,
TAG_TYPE_SCRIPT: ScriptData
}
__all__ = ["Header", "Tag", "FrameData", "AudioData", "AACAudioData",
"VideoData", "VideoCommandFrame", "AVCVideoData",
"ScriptData", "TAG_TYPE_VIDEO", "TAG_TYPE_AUDIO", "TAG_TYPE_SCRIPT"]
livestreamer-1.12.2/src/livestreamer/packages/flashmedia/packet.py 0000644 0001750 0001750 00000002712 12521217321 026360 0 ustar chrippa chrippa 0000000 0000000 #!/usr/bin/env python
import struct
class Packet(object):
exception = IOError
@classmethod
def _deserialize(cls, fd):
raise NotImplementedError
@classmethod
def _deserialize_from(cls, buf, offset, **kw):
raise NotImplementedError
@classmethod
def deserialize(cls, fd, **kw):
try:
return cls._deserialize(fd, **kw)
except (struct.error, IOError) as err:
raise cls.exception(err)
@classmethod
def deserialize_from(cls, buf, offset, **kw):
try:
return cls._deserialize_from(buf, offset, **kw)
except (struct.error, IOError) as err:
raise cls.exception(err)
def _serialize(self):
raise NotImplementedError
def _serialize_into(self, buf, offset):
raise NotImplementedError
def serialize(self, packet=None, **kw):
if packet is None:
packet = bytearray()
self._serialize(packet, **kw)
return packet
def serialize2(self):
buf = bytearray(self.size)
self.serialize_into(buf, 0)
return buf
def serialize_into(self, buf, offset):
return self._serialize_into(buf, offset)
def __bytes__(self):
return self.serialize()
class TagData(Packet):
@property
def size(self):
if isinstance(self.data, Packet):
return self.data.size
else:
return len(self.data)
__all__ = ["Packet", "TagData"]
livestreamer-1.12.2/src/livestreamer/packages/flashmedia/ordereddict.py 0000644 0001750 0001750 00000021255 12521217321 027404 0 ustar chrippa chrippa 0000000 0000000 # Source: http://code.activestate.com/recipes/576693/
# Backport of OrderedDict() class that runs on Python 2.4, 2.5, 2.6, 2.7 and pypy.
# Passes Python2.7's test suite and incorporates all the latest updates.
try:
from thread import get_ident as _get_ident
except ImportError:
from dummy_thread import get_ident as _get_ident
try:
from _abcoll import KeysView, ValuesView, ItemsView
except ImportError:
pass
class OrderedDict(dict):
'Dictionary that remembers insertion order'
# An inherited dict maps keys to values.
# The inherited dict provides __getitem__, __len__, __contains__, and get.
# The remaining methods are order-aware.
# Big-O running times for all methods are the same as for regular dictionaries.
# The internal self.__map dictionary maps keys to links in a doubly linked list.
# The circular doubly linked list starts and ends with a sentinel element.
# The sentinel element never gets deleted (this simplifies the algorithm).
# Each link is stored as a list of length three: [PREV, NEXT, KEY].
def __init__(self, *args, **kwds):
'''Initialize an ordered dictionary. Signature is the same as for
regular dictionaries, but keyword arguments are not recommended
because their insertion order is arbitrary.
'''
if len(args) > 1:
raise TypeError('expected at most 1 arguments, got %d' % len(args))
try:
self.__root
except AttributeError:
self.__root = root = [] # sentinel node
root[:] = [root, root, None]
self.__map = {}
self.__update(*args, **kwds)
def __setitem__(self, key, value, dict_setitem=dict.__setitem__):
'od.__setitem__(i, y) <==> od[i]=y'
# Setting a new item creates a new link which goes at the end of the linked
# list, and the inherited dictionary is updated with the new key/value pair.
if key not in self:
root = self.__root
last = root[0]
last[1] = root[0] = self.__map[key] = [last, root, key]
dict_setitem(self, key, value)
def __delitem__(self, key, dict_delitem=dict.__delitem__):
'od.__delitem__(y) <==> del od[y]'
# Deleting an existing item uses self.__map to find the link which is
# then removed by updating the links in the predecessor and successor nodes.
dict_delitem(self, key)
link_prev, link_next, key = self.__map.pop(key)
link_prev[1] = link_next
link_next[0] = link_prev
def __iter__(self):
'od.__iter__() <==> iter(od)'
root = self.__root
curr = root[1]
while curr is not root:
yield curr[2]
curr = curr[1]
def __reversed__(self):
'od.__reversed__() <==> reversed(od)'
root = self.__root
curr = root[0]
while curr is not root:
yield curr[2]
curr = curr[0]
def clear(self):
'od.clear() -> None. Remove all items from od.'
try:
for node in self.__map.itervalues():
del node[:]
root = self.__root
root[:] = [root, root, None]
self.__map.clear()
except AttributeError:
pass
dict.clear(self)
def popitem(self, last=True):
'''od.popitem() -> (k, v), return and remove a (key, value) pair.
Pairs are returned in LIFO order if last is true or FIFO order if false.
'''
if not self:
raise KeyError('dictionary is empty')
root = self.__root
if last:
link = root[0]
link_prev = link[0]
link_prev[1] = root
root[0] = link_prev
else:
link = root[1]
link_next = link[1]
root[1] = link_next
link_next[0] = root
key = link[2]
del self.__map[key]
value = dict.pop(self, key)
return key, value
# -- the following methods do not depend on the internal structure --
def keys(self):
'od.keys() -> list of keys in od'
return list(self)
def values(self):
'od.values() -> list of values in od'
return [self[key] for key in self]
def items(self):
'od.items() -> list of (key, value) pairs in od'
return [(key, self[key]) for key in self]
def iterkeys(self):
'od.iterkeys() -> an iterator over the keys in od'
return iter(self)
def itervalues(self):
'od.itervalues -> an iterator over the values in od'
for k in self:
yield self[k]
def iteritems(self):
'od.iteritems -> an iterator over the (key, value) items in od'
for k in self:
yield (k, self[k])
def update(*args, **kwds):
'''od.update(E, **F) -> None. Update od from dict/iterable E and F.
If E is a dict instance, does: for k in E: od[k] = E[k]
If E has a .keys() method, does: for k in E.keys(): od[k] = E[k]
Or if E is an iterable of items, does: for k, v in E: od[k] = v
In either case, this is followed by: for k, v in F.items(): od[k] = v
'''
if len(args) > 2:
raise TypeError('update() takes at most 2 positional '
'arguments (%d given)' % (len(args),))
elif not args:
raise TypeError('update() takes at least 1 argument (0 given)')
self = args[0]
# Make progressively weaker assumptions about "other"
other = ()
if len(args) == 2:
other = args[1]
if isinstance(other, dict):
for key in other:
self[key] = other[key]
elif hasattr(other, 'keys'):
for key in other.keys():
self[key] = other[key]
else:
for key, value in other:
self[key] = value
for key, value in kwds.items():
self[key] = value
__update = update # let subclasses override update without breaking __init__
__marker = object()
def pop(self, key, default=__marker):
'''od.pop(k[,d]) -> v, remove specified key and return the corresponding value.
If key is not found, d is returned if given, otherwise KeyError is raised.
'''
if key in self:
result = self[key]
del self[key]
return result
if default is self.__marker:
raise KeyError(key)
return default
def setdefault(self, key, default=None):
'od.setdefault(k[,d]) -> od.get(k,d), also set od[k]=d if k not in od'
if key in self:
return self[key]
self[key] = default
return default
def __repr__(self, _repr_running={}):
'od.__repr__() <==> repr(od)'
call_key = id(self), _get_ident()
if call_key in _repr_running:
return '...'
_repr_running[call_key] = 1
try:
if not self:
return '%s()' % (self.__class__.__name__,)
return '%s(%r)' % (self.__class__.__name__, self.items())
finally:
del _repr_running[call_key]
def __reduce__(self):
'Return state information for pickling'
items = [[k, self[k]] for k in self]
inst_dict = vars(self).copy()
for k in vars(OrderedDict()):
inst_dict.pop(k, None)
if inst_dict:
return (self.__class__, (items,), inst_dict)
return self.__class__, (items,)
def copy(self):
'od.copy() -> a shallow copy of od'
return self.__class__(self)
@classmethod
def fromkeys(cls, iterable, value=None):
'''OD.fromkeys(S[, v]) -> New ordered dictionary with keys from S
and values equal to v (which defaults to None).
'''
d = cls()
for key in iterable:
d[key] = value
return d
def __eq__(self, other):
'''od.__eq__(y) <==> od==y. Comparison to another OD is order-sensitive
while comparison to a regular mapping is order-insensitive.
'''
if isinstance(other, OrderedDict):
return len(self)==len(other) and self.items() == other.items()
return dict.__eq__(self, other)
def __ne__(self, other):
return not self == other
# -- the following methods are only used in Python 2.7 --
def viewkeys(self):
"od.viewkeys() -> a set-like object providing a view on od's keys"
return KeysView(self)
def viewvalues(self):
"od.viewvalues() -> an object providing a view on od's values"
return ValuesView(self)
def viewitems(self):
"od.viewitems() -> a set-like object providing a view on od's items"
return ItemsView(self)
livestreamer-1.12.2/src/livestreamer/packages/flashmedia/flv.py 0000644 0001750 0001750 00000001070 12521217321 025674 0 ustar chrippa chrippa 0000000 0000000 #!/usr/bin/env python
from .error import FLVError
from .compat import is_py2
from .tag import Header, Tag
class FLV(object):
def __init__(self, fd=None, strict=False):
self.fd = fd
self.header = Header.deserialize(self.fd)
self.strict = strict
def __iter__(self):
return self
def __next__(self):
try:
tag = Tag.deserialize(self.fd, strict=self.strict)
except (IOError, FLVError):
raise StopIteration
return tag
if is_py2:
next = __next__
__all__ = ["FLV"]
livestreamer-1.12.2/src/livestreamer/packages/flashmedia/f4v.py 0000644 0001750 0001750 00000001171 12521217321 025606 0 ustar chrippa chrippa 0000000 0000000 #!/usr/bin/env python
from .box import Box, RawPayload
from .compat import is_py2
class F4V(object):
def __init__(self, fd, strict=False, raw_payload=False):
self.fd = fd
self.raw_payload = raw_payload
self.strict = strict
def __iter__(self):
return self
def __next__(self):
try:
box = Box.deserialize(self.fd,
strict=self.strict,
raw_payload=self.raw_payload)
except IOError:
raise StopIteration
return box
if is_py2:
next = __next__
__all__ = ["F4V"]
livestreamer-1.12.2/src/livestreamer/packages/flashmedia/error.py 0000644 0001750 0001750 00000000265 12521217321 026243 0 ustar chrippa chrippa 0000000 0000000 #!/usr/bin/env python
class FLVError(Exception):
pass
class F4VError(Exception):
pass
class AMFError(Exception):
pass
__all__ = ["FLVError", "F4VError", "AMFError"]
livestreamer-1.12.2/src/livestreamer/packages/flashmedia/compat.py 0000644 0001750 0001750 00000001440 12521217321 026371 0 ustar chrippa chrippa 0000000 0000000 import os
import sys
is_py2 = (sys.version_info[0] == 2)
is_py3 = (sys.version_info[0] == 3)
is_win32 = os.name == "nt"
if is_py2:
_str = str
str = unicode
range = xrange
string_types = (_str, unicode)
integer_types = (int, long)
def bytes(b=None, enc="ascii"):
if b is None:
return ""
elif isinstance(b, list) or isinstance(b, tuple):
return "".join([chr(i) for i in b])
else:
return _str(b)
elif is_py3:
bytes = bytes
str = str
range = range
string_types = (str,)
integer_types = (int,)
try:
from collections import OrderedDict
except ImportError:
from .ordereddict import OrderedDict
__all__ = ["is_py2", "is_py3", "is_win32", "str", "bytes", "range",
"OrderedDict"]
livestreamer-1.12.2/src/livestreamer/packages/flashmedia/box.py 0000644 0001750 0001750 00000076041 12521217321 025707 0 ustar chrippa chrippa 0000000 0000000 from ctypes import BigEndianStructure, Union, c_uint8, c_uint16, c_uint32
from io import BytesIO
from .compat import *
from .error import *
from .packet import *
from .types import *
from .util import *
class Box(Packet):
exception = F4VError
def __init__(self, type, payload, extended_size=False):
self.type = type
self.payload = payload
self.extended_size = extended_size
@property
def size(self):
size = 8
size += self.payload.size
if size > 0xFFFFFFFF or self.extended_size:
size += 8
return size
@classmethod
def _deserialize(cls, io, strict=False, raw_payload=False):
size = U32BE.read(io)
type_ = FourCC.read(io)
header_size = 8
extended_size = False
if size == 1:
size = U64BE.read(io)
header_size += 8
extended_size = True
if size == 0:
data = io.read()
else:
data = chunked_read(io, size - header_size, exception=F4VError)
if type_ in PayloadTypes and not raw_payload:
payloadcls = PayloadTypes[type_]
payloadio = BytesIO(data)
payload = payloadcls.deserialize(payloadio)
else:
payload = RawPayload(data)
box = cls(type_, payload, extended_size)
if strict and box.size != size:
raise F4VError("Data size mismatch when deserialising tag")
return box
def _serialize(self, packet):
size = self.payload.size
if size > 0xFFFFFFFF or self.extended_size:
packet += U32BE(1)
else:
packet += U32BE(size + 8)
packet += FourCC(self.type)
if size > 0xFFFFFFFF or self.extended_size:
packet += U64BE(size + 16)
if isinstance(self.payload, BoxPayload):
self.payload.serialize(packet)
else:
packetwrite(self.payload)
class BoxPayload(Packet):
exception = F4VError
@property
def size(self):
return 0
@classmethod
def box(cls, *args, **kw):
type_ = None
for name, kls in PayloadTypes.items():
if kls == cls:
type_ = name
break
payload = cls(*args, **kw)
return Box(type_, 0, payload)
class BoxContainer(BoxPayload):
def __init__(self, boxes):
self.boxes = boxes
@property
def size(self):
size = 0
for box in self.boxes:
size += box.size
return size
def _serialize(self, packet):
for box in self.boxes:
box.serialize(packet)
@classmethod
def _deserialize(cls, io):
boxes = []
while True:
try:
box = Box.deserialize(io)
except IOError:
break
boxes.append(box)
return cls(boxes)
class BoxContainerSingle(BoxPayload):
def __init__(self, box):
self.box = box
@property
def size(self):
return self.box.size
def _serialize(self, packet):
self.box.serialize(packet)
@classmethod
def _deserialize(cls, io):
box = Box.deserialize(io)
return cls(box)
class RawPayload(BoxPayload):
def __init__(self, data):
self.data = data
def __repr__(self):
return "<RawPayload size={0}>".format(self.size)
@property
def size(self):
return len(self.data)
@classmethod
def _deserialize(cls, io):
data = io.read()
return cls(data)
def _serialize(self, packet):
packet += self.data
class BoxPayloadFTYP(BoxPayload):
def __init__(self, major_brand="f4v", minor_version=0,
compatible_brands=["isom", "mp42", "m4v"]):
self.major_brand = major_brand
self.minor_version = minor_version
self.compatible_brands = compatible_brands
@property
def size(self):
return 4+4+(len(self.compatible_brands)*4)
def _serialize(self, packet):
packet += FourCC(self.major_brand)
packet += U32BE(self.minor_version)
for brand in self.compatible_brands:
packet += FourCC(brand)
@classmethod
def _deserialize(cls, io):
major_brand = FourCC.read(io)
minor_version = U32BE.read(io)
compatible_brands = []
while True:
try:
brand = FourCC.read(io)
except IOError:
break
compatible_brands.append(brand)
return cls(major_brand, minor_version,
compatible_brands)
class BoxPayloadMVHD(BoxPayload):
def __init__(self, version=0, creation_time=0, modification_time=0,
time_scale=1000, duration=0, rate=1.0, volume=1.0,
matrix=[65536, 0, 0, 0, 65536, 0, 0, 0, 1073741824],
next_track_id=0):
self.version = version
self.creation_time = creation_time
self.modification_time = modification_time
self.time_scale = time_scale
self.duration = duration
self.rate = rate
self.volume = volume
self.matrix = matrix
self.next_track_id = next_track_id
@property
def size(self):
size = 1+3+4+4+2+2+4+4+(9*4)+(6*4)+4
if self.version == 1:
size += 3*8
else:
size += 3*4
return size
def _serialize(self, packet):
packet += U8(self.version)
packet += U24BE(0) # Reserved
packet += U3264(self.creation_time, self.version)
packet += U3264(self.modification_time, self.version)
packet += U32BE(self.time_scale)
packet += U3264(self.duration, self.version)
packet += S16BE_16(self.rate)
packet += S8_8BE(self.volume)
packet += U16BE(0) # Reserved
packet += U32BE(0) # Reserved
packet += U32BE(0) # Reserved
for m in self.matrix:
packet += U32BE(m)
for i in range(6):
packet += U32BE(0) # Reserved
packet += U32BE(self.next_track_id)
@classmethod
def _deserialize(cls, io):
version = U8.read(io)
U24BE.read(io) # Reserved
creation_time = U3264.read(io, version)
modification_time = U3264.read(io, version)
time_scale = U32BE.read(io)
duration = U3264.read(io, version)
rate = S16_16.read(io)
volume = S8_8BE.read(io)
U16BE.read(io) # Reserved
U32BE.read(io) # Reserved
U32BE.read(io) # Reserved
matrix = []
for i in range(9):
matrix.append(U32BE.read(io))
for i in range(6):
U32BE.read(io) # Reserved
next_track_id = U32BE.read(io)
return cls(version, creation_time,
modification_time, time_scale, duration,
rate, volume, matrix, next_track_id)
class SampleFlags(BoxPayload):
class Flags(Union):
class Bits(BigEndianStructure):
_fields_ = [("reserved", c_uint8, 6),
("sample_depends_on", c_uint8, 2),
("sample_is_depended_on", c_uint8, 2),
("sample_has_redundancy", c_uint8, 2),
("sample_padding_value", c_uint8, 3),
("sample_is_difference_sample", c_uint8, 1),
("sample_degradation_priority", c_uint16, 16)]
_fields_ = [("bit", Bits), ("byte", c_uint32)]
def __init__(self, sample_depends_on, sample_is_depended_on,
sample_has_redundancy, sample_padding_value,
sample_is_difference_sample, sample_degradation_priority):
self.flags = self.Flags()
self.flags.bit.reserved = 0 # Reserved
self.flags.bit.sample_depends_on = sample_depends_on
self.flags.bit.sample_is_depended_on = sample_is_depended_on
self.flags.bit.sample_has_redundancy = sample_has_redundancy
self.flags.bit.sample_padding_value = sample_padding_value
self.flags.bit.sample_is_difference_sample = sample_is_difference_sample
self.flags.bit.sample_degradation_priority = sample_degradation_priority
@property
def size(self):
return 4
def _serialize(self, packet):
packet += U32BE(self.flags.byte)
@classmethod
def _deserialize(cls, io):
flags = cls.Flags()
flags.byte = U32BE.read(io)
return cls(flags.bit.sample_depends_on, flags.bit.sample_is_depended_on,
flags.bit.sample_has_redundancy, flags.bit.sample_padding_value,
flags.bit.sample_is_difference_sample, flags.bit.sample_degradation_priority)
class BoxPayloadTREX(BoxPayload):
def __init__(self, version, track_id,
default_sample_description_index,
default_sample_duration, default_sample_size,
default_sample_flags):
self.version = version
self.track_id = track_id
self.default_sample_description_index = default_sample_description_index
self.default_sample_duration = default_sample_duration
self.default_sample_size = default_sample_size
self.default_sample_flags = default_sample_flags
@property
def size(self):
return 1+3+4+4+4+4+self.default_sample_flags.size
def _serialize(self, packet):
packet += U8(self.version)
packet += U24BE(0) # Reserved
packet += U32BE(self.track_id)
packet += U32BE(self.default_sample_description_index)
packet += U32BE(self.default_sample_duration)
packet += U32BE(self.default_sample_size)
self.default_sample_flags.serialize(packet)
@classmethod
def _deserialize(cls, io):
version = U8.read(io)
flags = U24BE.read(io)
track_id = U32BE.read(io)
default_sample_description_index = U32BE.read(io)
default_sample_duration = U32BE.read(io)
default_sample_size = U32BE.read(io)
default_sample_flags = SampleFlags.deserialize(io)
return cls(version, track_id,
default_sample_description_index,
default_sample_duration, default_sample_size,
default_sample_flags)
class BoxPayloadTKHD(BoxPayload):
def __init__(self, version=0, flags=1, creation_time=0, modification_time=0,
track_id=1, duration=0, layer=0, alternate_group=0, volume=0.0,
transform_matrix=[65536, 0, 0, 0, 65536, 0, 0, 0, 1073741824],
width=0.0, height=0.0):
self.version = version
self.flags = flags
self.creation_time = creation_time
self.modification_time = modification_time
self.track_id = track_id
self.duration = duration
self.layer = layer
self.alternate_group = alternate_group
self.volume = volume
self.transform_matrix = transform_matrix
self.width = width
self.height = height
@property
def size(self):
size = 1+3+4+4+4+4+4+(4*2)+2+2+2+2+(9*4)+4+4
if self.version == 1:
size += 4*3
return size
def _serialize(self, packet):
packet += U8(self.version)
packet += U24BE(self.flags)
packet += U3264(self.creation_time, self.version)
packet += U3264(self.modification_time, self.version)
packet += U32BE(self.track_id)
packet += U32BE(0) # Reserved
packet += U3264(self.duration, self.version)
for i in range(2):
packet += U32BE(0) # Reserved
packet += S16BE(self.layer)
packet += S16BE(self.alternate_group)
packet += S8_8BE(self.volume)
packet += U16BE(0) # Reserved
for i in range(9):
packet += U32BE(self.transform_matrix[i])
packet += S16BE_16(self.width)
packet += S16BE_16(self.height)
@classmethod
def _deserialize(cls, io):
version = U8.read(io)
flags = U24BE.read(io)
creation_time = U3264.read(io, version)
modification_time = U3264.read(io, version)
track_id = U32BE.read(io)
U32BE.read(io) # Reserved
duration = U3264.read(io, version)
for i in range(2):
U32BE.read(io) # Reserved
layer = S16BE.read(io)
alternate_group = S16BE.read(io)
volume = S8_8BE.read(io)
U16BE.read(io) # Reserved
transform_matrix = []
for i in range(9):
transform_matrix.append(S32BE.read(io))
width = S16_16.read(io)
height = S16_16.read(io)
return cls(version, flags, creation_time, modification_time,
track_id, duration, layer, alternate_group, volume,
transform_matrix, width, height)
class BoxPayloadMDHD(BoxPayload):
def __init__(self, version=0, creation_time=0, modification_time=0,
time_scale=1000, duration=0, language="eng"):
self.version = version
self.creation_time = creation_time
self.modification_time = modification_time
self.time_scale = time_scale
self.duration = duration
self.language = language
@property
def size(self):
size = 1+3+4+4+4+4+2+2
if self.version == 1:
size += 4*3
return size
def _serialize(self, packet):
packet += U8(self.version)
packet += U24BE(0) # Reserved
packet += U3264(self.creation_time, self.version)
packet += U3264(self.modification_time, self.version)
packet += U32BE(self.time_scale)
packet += U3264(self.duration, self.version)
packet += S16BE(iso639_to_lang(self.language))
packet += U16BE(0) # Reserved
@classmethod
def _deserialize(cls, io):
version = U8.read(io)
U24BE.read(io) # Reserved
creation_time = U3264.read(io, version)
modification_time = U3264.read(io, version)
time_scale = U32BE.read(io)
duration = U3264.read(io, version)
language = lang_to_iso639(U16BE.read(io))
U16BE.read(io) # Reserved
return cls(version, creation_time, modification_time,
time_scale, duration, language)
class BoxPayloadHDLR(BoxPayload):
def __init__(self, version=0, predefined=0, handler_type="vide",
name=""):
self.version = version
self.predefined = predefined
self.handler_type = handler_type
self.name = name
@property
def size(self):
size = 1+3+4+4+(3*4)
size += len(self.name)
return size
def _serialize(self, packet):
packet += U8(self.version)
packet += U24BE(0) # Reserved
packet += U32BE(self.predefined)
packet += FourCC(self.handler_type)
for i in range(3):
packet += U32BE(0) # Reserved
#packet += self.name.encode("utf8", "ignore")
packet += CString(self.name)
@classmethod
def _deserialize(cls, io):
version = U8.read(io)
flags = U24BE.read(io) # Reserved
predefined = U32BE.read(io)
handler_type = FourCC.read(io)
for i in range(3):
U32BE.read(io) # Reserved
name = CString.read(io)
return cls(version, predefined, handler_type,
name)
class BoxPayloadVMHD(BoxPayload):
def __init__(self, version=0, flags=1, graphics_mode=0, op_color=[0, 0, 0]):
self.version = version
self.flags = flags
self.graphics_mode = graphics_mode
self.op_color = op_color
@property
def size(self):
return 1+3+2+(3*2)
def _serialize(self, packet):
packet += U8(self.version)
packet += U24BE(self.flags)
packet += U16BE(self.graphics_mode)
for i in range(3):
packet += U16BE(self.op_color[i])
@classmethod
def _deserialize(cls, io):
version = U8.read(io)
flags = U24BE.read(io)
graphics_mode = U16BE.read(io)
op_color = []
for i in range(3):
op_color.append(U16BE.read(io))
return cls(version, flags, graphics_mode, op_color)
class BoxPayloadDREF(BoxContainer):
def __init__(self, version=0, boxes=[]):
self.version = version
self.boxes = boxes
@property
def size(self):
size = 1+3+4
for box in self.boxes:
size += box.size
return size
def _serialize(self, packet):
packet += U8(self.version)
packet += U24BE(0) # Reserved
packet += U32BE(len(self.boxes))
for box in self.boxes:
box.serialize(packet)
@classmethod
def _deserialize(cls, io):
version = U8.read(io)
flags = U24BE.read(io)
entry_count = U32BE.read(io)
boxes = []
for i in range(entry_count):
box = Box.deserialize(io)
boxes.append(box)
return cls(version, boxes)
class BoxPayloadURL(BoxPayload):
def __init__(self, version=0, flags=1):
self.version = version
self.flags = flags
@property
def size(self):
return 4
def _serialize(self, packet):
packet += U8(self.version)
packet += U24BE(self.flags)
@classmethod
def _deserialize(cls, io):
version = U8.read(io)
flags = U24BE.read(io)
return cls(version, flags)
class BoxPayloadSTSD(BoxContainer):
def __init__(self, version=0, descriptions=[]):
self.version = version
self.descriptions = descriptions
@property
def size(self):
size = 4+4
for description in self.descriptions:
size += description.size
return size
@property
def boxes(self):
return self.descriptions
def _serialize(self, packet):
packet += U8(self.version)
packet += U24BE(0) # Reserved
packet += U32BE(len(self.descriptions))
for description in self.descriptions:
description.serialize(packet)
@classmethod
def _deserialize(cls, io):
version = U8.read(io)
flags = U24BE.read(io)
count = U32BE.read(io)
descriptions = []
for i in range(count):
box = Box.deserialize(io)
descriptions.append(box)
return cls(version, descriptions)
class BoxPayloadVisualSample(BoxContainer):
def __init__(self, data_reference_index=0, width=0, height=0,
horiz_resolution=0.0, vert_resolution=0.0, frame_count=0,
compressor_name="", depth=0, boxes=[]):
self.data_reference_index = data_reference_index
self.width = width
self.height = height
self.horiz_resolution = horiz_resolution
self.vert_resolution = vert_resolution
self.frame_count = frame_count
self.compressor_name = compressor_name
slef.depth = depth
self.boxes = boxes
@property
def size(self):
return 4
def _serialize(self, packet):
packet += U8(self.version)
packet += U24BE(self.flags)
@classmethod
def _deserialize(cls, io):
for i in range(4):
U8.read(io)
return cls(version, flags)
class BoxPayloadMDAT(RawPayload):
def __repr__(self):
return "<BoxPayloadMDAT size={0}>".format(self.size)
class BoxPayloadSKIP(RawPayload):
def __repr__(self):
return "<BoxPayloadSKIP size={0}>".format(self.size)
class BoxPayloadFREE(RawPayload):
def __repr__(self):
return "<BoxPayloadFREE size={0}>".format(self.size)
class BoxPayloadABST(BoxPayload):
class Flags(Union):
class Bits(BigEndianStructure):
_fields_ = [("profile", c_uint8, 2),
("live", c_uint8, 1),
("update", c_uint8, 1),
("reserved", c_uint8, 4)]
_fields_ = [("bit", Bits), ("byte", c_uint8)]
def __init__(self, version, bootstrap_info_version, profile, live, update,
time_scale, current_media_time, smpte_time_code_offset,
movie_identifier, server_entry_table, quality_entry_table,
drm_data, metadata, segment_run_table_entries,
fragment_run_table_entries):
self.version = version
self.bootstrap_info_version = bootstrap_info_version
self.flags = self.Flags()
self.flags.bit.profile = profile
self.flags.bit.live = live
self.flags.bit.update = update
self.flags.bit.reserved = 0
self.time_scale = time_scale
self.current_media_time = current_media_time
self.smpte_time_code_offset = smpte_time_code_offset
self.movie_identifier = movie_identifier
self.server_entry_table = server_entry_table
self.quality_entry_table = quality_entry_table
self.drm_data = drm_data
self.metadata = metadata
self.segment_run_table_entries = segment_run_table_entries
self.fragment_run_table_entries = fragment_run_table_entries
profile = flagproperty("flags", "profile")
update = flagproperty("flags", "update", True)
live = flagproperty("flags", "live", True)
@property
def size(self):
size = 1+3+4+1+4+8+8
size += len(self.movie_identifier) + 1
size += 1
for server in self.server_entry_table:
size += len(server) + 1
size += 1
for quality_entry in self.quality_entry_table:
size += len(quality_entry) + 1
size += len(self.drm_data) + 1
size += len(self.metadata) + 1
size += 1
for segment_run_table in self.segment_run_table_entries:
size += segment_run_table.size
size += 1
for fragment_run_table in self.fragment_run_table_entries:
size += fragment_run_table.size
return size
def _serialize(self, packet):
packet += U8(self.version)
packet += U24BE(0) # Reserved
packet += U32BE(self.bootstrap_info_version)
packet += U8(self.flags.byte)
packet += U32BE(self.time_scale)
packet += U64BE(self.current_media_time)
packet += U64BE(self.smpte_time_code_offset)
packet += CString(self.movie_identifier)
packet += U8(len(self.server_entry_table))
for server_entry in self.server_entry_table:
packet += CString(server_entry)
packet += U8(len(self.quality_entry_table))
for quality_entry in self.quality_entry_table:
packet += CString(quality_entry)
packet += CString(self.drm_data)
packet += CString(self.metadata)
packet += U8(len(self.segment_run_table_entries))
for segment_run_table in self.segment_run_table_entries:
segment_run_table.serialize(packet)
packet += U8(len(self.fragment_run_table_entries))
for fragment_run_table in self.fragment_run_table_entries:
fragment_run_table.serialize(packet)
@classmethod
def _deserialize(cls, io):
version = U8.read(io)
U24BE.read(io) # Reserved
bootstrap_info_version = U32BE.read(io)
flags = cls.Flags()
flags.byte = U8.read(io)
time_scale = U32BE.read(io)
current_media_time = U64BE.read(io)
smpte_time_code_offset = U64BE.read(io)
movie_identifier = CString.read(io)
server_entry_table = []
server_entry_count = U8.read(io)
for i in range(server_entry_count):
server_entry = CString.read(io)
server_entry_table.append(server_entry)
quality_entry_table = []
quality_entry_count = U8.read(io)
for i in range(quality_entry_count):
quality_entry = CString.read(io)
quality_entry_table.append(quality_entry)
drm_data = CString.read(io)
metadata = CString.read(io)
segment_run_table_entries = []
segment_run_table_count = U8.read(io)
for i in range(segment_run_table_count):
segment_run_table = Box.deserialize(io)
segment_run_table_entries.append(segment_run_table)
fragment_run_table_entries = []
fragment_run_table_count = U8.read(io)
for i in range(fragment_run_table_count):
fragment_run_table = Box.deserialize(io)
fragment_run_table_entries.append(fragment_run_table)
return cls(version, bootstrap_info_version, flags.bit.profile,
flags.bit.live, flags.bit.update, time_scale,
current_media_time, smpte_time_code_offset, movie_identifier,
server_entry_table, quality_entry_table, drm_data,
metadata, segment_run_table_entries, fragment_run_table_entries)
class SegmentRunEntry(BoxPayload):
def __init__(self, first_segment, fragments_per_segment):
self.first_segment = first_segment
self.fragments_per_segment = fragments_per_segment
@property
def size(self):
return 8
def _serialize(self, packet):
packet += U32BE(self.first_segment)
packet += U32BE(self.fragments_per_segment)
@classmethod
def _deserialize(cls, io):
first_segment = U32BE.read(io)
fragments_per_segment = U32BE.read(io)
return cls(first_segment, fragments_per_segment)
class BoxPayloadASRT(BoxPayload):
def __init__(self, version, flags, quality_segment_url_modifiers,
segment_run_entry_table):
self.version = version
self.flags = flags
self.quality_segment_url_modifiers = quality_segment_url_modifiers
self.segment_run_entry_table = segment_run_entry_table
@property
def size(self):
size = 1+3+1+4
for quality in self.quality_segment_url_modifiers:
size += len(quality) + 1
for segment_run_entry in self.segment_run_entry_table:
size += segment_run_entry.size
return size
def _serialize(self, packet):
packet += U8(self.version)
packet += U24BE(self.flags)
packet += U8(len(self.quality_segment_url_modifiers))
for quality in self.quality_segment_url_modifiers:
packet += CString(quality)
packet += U32BE(len(self.segment_run_entry_table))
for segment_run_entry in self.segment_run_entry_table:
segment_run_entry.serialize(packet)
@classmethod
def _deserialize(cls, io):
version = U8.read(io)
flags = U24BE.read(io)
quality_segment_url_modifiers = []
quality_entry_count = U8.read(io)
for i in range(quality_entry_count):
quality = CString.read(io)
quality_segment_url_modifiers.append(quality)
segment_run_entry_count = U32BE.read(io)
segment_run_entry_table = []
for i in range(segment_run_entry_count):
segment_run_entry = SegmentRunEntry.deserialize(io)
segment_run_entry_table.append(segment_run_entry)
return cls(version, flags, quality_segment_url_modifiers,
segment_run_entry_table)
class FragmentRunEntry(BoxPayload):
def __init__(self, first_fragment, first_fragment_timestamp,
fragment_duration, discontinuity_indicator):
self.first_fragment = first_fragment
self.first_fragment_timestamp = first_fragment_timestamp
self.fragment_duration = fragment_duration
self.discontinuity_indicator = discontinuity_indicator
@property
def size(self):
size = 4+8+4
if self.fragment_duration == 0:
size += 1
return size
def _serialize(self, packet):
packet += U32BE(self.first_fragment)
packet += U64BE(self.first_fragment_timestamp)
packet += U32BE(self.fragment_duration)
if self.fragment_duration == 0:
packet += U8(self.discontinuity_indicator)
@classmethod
def _deserialize(cls, io):
first_fragment = U32BE.read(io)
first_fragment_timestamp = U64BE.read(io)
fragment_duration = U32BE.read(io)
if fragment_duration == 0:
discontinuity_indicator = U8.read(io)
else:
discontinuity_indicator = None
return cls(first_fragment, first_fragment_timestamp,
fragment_duration, discontinuity_indicator)
class BoxPayloadAFRT(BoxPayload):
def __init__(self, version, flags, time_scale,
quality_segment_url_modifiers,
fragment_run_entry_table):
self.version = version
self.flags = flags
self.time_scale = time_scale
self.quality_segment_url_modifiers = quality_segment_url_modifiers
self.fragment_run_entry_table = fragment_run_entry_table
@property
def size(self):
size = 1+3+4+1+4
for quality in self.quality_segment_url_modifiers:
size += len(quality) + 1
for fragment_run_entry in self.fragment_run_entry_table:
size += fragment_run_entry.size
return size
def _serialize(self, packet):
packet += U8(self.version)
packet += U24BE(self.flags)
packet += U32BE(self.time_scale)
packet += U8(len(self.quality_segment_url_modifiers))
for quality in self.quality_segment_url_modifiers:
packet += CString(quality)
packet += U32BE(len(self.fragment_run_entry_table))
for fragment_run_entry in self.fragment_run_entry_table:
fragment_run_entry.serialize(packet)
@classmethod
def _deserialize(cls, io):
version = U8.read(io)
flags = U24BE.read(io)
time_scale = U32BE.read(io)
quality_segment_url_modifiers = []
quality_entry_count = U8.read(io)
for i in range(quality_entry_count):
quality = CString.read(io)
quality_segment_url_modifiers.append(quality)
fragment_run_entry_count = U32BE.read(io)
fragment_run_entry_table = []
for i in range(fragment_run_entry_count):
fragment_run_entry = FragmentRunEntry.deserialize(io)
fragment_run_entry_table.append(fragment_run_entry)
return cls(version, flags, time_scale,
quality_segment_url_modifiers,
fragment_run_entry_table)
class BoxPayloadMVEX(BoxContainer):
pass
class BoxPayloadMFRA(BoxContainer):
pass
class BoxPayloadTRAK(BoxContainer):
pass
class BoxPayloadMDIA(BoxContainer):
pass
class BoxPayloadMINF(BoxContainer):
pass
class BoxPayloadSTBL(BoxContainer):
pass
class BoxPayloadMOOV(BoxContainer):
pass
class BoxPayloadMOOF(BoxContainer):
pass
class BoxPayloadMETA(BoxContainer):
pass
class BoxPayloadDINF(BoxContainerSingle):
pass
PayloadTypes = {
"ftyp": BoxPayloadFTYP,
"mvhd": BoxPayloadMVHD,
"trex": BoxPayloadTREX,
"tkhd": BoxPayloadTKHD,
"mdhd": BoxPayloadMDHD,
"hdlr": BoxPayloadHDLR,
"vmhd": BoxPayloadVMHD,
"dref": BoxPayloadDREF,
"url": BoxPayloadURL,
"stsd": BoxPayloadSTSD,
"mdat": BoxPayloadMDAT,
"abst": BoxPayloadABST,
"asrt": BoxPayloadASRT,
"afrt": BoxPayloadAFRT,
"skip": BoxPayloadSKIP,
"free": BoxPayloadFREE,
# Containers
"moov": BoxPayloadMOOV,
"moof": BoxPayloadMOOF,
"mvex": BoxPayloadMVEX,
"mdia": BoxPayloadMDIA,
"minf": BoxPayloadMINF,
"meta": BoxPayloadMETA,
"mfra": BoxPayloadMFRA,
"stbl": BoxPayloadSTBL,
"trak": BoxPayloadTRAK,
"dinf": BoxPayloadDINF,
}
livestreamer-1.12.2/src/livestreamer/packages/flashmedia/amf.py 0000644 0001750 0001750 00000006363 12521217321 025662 0 ustar chrippa chrippa 0000000 0000000 from .error import AMFError
from .packet import Packet
from .types import AMF0String, AMF0Value, U8, U16BE, U32BE
class AMFHeader(Packet):
exception = AMFError
def __init__(self, name, value, must_understand=False):
self.name = name
self.value = value
self.must_understand = must_understand
@property
def size(self):
size = 4+1
size += AMF0String.size(self.name)
size += AMF0Value.size(self.value)
return size
def _serialize(self, packet):
packet += AMF0String(self.name)
packet += U8(int(self.must_understand))
packet += U32BE(self.size)
packet += AMF0Value(self.value)
@classmethod
def _deserialize(cls, io):
name = AMF0String.read(io)
must_understand = bool(U8.read(io))
length = U32BE.read(io)
value = AMF0Value.read(io)
return cls(name, value, must_understand)
class AMFMessage(Packet):
exception = AMFError
def __init__(self, target_uri, response_uri, value):
self.target_uri = target_uri
self.response_uri = response_uri
self.value = value
@property
def size(self):
size = 4
size += AMF0String.size(self.target_uri)
size += AMF0String.size(self.response_uri)
size += AMF0Value.size(self.value)
return size
def _serialize(self, packet):
packet += AMF0String(self.target_uri)
packet += AMF0String(self.response_uri)
packet += U32BE(self.size)
packet += AMF0Value.pack(self.value)
@classmethod
def _deserialize(cls, io):
target_uri = AMF0String.read(io)
response_uri = AMF0String.read(io)
length = U32BE.read(io)
value = AMF0Value.read(io)
return cls(target_uri, response_uri, value)
class AMFPacket(Packet):
exception = AMFError
def __init__(self, version, headers=None, messages=None):
if headers is None:
headers = []
if messages is None:
messages = []
self.version = version
self.headers = headers
self.messages = messages
@property
def size(self):
size = 2+2+2
for header in self.headers:
size += header.size
for message in self.messages:
size += message.size
return size
def _serialize(self, packet):
packet += U16BE(self.version)
packet += U16BE(len(self.headers))
for header in self.headers:
header.serialize(packet)
packet += U16BE(len(self.messages))
for message in self.messages:
message.serialize(packet)
@classmethod
def _deserialize(cls, io):
version = U16BE.read(io)
if not version in (0, 3):
raise AMFError("AMF version must be 0 or 3")
headers = []
header_count = U16BE.read(io)
for i in range(header_count):
header = AMFHeader.deserialize(io)
headers.append(header)
messages = []
message_count = U16BE.read(io)
for i in range(message_count):
message = AMFMessage.deserialize(io)
messages.append(message)
return cls(version, headers, messages)
__all__ = ["AMFPacket", "AMFHeader", "AMFMessage"]
livestreamer-1.12.2/src/livestreamer/packages/flashmedia/__init__.py 0000644 0001750 0001750 00000000145 12521217321 026646 0 ustar chrippa chrippa 0000000 0000000 #!/usr/bin/env python
from .error import *
from .amf import *
from .flv import *
from .f4v import *
livestreamer-1.12.2/examples/ 0000755 0001750 0001750 00000000000 12521217500 017206 5 ustar chrippa chrippa 0000000 0000000 livestreamer-1.12.2/examples/gst-player.py 0000755 0001750 0001750 00000007471 12521217321 021664 0 ustar chrippa chrippa 0000000 0000000 #!/usr/bin/env python
from __future__ import print_function
import sys
import gi
from gi.repository import GObject as gobject, Gst as gst
from livestreamer import Livestreamer, StreamError, PluginError, NoPluginError
def exit(msg):
print(msg, file=sys.stderr)
sys.exit()
class LivestreamerPlayer(object):
def __init__(self):
self.fd = None
self.mainloop = gobject.MainLoop()
# This creates a playbin pipeline and using the appsrc source
# we can feed it our stream data
self.pipeline = gst.ElementFactory.make("playbin", None)
self.pipeline.set_property("uri", "appsrc://")
# When the playbin creates the appsrc source it will call
# this callback and allow us to configure it
self.pipeline.connect("source-setup", self.on_source_setup)
# Creates a bus and set callbacks to receive errors
self.bus = self.pipeline.get_bus()
self.bus.add_signal_watch()
self.bus.connect("message::eos", self.on_eos)
self.bus.connect("message::error", self.on_error)
def exit(self, msg):
self.stop()
exit(msg)
def stop(self):
# Stop playback and exit mainloop
self.pipeline.set_state(gst.State.NULL)
self.mainloop.quit()
# Close the stream
if self.fd:
self.fd.close()
def play(self, stream):
# Attempt to open the stream
try:
self.fd = stream.open()
except StreamError as err:
self.exit("Failed to open stream: {0}".format(err))
# Start playback
self.pipeline.set_state(gst.State.PLAYING)
self.mainloop.run()
def on_source_setup(self, element, source):
# When this callback is called the appsrc expects
# us to feed it more data
source.connect("need-data", self.on_source_need_data)
def on_source_need_data(self, source, length):
# Attempt to read data from the stream
try:
data = self.fd.read(length)
except IOError as err:
self.exit("Failed to read data from stream: {0}".format(err))
# If data is empty it's the end of stream
if not data:
source.emit("end-of-stream")
return
# Convert the Python bytes into a GStreamer Buffer
# and then push it to the appsrc
buf = gst.Buffer.new_wrapped(data)
source.emit("push-buffer", buf)
def on_eos(self, bus, msg):
# Stop playback on end of stream
self.stop()
def on_error(self, bus, msg):
# Print error message and exit on error
error = msg.parse_error()[1]
self.exit(error)
def main():
if len(sys.argv) < 3:
exit("Usage: {0} <url> <quality>".format(sys.argv[0]))
# Initialize and check GStreamer version
gi.require_version("Gst", "1.0")
gobject.threads_init()
gst.init(None)
# Collect arguments
url = sys.argv[1]
quality = sys.argv[2]
# Create the Livestreamer session
livestreamer = Livestreamer()
# Enable logging
livestreamer.set_loglevel("info")
livestreamer.set_logoutput(sys.stdout)
# Attempt to fetch streams
try:
streams = livestreamer.streams(url)
except NoPluginError:
exit("Livestreamer is unable to handle the URL '{0}'".format(url))
except PluginError as err:
exit("Plugin error: {0}".format(err))
if not streams:
exit("No streams found on URL '{0}'".format(url))
# Look for specified stream
if quality not in streams:
exit("Unable to find '{0}' stream on URL '{1}'".format(quality, url))
# We found the stream
stream = streams[quality]
# Create the player and start playback
player = LivestreamerPlayer()
# Blocks until playback is done
player.play(stream)
if __name__ == "__main__":
main()
livestreamer-1.12.2/docs/ 0000755 0001750 0001750 00000000000 12521217500 016320 5 ustar chrippa chrippa 0000000 0000000 livestreamer-1.12.2/docs/twitch_oauth.rst 0000644 0001750 0001750 00000001576 12521217321 021566 0 ustar chrippa chrippa 0000000 0000000 .. _twitch_oauth:
Twitch OAuth authentication
===========================
.. raw:: html
<!-- Some themes include jquery after our code... -->
<script type="text/javascript" src="_static/jquery.js"></script>
<script type="text/javascript">
$(function() {
var el = $(".highlight");
var params = (window.location.hash.substr(1)).split("&");
for (i = 0; i < params.length; i++) {
var keyval = params[i].split("=");
if (keyval[0] == "access_token")
{
el.html('<pre>twitch-oauth-token<span class="o">=</span>' + keyval[1] + '</pre>');
}
}
});
</script>
You successfully authenticated Livestreamer with Twitch.
Paste this into your :ref:`configuration file <cli-livestreamerrc>`:
.. code-block:: bash
twitch-oauth-token=
livestreamer-1.12.2/docs/plugin_matrix.rst 0000644 0001750 0001750 00000013636 12521217321 021746 0 ustar chrippa chrippa 0000000 0000000 .. _plugin_matrix:
Plugins
=======
This is a list of the currently built in plugins and what URLs and features
they support. Livestreamer's primary focus is live streams, so VOD support
is limited.
=================== ==================== ===== ===== ===========================
Name URL(s) Live VOD Notes
=================== ==================== ===== ===== ===========================
afreeca afreecatv.com Yes No
afreecatv afreeca.tv Yes No
aftonbladet aftonbladet.se Yes Yes
alieztv aliez.tv Yes Yes
ard_live live.daserste.de Yes -- Streams may be geo-restricted to Germany.
ard_mediathek ardmediathek.de Yes Yes Streams may be geo-restricted to Germany.
artetv arte.tv Yes Yes
azubutv azubu.tv Yes No
beattv be-at.tv Yes Yes Playlist not implemented yet.
bambuser bambuser.com Yes Yes
chaturbate chaturbate.com Yes No
connectcast connectcast.tv Yes Yes
crunchyroll crunchyroll.com -- Yes
cybergame cybergame.tv Yes Yes
dailymotion dailymotion.com Yes Yes
disney_de - video.disney.de Yes Yes Streams may be geo-restricted to Germany.
- disneychannel.de
dommune dommune.com Yes --
douyutv douyutv.com Yes --
dmcloud api.dmcloud.net Yes --
drdk dr.dk Yes Yes Streams may be geo-restricted to Denmark.
euronews euronews.com Yes No
filmon filmon.com Yes Yes Only SD quality streams.
filmon_us filmon.us Yes Yes
furstream furstre.am Yes No
gaminglive gaminglive.tv Yes Yes
gomexp gomexp.com Yes No
goodgame goodgame.ru Yes No Only HLS streams are available.
hitbox hitbox.tv Yes Yes
itvplayer itv.com/itvplayer Yes Yes Streams may be geo-restricted to Great Britain.
letontv leton.tv Yes --
livestation livestation.com Yes --
livestream new.livestream.com Yes --
media_ccc_de - media.ccc.de Yes Yes Only mp4 and HLS ar are supported.
- streaming... [4]_
mips mips.tv Yes -- Requires rtmpdump with K-S-V patches.
mlgtv mlg.tv Yes --
nhkworld nhk.or.jp/nhkworld Yes No
nos nos.nl Yes Yes Streams may be geo-restricted to Netherlands.
npo npo.nl Yes Yes Streams may be geo-restricted to Netherlands.
nrk - tv.nrk.no Yes Yes Streams may be geo-restricted to Norway.
- radio.nrk.no
oldlivestream original.liv... [3]_ Yes No Only mobile streams are supported.
periscope periscope.tv Yes --
picarto picarto.tv Yes --
rtve rtve.es Yes No
sbsdiscovery - kanal5play.se -- Yes
- kanal9play.se
- kanal11play.se
seemeplay seemeplay.ru Yes Yes
speedrunslive speedrunslive.com Yes -- URL forwarder to Twitch channels.
ssh101 ssh101.com Yes No
streamingvi... [1]_ streamingvid... [2]_ Yes -- RTMP streams requires rtmpdump with
K-S-V patches.
streamlive streamlive.to Yes --
svtplay - svtplay.se Yes Yes Streams may be geo-restricted to Sweden.
- svtflow.se
- oppetarkiv.se
tga - star.plu.cn Yes No
- star.tga.plu.cn
tv3cat tv3.cat Yes Yes Streams may be geo-restricted to Spain.
tv4play - tv4play.se Yes Yes Streams may be geo-restricted to Sweden.
Only non-premium streams currently supported.
- fotbollskanalen.se
tvcatchup - tvcatchup.com Yes No Streams may be geo-restricted to Great Britain.
tvplayer tvplayer.com Yes No
twitch twitch.tv Yes Yes Possible to authenticate for access to
subscription streams.
ustreamtv ustream.tv Yes Yes
vaughnlive - vaughnlive.tv Yes --
- breakers.tv
- instagib.tv
- vapers.tv
veetle veetle.com Yes Yes
vgtv vgtv.no Yes Yes
viagame viagame.com
viasat - tv3play.se Yes Yes Streams may be geo-restricted.
- tv3play.no
- tv3play.dk
- tv3play.ee
- tv3play.lt
- tv3play.lv
- tv6play.se
- tv6play.no
- tv8play.se
- tv10play.se
- viasat4play.no
- play.tv3.lt
- juicyplay.se
wattv wat.tv -- Yes
weeb weeb.tv Yes -- Requires rtmpdump with K-S-V patches.
youtube - youtube.com Yes Yes Protected videos are not supported.
- youtu.be
zdf_mediathek zdf.de Yes Yes
=================== ==================== ===== ===== ===========================
.. [1] streamingvideoprovider
.. [2] streamingvideoprovider.co.uk
.. [3] original.livestream.com
.. [4] streaming.media.ccc.de
livestreamer-1.12.2/docs/players.rst 0000644 0001750 0001750 00000006747 12521217321 020550 0 ustar chrippa chrippa 0000000 0000000 .. _players:
Players
=======
Transport modes
---------------
There are three different modes of transporting the stream to the player.
====================== =========================================================
Name Description
====================== =========================================================
Standard input pipe This is the default behaviour when there are no other
options specified.
Named pipe (FIFO) Use the :option:`--player-fifo` option to enable.
HTTP Use the :option:`--player-http` or
:option:`--player-continuous-http` options to enable.
====================== =========================================================
Player compatibility
--------------------
This is a list of video players and their compatibility with the transport
modes.
===================================================== ========== ========== ====
Name Stdin Pipe Named Pipe HTTP
===================================================== ========== ========== ====
`Daum Pot Player <http://potplayer.daum.net>`_ No No Yes [1]_
`MPC-HC <http://mpc-hc.org/>`_ Yes [2]_ No Yes [1]_
`MPlayer <http://mplayerhq.hu>`_ Yes Yes Yes
`MPlayer2 <http://mplayer2.org>`_ Yes Yes Yes
`mpv <http://mpv.io>`_ Yes Yes Yes
`QuickTime <http://apple.com/quicktime>`_ No No No
`VLC media player <http://videolan.org>`_ Yes [3]_ Yes Yes
===================================================== ========== ========== ====
.. [1] :option:`--player-continuous-http` must be used.
Using HTTP with players that rely on Windows' codecs to access HTTP
streams may have a long startup time since Windows tend to do multiple
HTTP requests and Livestreamer will attempt to open the stream for each
request.
.. [2] Stdin requires MPC-HC 1.7 or newer.
.. [3] Some versions of VLC might be unable to use the stdin pipe and
prints the error message::
VLC is unable to open the MRL 'fd://0'
Use one of the other transport methods instead to work around this.
Known issues and workarounds
----------------------------
MPC-HC reports "File not found"
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Upgrading to version 1.7 or newer will solve this issue since reading data
from standard input is not supported in version 1.6.x of MPC-HC.
MPC-HC only plays sound on Twitch streams
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Twitch sometimes returns badly muxed streams which may confuse players. The
following workaround was contributed by MPC-HC developer @kasper93:
*To fix this problem go to options -> internal filters -> open splitter
settings and increase "Stream Analysis Duration" this will let ffmpeg to
properly detect all streams.*
Using :option:`--player-passthrough hls <--player-passthrough>` has also been
reported to work.
MPlayer tries to play Twitch streams at the wrong FPS
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
This is a bug in MPlayer, using the MPlayer fork `mpv <http://mpv.io>`_ instead
is recommended.
VLC hangs when buffering and no playback starts
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Some versions of 64-bit VLC seem to be unable to read the stream created by
rtmpdump. Using the 32-bit version of VLC might help.
livestreamer-1.12.2/docs/issues.rst 0000644 0001750 0001750 00000004307 12521217321 020372 0 ustar chrippa chrippa 0000000 0000000 .. _issues:
Common issues
=============
.. _issues-player_caching:
Streams are buffering/lagging
-----------------------------
Enable caching in your player
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
By default most players do not cache the data they receieve from Livestreamer.
Caching can reduce the amount of buffering you run into because the player will
have some breathing room between receving the data and playing it.
============= ======================== ======================================
Player Parameter Note
============= ======================== ======================================
MPC-HC -- Currently no way of configuring the cache
MPlayer ``-cache <kbytes>`` Between 1024 and 8192 is recommended
MPlayer2 ``-cache <kbytes>`` Between 1024 and 8192 is recommended
mpv ``--cache <kbytes>`` Between 1024 and 8192 is recommended
VLC ``--file-caching <ms> Between 1000 and 10000 is recommended
--network-caching <ms>``
============= ======================== ======================================
Use the :option:`--player` option to pass these options to your player.
Multi-threaded streaming
^^^^^^^^^^^^^^^^^^^^^^^^
On segmented streaming protocols (such as HLS and HDS) it's possible to use
multiple threads to potentially increase the throughput.
Each stream type has it's own option, these options are currently available:
=================================== ============================================
Option Used by these plugins
=================================== ============================================
:option:`--hls-segment-threads` `twitch`, `youtube` and many more.
:option:`--hds-segment-threads` `dailymotion`, `mlgtv` and many more.
:option:`--stream-segment-threads` `ustreamtv`, `beattv` and any other plugins
implementing their own segmented streaming
protocol.
=================================== ============================================
.. note::
Using 2 or 3 threads should be enough to see an impact on live streams,
any more will likely not show much effect.
livestreamer-1.12.2/docs/install.rst 0000644 0001750 0001750 00000023110 12521217321 020516 0 ustar chrippa chrippa 0000000 0000000 .. _install:
Installation
============
Linux and BSD packages
----------------------
==================================== ===========================================
Distribution Installing
==================================== ===========================================
`Arch Linux (package)`_ .. code-block:: console
# pacman -S livestreamer
`Arch Linux (aur, git)`_ `Installing AUR packages`_
`CRUX`_ .. code-block:: console
$ cd /usr/ports/contrib/livestreamer
# pkgmk -d -i
`Debian`_ .. code-block:: console
# apt-get install livestreamer
`Exherbo Linux`_
`Fedora`_ .. code-block:: console
# yum install livestreamer
`FreeBSD (package)`_ .. code-block:: console
# pkg install multimedia/livestreamer
`FreeBSD (ports)`_ .. code-block:: console
$ cd /usr/ports/multimedia/livestreamer
# make install clean
`Gentoo Linux`_ .. code-block:: console
# emerge net-misc/livestreamer
`NetBSD (pkgsrc)`_ .. code-block:: console
$ cd /usr/pkgsrc/multimedia/livestreamer
# make install clean
`OpenBSD (package)`_ .. code-block:: console
# pkg_add livestreamer
`OpenBSD (ports)`_ .. code-block:: console
$ cd /usr/ports/multimedia/livestreamer
# make install clean
`Slackware Linux`_ `Installing Slackbuilds`_
`Ubuntu`_ .. code-block:: console
# apt-get install livestreamer
==================================== ===========================================
.. _Arch Linux (package): https://archlinux.org/packages/?q=livestreamer
.. _Arch Linux (aur, git): https://aur.archlinux.org/packages/livestreamer-git/
.. _CRUX: http://crux.nu/portdb/?a=search&q=livestreamer
.. _Debian: https://packages.debian.org/search?keywords=livestreamer&searchon=names&exact=1&suite=all§ion=all
.. _Exherbo Linux: http://git.exherbo.org/summer/packages/media/livestreamer/index.html
.. _Fedora: https://admin.fedoraproject.org/pkgdb/package/livestreamer/
.. _FreeBSD (package): http://www.freshports.org/multimedia/livestreamer
.. _FreeBSD (ports): http://www.freshports.org/multimedia/livestreamer
.. _Gentoo Linux: https://packages.gentoo.org/package/net-misc/livestreamer
.. _NetBSD (pkgsrc): http://pkgsrc.se/multimedia/livestreamer
.. _OpenBSD (package): http://openports.se/multimedia/livestreamer
.. _OpenBSD (ports): http://openports.se/multimedia/livestreamer
.. _Slackware Linux: http://slackbuilds.org/result/?search=livestreamer
.. _Ubuntu: http://packages.ubuntu.com/search?keywords=livestreamer&searchon=names&exact=1&suite=all§ion=all
.. _Installing AUR packages: https://wiki.archlinux.org/index.php/Arch_User_Repository#Installing_packages
.. _Installing Slackbuilds: http://slackbuilds.org/howto/
Other platforms
---------------
==================================== ===========================================
Platform Installing
==================================== ===========================================
Mac OS X .. code-block:: console
# easy_install -U livestreamer
Microsoft Windows See `Windows binaries`_.
==================================== ===========================================
Source code
-----------
If a package is not available for your platform (or it's out of date) you
can install Livestreamer via source.
There are a few different methods to do this,
`pip <http://pip.readthedocs.org/en/latest/installing.html>`_ the Python package
manager, :command:`easy_install` the older package manager included with
`python-setuptools`_ or by checking out the latest code with
`Git <http://git-scm.com/downloads>`_.
The commands listed here will also upgrade any existing version of Livestreamer.
==================================== ===========================================
Version Installing
==================================== ===========================================
`Latest release (pip)`_ .. code-block:: console
# pip install -U livestreamer
`Latest release (easy_install)`_ .. code-block:: console
# easy_install -U livestreamer
`Development version (pip)`_ .. code-block:: console
# pip install -U git+https://github.com/chrippa/livestreamer.git
`Development version (git)`_ .. code-block:: console
$ git clone git://github.com/chrippa/livestreamer.git
$ cd livestreamer
# python setup.py install
==================================== ===========================================
.. _Latest release (pip): https://pypi.python.org/pypi/livestreamer
.. _Latest release (easy_install): https://pypi.python.org/pypi/livestreamer
.. _Development version (pip): https://github.com/chrippa/livestreamer
.. _Development version (git): https://github.com/chrippa/livestreamer
Dependencies
^^^^^^^^^^^^
To install Livestreamer from source you will need these dependencies.
==================================== ===========================================
Name Notes
==================================== ===========================================
`Python`_ At least version **2.6** or **3.3**.
`python-setuptools`_
**Automatically installed by the setup script**
--------------------------------------------------------------------------------
`python-argparse`_ Only needed on Python **2.6**.
`python-futures`_ Only needed on Python **2.x**.
`python-requests`_ At least version **1.0**.
`python-singledispatch`_ Only needed on Python versions older than **3.4**.
**Optional**
--------------------------------------------------------------------------------
`RTMPDump`_ Required to play RTMP streams.
`PyCrypto`_ Required to play some encrypted streams.
`python-librtmp`_ Required by the *ustreamtv* plugin to be
able to use non-mobile streams.
==================================== ===========================================
.. _Python: http://python.org/
.. _python-setuptools: http://pypi.python.org/pypi/setuptools
.. _python-argparse: http://pypi.python.org/pypi/argparse
.. _python-futures: http://pypi.python.org/pypi/futures
.. _python-requests: http://python-requests.org/
.. _python-singledispatch: http://pypi.python.org/pypi/singledispatch
.. _RTMPDump: http://rtmpdump.mplayerhq.hu/
.. _PyCrypto: https://www.dlitz.net/software/pycrypto/
.. _python-librtmp: https://github.com/chrippa/python-librtmp
Installing without root permissions
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
If you do not wish to install Livestreamer globally on your system it's
recommended to use `virtualenv`_ to create a user owned Python environment
instead.
.. code-block:: console
Creating an environment
$ virtualenv ~/myenv
Activating the environment
$ source ~/myenv/bin/activate
Installing livestreamer into the environment
(myenv)$ pip install livestreamer
Using livestreamer in the enviroment
(myenv)$ livestreamer ...
Deactivating the enviroment
(myenv)$ deactivate
Using livestreamer without activating the environment
$ ~/myenv/bin/livestreamer ...
.. note::
This may also be required on some OS X versions that seems to have weird
permission issues (see issue #401).
.. _virtualenv: http://virtualenv.readthedocs.org/en/latest/
Windows binaries
----------------
:releaseref:`Installer <https://github.com/chrippa/livestreamer/releases/download/v|release|/livestreamer-v|release|-win32-setup.exe>`
^^^^^^^^^^^^^^^^^^^^^^
This is a installer which contains:
- A compiled version of Livestreamer that does not require an existing Python
installation
- `RTMPDump`_ for viewing RTMP streams
and performs the following tasks:
- Generates a default :ref:`configuration file <cli-livestreamerrc>`
- Adds Livestreamer to your ``$PATH`` (making it possible to use
:command:`livestreamer` directly from the command prompt without specifying
its directory)
:releaseref:`Zip archive <https://github.com/chrippa/livestreamer/releases/download/v|release|/livestreamer-v|release|-win32.zip>`
^^^^^^^^^^^^^^^^^^^^^^^^
This is minimal zip archive containing a compiled version of Livestreamer that
does not require an existing Python installation.
`Nightly build`_
^^^^^^^^^^^^^^^^
This is an automatically generated build of the latest development code
from the git repo.
.. _Nightly build: http://livestreamer-builds.s3.amazonaws.com/livestreamer-latest-win32.zip
.. note::
The binaries requires `Microsoft Visual C++ 2008 Redistributable
Package <http://www.microsoft.com/en-us/download/details.aspx?id=29>`_ to
be installed.
livestreamer-1.12.2/docs/index.rst 0000644 0001750 0001750 00000003764 12521217321 020174 0 ustar chrippa chrippa 0000000 0000000 Overview
--------
Livestreamer is a :ref:`command-line utility <cli>` that pipes video streams
from various services into a video player, such as `VLC <http://videolan.org/>`_.
The main purpose of Livestreamer is to allow the user to avoid buggy and CPU
heavy flash plugins but still be able to enjoy various streamed content.
There is also an :ref:`API <api_guide>` available for developers who want access
to the video stream data.
- Latest release: |version| (:ref:`changelog`)
- GitHub: https://github.com/chrippa/livestreamer
- Issue tracker: https://github.com/chrippa/livestreamer/issues
- PyPI: https://pypi.python.org/pypi/livestreamer
- Discussions: https://groups.google.com/forum/#!forum/livestreamer
- IRC: #livestreamer @ Freenode
- Free software: Simplified BSD license
Features
--------
Livestreamer is built upon a plugin system which allows support for new services
to be easily added. Currently most of the big streaming services are supported,
such as:
- `Dailymotion <http://dailymotion.com/live>`_
- `Livestream <http://livestream.com>`_
- `Twitch <http://twitch.tv>`_
- `UStream <http://ustream.tv>`_
- `YouTube Live <http://youtube.com>`_
... and many more. A full list of plugins currently included can be found
on the :ref:`plugin_matrix` page.
Quickstart
-----------
The default behaviour of Livestreamer is to playback a stream in the default
player (`VLC <http://videolan.org/>`_).
.. sourcecode:: console
# pip install livestreamer
$ livestreamer twitch.tv/day9tv best
[cli][info] Found matching plugin twitch for URL twitch.tv/day9tv
[cli][info] Opening stream: source (hls)
[cli][info] Starting player: vlc
For more in-depth usage and install instructions see the `User guide`_.
User guide
----------
Livestreamer is made up of two parts, a :ref:`cli` and a library :ref:`API <api>`.
See their respective sections for more information on how to use them.
.. toctree::
:maxdepth: 2
install
cli
plugin_matrix
players
issues
api_guide
api
livestreamer-1.12.2/docs/ext_releaseref.py 0000644 0001750 0001750 00000001332 12521217321 021667 0 ustar chrippa chrippa 0000000 0000000 """Creates links that allows substituting the current release
within the title or target."""
import os.path
from docutils import nodes
from sphinx.util.nodes import split_explicit_title
def releaseref_role(name, rawtext, text, lineno, inliner, options={}, content=[]):
config = inliner.document.settings.env.config
text = text.replace("|version|", config.version)
text = text.replace("|release|", config.release)
has_explicit_title, title, target = split_explicit_title(text)
if not has_explicit_title:
title = os.path.basename(target)
node = nodes.reference(rawtext, title, refuri=target, **options)
return [node], []
def setup(app):
app.add_role("releaseref", releaseref_role)
livestreamer-1.12.2/docs/ext_github.py 0000644 0001750 0001750 00000004107 12521217321 021037 0 ustar chrippa chrippa 0000000 0000000 """Creates Github links from @user and #issue text.
Bascially a much simplified version of sphinxcontrib.issuetracker
with support for @user.
"""
import re
import sys
from docutils import nodes
from docutils.transforms import Transform
GITHUB_ISSUE_URL = "https://github.com/{0}/issues/{1}"
GITHUB_USER_URL = "https://github.com/{1}"
if sys.version_info[0] == 2:
str = unicode
class GithubReferences(Transform):
default_priority = 999
def apply(self):
config = self.document.settings.env.config
issue_re = re.compile(config.github_issue_pattern)
mention_re = re.compile(config.github_mention_pattern)
self._replace_pattern(issue_re, GITHUB_ISSUE_URL)
self._replace_pattern(mention_re, GITHUB_USER_URL)
def _replace_pattern(self, pattern, url_format):
project = self.document.settings.env.config.github_project
for node in self.document.traverse(nodes.Text):
parent = node.parent
if isinstance(parent, (nodes.literal, nodes.FixedTextElement)):
continue
text = str(node)
new_nodes = []
last_ref_end = 0
for match in pattern.finditer(text):
head = text[last_ref_end:match.start()]
if head:
new_nodes.append(nodes.Text(head))
last_ref_end = match.end()
ref = url_format.format(project, match.group(1))
link = nodes.reference(
match.group(0),
match.group(0),
refuri=ref
)
new_nodes.append(link)
if not new_nodes:
continue
tail = text[last_ref_end:]
if tail:
new_nodes.append(nodes.Text(tail))
parent.replace(node, new_nodes)
def setup(app):
app.add_config_value("github_project", None, "env")
app.add_config_value("github_issue_pattern", r"#(\d+)", "env")
app.add_config_value("github_mention_pattern", r"@(\w+)", "env")
app.add_transform(GithubReferences)
livestreamer-1.12.2/docs/ext_argparse.py 0000644 0001750 0001750 00000011040 12521217321 021353 0 ustar chrippa chrippa 0000000 0000000 """Convert a argparse parser to option directives.
Inspired by sphinxcontrib.autoprogram but with a few differences:
- Instead of relying on private argparse structures uses hooking
to extract information from a argparse parser.
- Contains some simple pre-processing on the help messages to make
the Sphinx version a bit prettier.
"""
import argparse
import re
from collections import namedtuple
from textwrap import dedent
from docutils import nodes
from docutils.parsers.rst.directives import unchanged
from docutils.statemachine import ViewList
from sphinx.util.nodes import nested_parse_with_titles
from sphinx.util.compat import Directive
_ArgumentParser = argparse.ArgumentParser
_Argument = namedtuple("Argument", ["args", "options"])
_block_re = re.compile(r":\n{2}\s{2}")
_default_re = re.compile(r"Default is (.+)\.\n")
_note_re = re.compile(r"Note: (.*)\n\n", re.DOTALL)
_option_re = re.compile(r"(--[\w-]+)")
class ArgumentParser(object):
def __init__(self, *args, **kwargs):
self.args = args
self.kwargs = kwargs
self.groups = []
self.arguments = []
def add_argument(self, *args, **options):
if not options.get("help") == argparse.SUPPRESS:
self.arguments.append(_Argument(args, options))
def add_argument_group(self, *args, **options):
group = ArgumentParser(*args, **options)
self.groups.append(group)
return group
def get_parser(module_name, attr):
argparse.ArgumentParser = ArgumentParser
module = __import__(module_name, globals(), locals(), [attr])
argparse.ArgumentParser = _ArgumentParser
return getattr(module, attr)
def indent(value, length=4):
space = " " * length
return "\n".join(space + line for line in value.splitlines())
class ArgparseDirective(Directive):
has_content = True
option_spec = {
"module": unchanged,
"attr": unchanged,
}
def process_help(self, help):
# Dedent the help to make sure we are always dealing with
# non-indented text.
help = dedent(help)
# Create simple blocks.
help = _block_re.sub("::\n\n ", help)
# Boldify the default value.
help = _default_re.sub(r"Default is: **\1**.\n", help)
# Create note directives from "Note: " paragraphs.
help = _note_re.sub(
lambda m: ".. note::\n\n" + indent(m.group(1)) + "\n\n",
help
)
# Replace option references with links.
help = _option_re.sub(
lambda m: (
":option:`{0}`".format(m.group(1))
if m.group(1) in self._available_options
else m.group(1)
),
help
)
return indent(help)
def generate_group_rst(self, group):
for arg in group.arguments:
help = arg.options.get("help")
metavar = arg.options.get("metavar")
if isinstance(metavar, tuple):
metavar = " ".join(metavar)
if metavar:
optional = arg.options.get("nargs") == "?"
if optional:
metavar = "[{0}]".format(metavar)
options = []
for a in arg.args:
if a.startswith("-"):
options.append("{0} {1}".format(a, metavar))
else:
options.append(metavar)
else:
options = arg.args
yield ".. option:: {0}".format(", ".join(options))
yield ""
for line in self.process_help(help).split("\n"):
yield line
yield ""
def generate_parser_rst(self, parser):
for group in parser.groups:
title = group.args[0]
yield ""
yield title
yield "^" * len(title)
for line in self.generate_group_rst(group):
yield line
def run(self):
module = self.options.get("module")
attr = self.options.get("attr")
parser = get_parser(module, attr)
self._available_options = []
for group in parser.groups:
for arg in group.arguments:
self._available_options += arg.args
node = nodes.section()
node.document = self.state.document
result = ViewList()
for line in self.generate_parser_rst(parser):
result.append(line, "argparse")
nested_parse_with_titles(self.state, result, node)
return node.children
def setup(app):
app.add_directive("argparse", ArgparseDirective)
livestreamer-1.12.2/docs/conf.py 0000644 0001750 0001750 00000014603 12521217321 017624 0 ustar chrippa chrippa 0000000 0000000 #!/usr/bin/env python3
# -*- coding: utf-8 -*-
import os
import sys
from livestreamer import __version__ as livestreamer_version
# If extensions (or modules to document with autodoc) are in another directory,
# add these directories to sys.path here. If the directory is relative to the
# documentation root, use os.path.abspath to make it absolute, like shown here.
sys.path.insert(0, os.path.abspath('.'))
# -- General configuration -----------------------------------------------------
# If your documentation needs a minimal Sphinx version, state it here.
#needs_sphinx = '1.0'
# Add any Sphinx extension module names here, as strings. They can be extensions
# coming with Sphinx (named 'sphinx.ext.*') or your custom ones.
extensions = ['sphinx.ext.autodoc', 'ext_argparse', 'ext_github', 'ext_releaseref']
# Add any paths that contain templates here, relative to this directory.
templates_path = ['_templates']
# The suffix of source filenames.
source_suffix = '.rst'
# The encoding of source files.
#source_encoding = 'utf-8-sig'
# The master toctree document.
master_doc = 'index'
# General information about the project.
project = 'Livestreamer'
copyright = '2011-2015, Christopher Rosell'
# The version info for the project you're documenting, acts as replacement for
# |version| and |release|, also used in various other places throughout the
# built documents.
#
# The short X.Y version.
version = livestreamer_version
# The full version, including alpha/beta/rc tags.
release = livestreamer_version
# The language for content autogenerated by Sphinx. Refer to documentation
# for a list of supported languages.
#language = None
# There are two options for replacing |today|: either, you set today to some
# non-false value, then it is used:
#today = ''
# Else, today_fmt is used as the format for a strftime call.
#today_fmt = '%B %d, %Y'
# List of patterns, relative to source directory, that match files and
# directories to ignore when looking for source files.
exclude_patterns = ['_build']
# The reST default role (used for this markup: `text`) to use for all documents.
#default_role = None
# If true, '()' will be appended to :func: etc. cross-reference text.
#add_function_parentheses = True
# If true, the current module name will be prepended to all description
# unit titles (such as .. function::).
#add_module_names = True
# If true, sectionauthor and moduleauthor directives will be shown in the
# output. They are ignored by default.
#show_authors = False
# The name of the Pygments (syntax highlighting) style to use.
#pygments_style = 'sphinx'
# A list of ignored prefixes for module index sorting.
#modindex_common_prefix = []
github_project = 'chrippa/livestreamer'
# -- Options for HTML output ---------------------------------------------------
sys.path.append(os.path.abspath('_themes'))
html_theme_path = ['_themes']
html_theme = 'sphinx_rtd_theme_violet'
html_theme_options = {
"oneliner": (
"Command-line utility that extracts streams from various services "
"and pipes them into a video player of choice."
),
"github_user": "chrippa",
"github_repo": "livestreamer",
"sticky_navigation": True
}
# The theme to use for HTML and HTML Help pages. See the documentation for
# a list of builtin themes.
#html_theme = 'default'
# Theme options are theme-specific and customize the look and feel of a theme
# further. For a list of options available for each theme, see the
# documentation.
# html_theme_options = { "github_fork": "chrippa/livestreamer" }
# Add any paths that contain custom themes here, relative to this directory.
#html_theme_path = []
# The name for this set of Sphinx documents. If None, it defaults to
# "<project> v<release> documentation".
#html_title = None
# A shorter title for the navigation bar. Default is the same as html_title.
#html_short_title = None
# The name of an image file (relative to this directory) to place at the top
# of the sidebar.
#html_logo = None
# The name of an image file (within the static path) to use as favicon of the
# docs. This file should be a Windows icon file (.ico) being 16x16 or 32x32
# pixels large.
#html_favicon = None
# Add any paths that contain custom static files (such as style sheets) here,
# relative to this directory. They are copied after the builtin static files,
# so a file named "default.css" will overwrite the builtin "default.css".
html_static_path = ['_static']
# If not '', a 'Last updated on:' timestamp is inserted at every page bottom,
# using the given strftime format.
#html_last_updated_fmt = '%b %d, %Y'
# If true, SmartyPants will be used to convert quotes and dashes to
# typographically correct entities.
#html_use_smartypants = True
# Custom sidebar templates, maps document names to template names.
#html_sidebars = {}
#html_sidebars = {
# 'index': ['sidebarintro.html', 'sourcelink.html', 'searchbox.html'],
# '**': ['sidebarlogo.html', 'localtoc.html', 'relations.html',
# 'sourcelink.html', 'searchbox.html']
#}
# Additional templates that should be rendered to pages, maps page names to
# template names.
#html_additional_pages = {}
# If false, no module index is generated.
html_domain_indices = False
# If false, no index is generated.
#html_use_index = True
# If true, the index is split into individual pages for each letter.
#html_split_index = False
# If true, links to the reST sources are added to the pages.
html_show_sourcelink = False
# If true, "Created using Sphinx" is shown in the HTML footer. Default is True.
#html_show_sphinx = True
# If true, "(C) Copyright ..." is shown in the HTML footer. Default is True.
#html_show_copyright = True
# If true, an OpenSearch description file will be output, and all pages will
# contain a <link> tag referring to it. The value of this option must be the
# base URL from which the finished HTML is served.
#html_use_opensearch = ''
# This is the file name suffix for HTML files (e.g. ".xhtml").
#html_file_suffix = None
# Output file base name for HTML help builder.
htmlhelp_basename = 'livestreamerdoc'
# -- Options for manual page output --------------------------------------------
# One entry per manual page. List of tuples
# (source start file, name, description, authors, manual section).
man_pages = [
('cli', 'livestreamer', 'extracts streams from various services and pipes them into a video player of choice', ['Christopher Rosell'], 1)
]
# If true, show URL addresses after external links.
#man_show_urls = False
livestreamer-1.12.2/docs/cli.rst 0000644 0001750 0001750 00000024206 12521217321 017626 0 ustar chrippa chrippa 0000000 0000000 .. _cli:
Command-Line Interface
======================
Tutorial
--------
Livestreamer is command-line application, this means the commands described
here should be typed into a terminal. On Windows this means you should open
the `command prompt`_ or `PowerShell`_, on Mac OS X open the `Terminal`_ app
and if you're on Linux or BSD you probably already know the drill.
The way Livestreamer works is that it's only a means to extract and transport
the streams, and the playback is done by an external video player. Livestreamer
works best with `VLC`_ or `mpv`_, which are also cross-platform, but other players
may be compatible too, see the :ref:`Players` page for a complete overview.
Now to get into actually using Livestreamer, let's say you want to watch the
stream located on http://twitch.tv/day9tv, you start off by telling Livestreamer
where to attempt to extract streams from. This is done by giving the URL to the
command :command:`livestreamer` as the first argument:
.. code-block:: console
$ livestreamer twitch.tv/day9tv
[cli][info] Found matching plugin twitch for URL twitch.tv/day9tv
Available streams: audio, high, low, medium, mobile (worst), source (best)
.. note::
You don't need to include the protocol when dealing with HTTP URLs,
e.g. just ``twitch.tv/day9tv`` is enough and quicker to type.
This command will tell Livestreamer to attempt to extract streams from the URL
specified, and if it's successful, print out a list of available streams to choose
from.
To select a stream and start playback, we simply add the stream name as a second
argument to the :command:`livestreamer` command:
.. sourcecode:: console
$ livestreamer twitch.tv/day9tv source
[cli][info] Found matching plugin twitch for URL twitch.tv/day9tv
[cli][info] Opening stream: source (hls)
[cli][info] Starting player: vlc
The stream you chose should now be playing in the player. It's a common use case
to just want start the highest quality stream and not be bothered with what it's
named. To do this just specify ``best`` as the stream name and Livestreamer will
attempt to rank the streams and open the one of highest quality. You can also
specify ``worst`` to get the lowest quality.
Now that you have a basic grasp of how Livestreamer works, you may want to look
into customizing it to your own needs, such as:
- Creating a :ref:`configuration file <cli-livestreamerrc>` of options you
want to use
- Setting up your player to :ref:`cache some data <issues-player_caching>`
before playing the stream to help avoiding buffering issues
.. _command prompt: http://windows.microsoft.com/en-us/windows/command-prompt-faq#1TC=windows-8
.. _PowerShell: http://www.microsoft.com/powershell
.. _Terminal: http://en.wikipedia.org/wiki/Terminal_(OS_X)
.. _VLC: http://videolan.org/
.. _mpv: http://mpv.io/
.. _cli-livestreamerrc:
Configuration file
------------------
Writing the command-line options every time is inconvenient, that's why Livestreamer
is capable of reading options from a configuration file instead.
Livestreamer will look for config files in different locations depending on
your platform:
================= ====================================================
Platform Location
================= ====================================================
Unix-like (POSIX) - $XDG_CONFIG_HOME/livestreamer/config
- ~/.livestreamerrc
Windows %APPDATA%\\livestreamer\\livestreamerrc
================= ====================================================
You can also specify the location yourself using the :option:`--config` option.
.. note::
- `$XDG_CONFIG_HOME` is ``~/.config`` if it has not been overridden
- `%APPDATA%` is usually ``<your user directory>\Application Data``
.. note::
On Windows there is a default config created by the installer but on any
other platform you must create the file yourself.
Syntax
^^^^^^
The config file is a simple text file and should contain one
:ref:`command-line option <cli-options>` (omitting the dashes) per
line in the format::
option=value
or for a option without value::
option
.. note::
Any quotes used will be part of the value, so only use when the value needs them,
e.g. specifiying a player with a path containing spaces.
Example
^^^^^^^
.. code-block:: bash
# Player options
player=mpv --cache 2048
player-no-close
# Authenticate with Twitch
twitch-oauth-token=mytoken
Plugin specific configuration file
----------------------------------
You may want to use specific options for some plugins only. This
can be accomplished by placing those settings inside a plugin specific
config file. Options inside these config files will override the main
config file when a URL matching the plugin is used.
Livestreamer expects this config to be named like the main config but
with ``.<plugin name>`` attached to the end.
Examples
^^^^^^^^
================= ====================================================
Platform Location
================= ====================================================
Unix-like (POSIX) - $XDG_CONFIG_HOME/livestreamer/config\ **.twitch**
- ~/.livestreamerrc\ **.ustreamtv**
Windows %APPDATA%\\livestreamer\\livestreamerrc\ **.youtube**
================= ====================================================
Have a look at the :ref:`list of plugins <plugin_matrix>` to see
the name of each built-in plugin.
Plugin specific usage
---------------------
Authenticating with Twitch
^^^^^^^^^^^^^^^^^^^^^^^^^^
It's possible to access subscription content on Twitch by giving Livestreamer
access to your account.
Authentication is done by creating an OAuth token that Livestreamer will
use to access your account. It's done like this:
.. sourcecode:: console
$ livestreamer --twitch-oauth-authenticate
This will open a web browser where Twitch will ask you if you want to give
Livestreamer permission to access your account, then forwards you to a page
with further instructions on how to use it.
Authenticating with Crunchyroll
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Crunchyroll requires authenticating with a premium account to access some of
their content. To do so, the plugin provides a couple of options to input your
information, :option:`--crunchyroll-username` and :option:`--crunchyroll-password`.
You can login like this:
.. sourcecode:: console
$ livestreamer --crunchyroll-username=xxxx --crunchyroll-password=xxx http://crunchyroll.com/a-crunchyroll-episode-link
.. note::
If you omit the password, livestreamer will ask for it.
Once logged in, the plugin makes sure to save the session credentials to avoid
asking your username and password again.
Neverthless, these credentials are valid for a limited amount of time, so it
might be a good idea to save your username and password in your
:ref:`configuration file <cli-livestreamerrc>` anyway.
.. warning::
The API this plugin uses isn't supposed to be available to use it on
computers. The plugin tries to blend in as a valid device using custom
headers and following the API usual flow (e.g. reusing credentials), but
this does not assure that your account will be safe from being spotted for
unusual behavior.
HTTP proxy with Crunchyroll
^^^^^^^^^^^^^^^^^^^^^^^^^^^
You can use the :option:`--http-proxy` **and** :option:`--https-proxy`
options (you need both since the plugin uses both protocols) to access the
Crunchyroll servers through a proxy to be able to stream region locked content.
When doing this, it's very probable that you will get denied to access the
stream; this occurs because the session and credentials used by the plugin
where obtained when logged from your own region, and the server still assumes
you're in that region.
For this, the plugin provides the :option:`--crunchyroll-purge-credentials`
option, which removes your saved session and credentials and tries to log
in again using your username and password.
Sideloading plugins
-------------------
Livestreamer will attempt to load standalone plugins from these directories:
================= ====================================================
Platform Location
================= ====================================================
Unix-like (POSIX) $XDG_CONFIG_HOME/livestreamer/plugins
Windows %APPDATA%\\livestreamer\\plugins
================= ====================================================
.. note::
If a plugin is added with the same name as a built-in plugin then
the added plugin will take precedence. This is useful if you want
to upgrade plugins independently of the Livestreamer version.
Playing built-in streaming protocols directly
---------------------------------------------
There are many types of streaming protocols used by services today and
Livestreamer supports most of them. It's possible to tell Livestreamer
to access a streaming protocol directly instead of relying on a plugin
to extract the streams from a URL for you.
A protocol can be accessed directly by specifying it in the URL format::
protocol://path [key=value]
Accessing a stream that requires extra parameters to be passed along
(e.g. RTMP):
.. code-block:: console
$ livestreamer "rtmp://streaming.server.net/playpath live=1 swfVfy=http://server.net/flashplayer.swf"
Most streaming technologies simply requires you to pass a HTTP URL, this is
a Adobe HDS stream:
.. code-block:: console
$ livestreamer hds://streaming.server.net/playpath/manifest.f4m
Supported streaming protocols
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
============================== =================================================
Name Prefix
============================== =================================================
Adobe HTTP Dynamic Streaming hds://
Akamai HD Adaptive Streaming akamaihd://
Apple HTTP Live Streaming hls:// hlsvariant://
Real Time Messaging Protocol rtmp:// rtmpe:// rtmps:// rtmpt:// rtmpte://
Progressive HTTP, HTTPS, etc httpstream://
============================== =================================================
.. _cli-options:
Command-line usage
------------------
.. code-block:: console
$ livestreamer [OPTIONS] [URL] [STREAM]
.. argparse::
:module: livestreamer_cli.argparser
:attr: parser
livestreamer-1.12.2/docs/changelog.rst 0000644 0001750 0001750 00000000103 12521217321 020774 0 ustar chrippa chrippa 0000000 0000000 .. _changelog:
Changelog
=========
.. include:: ../CHANGELOG.rst
livestreamer-1.12.2/docs/api_guide.rst 0000644 0001750 0001750 00000006241 12521217321 021004 0 ustar chrippa chrippa 0000000 0000000 .. _api_guide:
API Guide
=========
.. module:: livestreamer
This API is what powers the :ref:`cli` but is also available to developers that wish
to make use of the data Livestreamer can retrieve in their own application.
Extracting streams
------------------
The simplest use of the Livestreamer API looks like this:
.. code-block:: python
>>> import livestreamer
>>> streams = livestreamer.streams("http://twitch.tv/day9tv")
This simply attempts to find a plugin and use it to extract streams from
the URL. This works great in simple cases but if you want more
fine tuning you need to use a `session object`_ instead.
The returned value is a dict containing :class:`Stream <stream.Stream>` objects:
.. code-block:: python
>>> streams
{'best': <HLSStream('http://video11.fra01.hls.twitch.tv/ ...')>,
'high': <HLSStream('http://video11.fra01.hls.twitch.tv/ ...')>,
'low': <HLSStream('http://video11.fra01.hls.twitch.tv/ ...')>,
'medium': <HLSStream('http://video11.fra01.hls.twitch.tv/ ...')>,
'mobile': <HLSStream('http://video11.fra01.hls.twitch.tv/ ...')>,
'source': <HLSStream('http://video11.fra01.hls.twitch.tv/ ...')>,
'worst': <HLSStream('http://video11.fra01.hls.twitch.tv/ ...')>}
If no plugin for the URL is found, a :exc:`NoPluginError` will be raised.
If an error occurs while fetching streams, a :exc:`PluginError` will be raised.
Opening streams to read data
----------------------------
Now that you have extracted some streams we might want to read some data from
one of them. When you call `open()` on a stream, a file-like object will be
returned, which you can call `.read(size)` and `.close()` on.
.. code-block:: python
>>> stream = streams["source"]
>>> fd = stream.open()
>>> data = fd.read(1024)
>>> fd.close()
If an error occurs while opening a stream, a :exc:`StreamError` will be raised.
Inspecting streams
------------------
It's also possible to inspect streams internal parameters, see
:ref:`api-stream-subclasses` to see what attributes are available
for inspection for each stream type.
For example this is a :class:`HLSStream <stream.HLSStream>` object which
contains a `url` attribute.
.. code-block:: python
>>> stream.url
'http://video38.ams01.hls.twitch.tv/hls11/ ...'
Session object
--------------
The session allows you to set various options and is more efficient
when extracting streams more than once. You start by creating a
:class:`Livestreamer` object:
.. code-block:: python
>>> from livestreamer import Livestreamer
>>> session = Livestreamer()
You can then extract streams like this:
.. code-block:: python
>>> streams = session.streams("http://twitch.tv/day9tv")
or set options like this:
.. code-block:: python
>>> session.set_option("rtmp-rtmpdump", "/path/to/rtmpdump")
See :func:`Livestreamer.set_option` to see which options are available.
Examples
--------
Simple player
^^^^^^^^^^^^^
This example uses the `PyGObject`_ module to playback a stream using the
`GStreamer`_ framework.
.. _PyGObject: https://wiki.gnome.org/action/show/Projects/PyGObject
.. _GStreamer: http://gstreamer.freedesktop.org/
.. literalinclude:: ../examples/gst-player.py
livestreamer-1.12.2/docs/api.rst 0000644 0001750 0001750 00000002144 12521217321 017625 0 ustar chrippa chrippa 0000000 0000000 .. _api:
API Reference
=============
.. module:: livestreamer
This ia reference of all the available API methods in Livestreamer.
Livestreamer
------------
.. autofunction:: streams
Session
-------
.. autoclass:: Livestreamer
:members:
Plugins
-------
.. module:: livestreamer.plugin
.. autoclass:: Plugin
:members:
Streams
-------
All streams inherit from the :class:`Stream` class.
.. module:: livestreamer.stream
.. autoclass:: Stream
:members:
.. _api-stream-subclasses:
Stream subclasses
^^^^^^^^^^^^^^^^^
You are able to inspect the parameters used by each stream,
different properties are available depending on stream type.
.. autoclass:: AkamaiHDStream
:members:
.. autoclass:: HDSStream
:members:
.. autoclass:: HLSStream
:members:
.. autoclass:: HTTPStream
:members:
.. autoclass:: RTMPStream
:members:
Exceptions
----------
Livestreamer has three types of exceptions:
.. autoexception:: livestreamer.LivestreamerError
.. autoexception:: livestreamer.PluginError
.. autoexception:: livestreamer.NoPluginError
.. autoexception:: livestreamer.StreamError
livestreamer-1.12.2/docs/Makefile 0000644 0001750 0001750 00000012724 12521217321 017767 0 ustar chrippa chrippa 0000000 0000000 # Makefile for Sphinx documentation
#
# You can set these variables from the command line.
SPHINXOPTS =
SPHINXBUILD = sphinx-build
PAPER =
BUILDDIR = _build
# Internal variables.
PAPEROPT_a4 = -D latex_paper_size=a4
PAPEROPT_letter = -D latex_paper_size=letter
ALLSPHINXOPTS = -d $(BUILDDIR)/doctrees $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) .
# the i18n builder cannot share the environment and doctrees with the others
I18NSPHINXOPTS = $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) .
.PHONY: help clean html dirhtml singlehtml pickle json htmlhelp qthelp devhelp epub latex latexpdf text man changes linkcheck doctest gettext
help:
@echo "Please use \`make <target>' where <target> is one of"
@echo " html to make standalone HTML files"
@echo " dirhtml to make HTML files named index.html in directories"
@echo " singlehtml to make a single large HTML file"
@echo " pickle to make pickle files"
@echo " json to make JSON files"
@echo " htmlhelp to make HTML files and a HTML help project"
@echo " qthelp to make HTML files and a qthelp project"
@echo " devhelp to make HTML files and a Devhelp project"
@echo " epub to make an epub"
@echo " latex to make LaTeX files, you can set PAPER=a4 or PAPER=letter"
@echo " latexpdf to make LaTeX files and run them through pdflatex"
@echo " text to make text files"
@echo " man to make manual pages"
@echo " texinfo to make Texinfo files"
@echo " info to make Texinfo files and run them through makeinfo"
@echo " gettext to make PO message catalogs"
@echo " changes to make an overview of all changed/added/deprecated items"
@echo " linkcheck to check all external links for integrity"
@echo " doctest to run all doctests embedded in the documentation (if enabled)"
clean:
-rm -rf $(BUILDDIR)/*
html:
$(SPHINXBUILD) -b html $(ALLSPHINXOPTS) $(BUILDDIR)/html
@echo
@echo "Build finished. The HTML pages are in $(BUILDDIR)/html."
dirhtml:
$(SPHINXBUILD) -b dirhtml $(ALLSPHINXOPTS) $(BUILDDIR)/dirhtml
@echo
@echo "Build finished. The HTML pages are in $(BUILDDIR)/dirhtml."
singlehtml:
$(SPHINXBUILD) -b singlehtml $(ALLSPHINXOPTS) $(BUILDDIR)/singlehtml
@echo
@echo "Build finished. The HTML page is in $(BUILDDIR)/singlehtml."
pickle:
$(SPHINXBUILD) -b pickle $(ALLSPHINXOPTS) $(BUILDDIR)/pickle
@echo
@echo "Build finished; now you can process the pickle files."
json:
$(SPHINXBUILD) -b json $(ALLSPHINXOPTS) $(BUILDDIR)/json
@echo
@echo "Build finished; now you can process the JSON files."
htmlhelp:
$(SPHINXBUILD) -b htmlhelp $(ALLSPHINXOPTS) $(BUILDDIR)/htmlhelp
@echo
@echo "Build finished; now you can run HTML Help Workshop with the" \
".hhp project file in $(BUILDDIR)/htmlhelp."
qthelp:
$(SPHINXBUILD) -b qthelp $(ALLSPHINXOPTS) $(BUILDDIR)/qthelp
@echo
@echo "Build finished; now you can run "qcollectiongenerator" with the" \
".qhcp project file in $(BUILDDIR)/qthelp, like this:"
@echo "# qcollectiongenerator $(BUILDDIR)/qthelp/livestreamer.qhcp"
@echo "To view the help file:"
@echo "# assistant -collectionFile $(BUILDDIR)/qthelp/livestreamer.qhc"
devhelp:
$(SPHINXBUILD) -b devhelp $(ALLSPHINXOPTS) $(BUILDDIR)/devhelp
@echo
@echo "Build finished."
@echo "To view the help file:"
@echo "# mkdir -p $$HOME/.local/share/devhelp/livestreamer"
@echo "# ln -s $(BUILDDIR)/devhelp $$HOME/.local/share/devhelp/livestreamer"
@echo "# devhelp"
epub:
$(SPHINXBUILD) -b epub $(ALLSPHINXOPTS) $(BUILDDIR)/epub
@echo
@echo "Build finished. The epub file is in $(BUILDDIR)/epub."
latex:
$(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex
@echo
@echo "Build finished; the LaTeX files are in $(BUILDDIR)/latex."
@echo "Run \`make' in that directory to run these through (pdf)latex" \
"(use \`make latexpdf' here to do that automatically)."
latexpdf:
$(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex
@echo "Running LaTeX files through pdflatex..."
$(MAKE) -C $(BUILDDIR)/latex all-pdf
@echo "pdflatex finished; the PDF files are in $(BUILDDIR)/latex."
text:
$(SPHINXBUILD) -b text $(ALLSPHINXOPTS) $(BUILDDIR)/text
@echo
@echo "Build finished. The text files are in $(BUILDDIR)/text."
man:
$(SPHINXBUILD) -b man $(ALLSPHINXOPTS) $(BUILDDIR)/man
@echo
@echo "Build finished. The manual pages are in $(BUILDDIR)/man."
texinfo:
$(SPHINXBUILD) -b texinfo $(ALLSPHINXOPTS) $(BUILDDIR)/texinfo
@echo
@echo "Build finished. The Texinfo files are in $(BUILDDIR)/texinfo."
@echo "Run \`make' in that directory to run these through makeinfo" \
"(use \`make info' here to do that automatically)."
info:
$(SPHINXBUILD) -b texinfo $(ALLSPHINXOPTS) $(BUILDDIR)/texinfo
@echo "Running Texinfo files through makeinfo..."
make -C $(BUILDDIR)/texinfo info
@echo "makeinfo finished; the Info files are in $(BUILDDIR)/texinfo."
gettext:
$(SPHINXBUILD) -b gettext $(I18NSPHINXOPTS) $(BUILDDIR)/locale
@echo
@echo "Build finished. The message catalogs are in $(BUILDDIR)/locale."
changes:
$(SPHINXBUILD) -b changes $(ALLSPHINXOPTS) $(BUILDDIR)/changes
@echo
@echo "The overview file is in $(BUILDDIR)/changes."
linkcheck:
$(SPHINXBUILD) -b linkcheck $(ALLSPHINXOPTS) $(BUILDDIR)/linkcheck
@echo
@echo "Link check complete; look for any errors in the above output " \
"or in $(BUILDDIR)/linkcheck/output.txt."
doctest:
$(SPHINXBUILD) -b doctest $(ALLSPHINXOPTS) $(BUILDDIR)/doctest
@echo "Testing of doctests in the sources finished, look at the " \
"results in $(BUILDDIR)/doctest/output.txt."
livestreamer-1.12.2/docs/_themes/ 0000755 0001750 0001750 00000000000 12521217500 017744 5 ustar chrippa chrippa 0000000 0000000 livestreamer-1.12.2/docs/_themes/.gitignore 0000644 0001750 0001750 00000000026 12521217321 021733 0 ustar chrippa chrippa 0000000 0000000 *.pyc
*.pyo
.DS_Store
livestreamer-1.12.2/docs/_themes/sphinx_rtd_theme_violet/ 0000755 0001750 0001750 00000000000 12521217500 024672 5 ustar chrippa chrippa 0000000 0000000 livestreamer-1.12.2/docs/_themes/sphinx_rtd_theme_violet/versions.html 0000644 0001750 0001750 00000002277 12521217321 027441 0 ustar chrippa chrippa 0000000 0000000 {% if READTHEDOCS %}
{# Add rst-badge after rst-versions for small badge style. #}
<div class="rst-versions rst-badge" data-toggle="rst-versions" role="note" aria-label="versions">
<span class="rst-current-version" data-toggle="rst-current-version">
<span class="fa fa-book"></span>
v: {{ current_version }}
<span class="fa fa-caret-down"></span>
</span>
<div class="rst-other-versions">
<dl>
<dt>Versions</dt>
{% for slug, url in versions %}
<dd><a href="{{ url }}">{{ slug }}</a></dd>
{% endfor %}
</dl>
<dl>
<dt>Downloads</dt>
{% for type, url in downloads %}
<dd><a href="{{ url }}">{{ type }}</a></dd>
{% endfor %}
</dl>
<dl>
<dt>On Read the Docs</dt>
<dd>
<a href="//{{ PRODUCTION_DOMAIN }}/projects/{{ slug }}/?fromdocs={{ slug }}">Project Home</a>
</dd>
<dd>
<a href="//{{ PRODUCTION_DOMAIN }}/builds/{{ slug }}/?fromdocs={{ slug }}">Builds</a>
</dd>
</dl>
<hr/>
Free document hosting provided by <a href="http://www.readthedocs.org">Read the Docs</a>.
</div>
</div>
{% endif %}
livestreamer-1.12.2/docs/_themes/sphinx_rtd_theme_violet/theme.conf 0000644 0001750 0001750 00000000244 12521217321 026644 0 ustar chrippa chrippa 0000000 0000000 [theme]
inherit = basic
stylesheet = css/theme.css
[options]
typekit_id = hiw1hhg
analytics_id =
sticky_navigation = False
oneliner =
github_user =
github_repo =
livestreamer-1.12.2/docs/_themes/sphinx_rtd_theme_violet/searchbox.html 0000644 0001750 0001750 00000000464 12521217321 027543 0 ustar chrippa chrippa 0000000 0000000 <div role="search">
<form id ="rtd-search-form" class="wy-form" action="{{ pathto('search') }}" method="get">
<input type="text" name="q" placeholder="Search docs" />
<input type="hidden" name="check_keywords" value="yes" />
<input type="hidden" name="area" value="default" />
</form>
</div>
livestreamer-1.12.2/docs/_themes/sphinx_rtd_theme_violet/search.html 0000644 0001750 0001750 00000002772 12521217321 027036 0 ustar chrippa chrippa 0000000 0000000 {#
basic/search.html
~~~~~~~~~~~~~~~~~
Template for the search page.
:copyright: Copyright 2007-2013 by the Sphinx team, see AUTHORS.
:license: BSD, see LICENSE for details.
#}
{%- extends "layout.html" %}
{% set title = _('Search') %}
{% set script_files = script_files + ['_static/searchtools.js'] %}
{% block footer %}
<script type="text/javascript">
jQuery(function() { Search.loadIndex("{{ pathto('searchindex.js', 1) }}"); });
</script>
{# this is used when loading the search index using $.ajax fails,
such as on Chrome for documents on localhost #}
<script type="text/javascript" id="searchindexloader"></script>
{{ super() }}
{% endblock %}
{% block body %}
<noscript>
<div id="fallback" class="admonition warning">
<p class="last">
{% trans %}Please activate JavaScript to enable the search
functionality.{% endtrans %}
</p>
</div>
</noscript>
{% if search_performed %}
<h2>{{ _('Search Results') }}</h2>
{% if not search_results %}
<p>{{ _('Your search did not match any documents. Please make sure that all words are spelled correctly and that you\'ve selected enough categories.') }}</p>
{% endif %}
{% endif %}
<div id="search-results">
{% if search_results %}
<ul>
{% for href, caption, context in search_results %}
<li>
<a href="{{ pathto(item.href) }}">{{ caption }}</a>
<p class="context">{{ context|e }}</p>
</li>
{% endfor %}
</ul>
{% endif %}
</div>
{% endblock %}
livestreamer-1.12.2/docs/_themes/sphinx_rtd_theme_violet/layout_old.html 0000644 0001750 0001750 00000016255 12521217321 027745 0 ustar chrippa chrippa 0000000 0000000 {#
basic/layout.html
~~~~~~~~~~~~~~~~~
Master layout template for Sphinx themes.
:copyright: Copyright 2007-2013 by the Sphinx team, see AUTHORS.
:license: BSD, see LICENSE for details.
#}
{%- block doctype -%}
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
{%- endblock %}
{%- set reldelim1 = reldelim1 is not defined and ' »' or reldelim1 %}
{%- set reldelim2 = reldelim2 is not defined and ' |' or reldelim2 %}
{%- set render_sidebar = (not embedded) and (not theme_nosidebar|tobool) and
(sidebars != []) %}
{%- set url_root = pathto('', 1) %}
{# XXX necessary? #}
{%- if url_root == '#' %}{% set url_root = '' %}{% endif %}
{%- if not embedded and docstitle %}
{%- set titlesuffix = " — "|safe + docstitle|e %}
{%- else %}
{%- set titlesuffix = "" %}
{%- endif %}
{%- macro relbar() %}
<div class="related">
<h3>{{ _('Navigation') }}</h3>
<ul>
{%- for rellink in rellinks %}
<li class="right" {% if loop.first %}style="margin-right: 10px"{% endif %}>
<a href="{{ pathto(rellink[0]) }}" title="{{ rellink[1]|striptags|e }}"
{{ accesskey(rellink[2]) }}>{{ rellink[3] }}</a>
{%- if not loop.first %}{{ reldelim2 }}{% endif %}</li>
{%- endfor %}
{%- block rootrellink %}
<li><a href="{{ pathto(master_doc) }}">{{ shorttitle|e }}</a>{{ reldelim1 }}</li>
{%- endblock %}
{%- for parent in parents %}
<li><a href="{{ parent.link|e }}" {% if loop.last %}{{ accesskey("U") }}{% endif %}>{{ parent.title }}</a>{{ reldelim1 }}</li>
{%- endfor %}
{%- block relbaritems %} {% endblock %}
</ul>
</div>
{%- endmacro %}
{%- macro sidebar() %}
{%- if render_sidebar %}
<div class="sphinxsidebar">
<div class="sphinxsidebarwrapper">
{%- block sidebarlogo %}
{%- if logo %}
<p class="logo"><a href="{{ pathto(master_doc) }}">
<img class="logo" src="{{ pathto('_static/' + logo, 1) }}" alt="Logo"/>
</a></p>
{%- endif %}
{%- endblock %}
{%- if sidebars != None %}
{#- new style sidebar: explicitly include/exclude templates #}
{%- for sidebartemplate in sidebars %}
{%- include sidebartemplate %}
{%- endfor %}
{%- else %}
{#- old style sidebars: using blocks -- should be deprecated #}
{%- block sidebartoc %}
{%- include "localtoc.html" %}
{%- endblock %}
{%- block sidebarrel %}
{%- include "relations.html" %}
{%- endblock %}
{%- block sidebarsourcelink %}
{%- include "sourcelink.html" %}
{%- endblock %}
{%- if customsidebar %}
{%- include customsidebar %}
{%- endif %}
{%- block sidebarsearch %}
{%- include "searchbox.html" %}
{%- endblock %}
{%- endif %}
</div>
</div>
{%- endif %}
{%- endmacro %}
{%- macro script() %}
<script type="text/javascript">
var DOCUMENTATION_OPTIONS = {
URL_ROOT: '{{ url_root }}',
VERSION: '{{ release|e }}',
COLLAPSE_INDEX: false,
FILE_SUFFIX: '{{ '' if no_search_suffix else file_suffix }}',
HAS_SOURCE: {{ has_source|lower }}
};
</script>
{%- for scriptfile in script_files %}
<script type="text/javascript" src="{{ pathto(scriptfile, 1) }}"></script>
{%- endfor %}
{%- endmacro %}
{%- macro css() %}
<link rel="stylesheet" href="{{ pathto('_static/' + style, 1) }}" type="text/css" />
<link rel="stylesheet" href="{{ pathto('_static/pygments.css', 1) }}" type="text/css" />
{%- for cssfile in css_files %}
<link rel="stylesheet" href="{{ pathto(cssfile, 1) }}" type="text/css" />
{%- endfor %}
{%- endmacro %}
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset={{ encoding }}" />
{{ metatags }}
{%- block htmltitle %}
<title>{{ title|striptags|e }}{{ titlesuffix }}
{%- endblock %}
{{ css() }}
{%- if not embedded %}
{{ script() }}
{%- if use_opensearch %}
{%- endif %}
{%- if favicon %}
{%- endif %}
{%- endif %}
{%- block linktags %}
{%- if hasdoc('about') %}
{%- endif %}
{%- if hasdoc('genindex') %}
{%- endif %}
{%- if hasdoc('search') %}
{%- endif %}
{%- if hasdoc('copyright') %}
{%- endif %}
{%- if parents %}
{%- endif %}
{%- if next %}
{%- endif %}
{%- if prev %}
{%- endif %}
{%- endblock %}
{%- block extrahead %} {% endblock %}
{%- block header %}{% endblock %}
{%- block relbar1 %}{{ relbar() }}{% endblock %}
{%- block content %}
{%- block sidebar1 %} {# possible location for sidebar #} {% endblock %}