Cross-layer Adaptive Bitrate Streaming

The project contains a set of cross-layer adaptive bitrate streaming algorithms implemented on top of QUIC and DASH.js.

Repository structure

quic: Chromium QUIC server with pluggable congestion control and adaptive bitrate algorithms
dash: Typescript(and ECMAScript 6) wrapper over DASH.js player
exp: Experimental setup for running multiple players over a shared environment.
downloads: Python scripts for downloading and preparing new videos.
learning: Environment for reinforcement learning-based congestion control.

For more details about each sub-module, take a look at the README present in each folder.

Quickstart

Experiment can be run from the script exp/experiments.py. To be able to do so, one needs to:

install the Chromium QUIC server:
```
quic/install.sh --install
```
install the Python dependencies:
```
pip3 install -r exp/requirements.txt
```
install front-end dependencies from the dash folder:
```
npm install
```

The experiments can be listed using the command:

python3 exp/experiment.py --help

To run an experiment, one can use the command:

python3 exp/experiment.py --help

Note that the TC Linux utility needs root privileges, hence running an experiment might need sudo.

Algorithms

The list of available(CC and ABR) algorithms can be found using the command:

$ python3 exp/run.py --help

usage: run.py [-h] [...]
  [--algo {bola,dynamic,bb,festive,rb,robustMpc,pensieve,minerva,minervann}]
  [--server-algo {bb,random,worthed,target,target2,target3,gap,remote,minerva,minervann}]
  [--cc {bbr,bbr2,pcc,reno,cubic,abbr,xbbr,target,gap,minerva}]

The --algo argument shows all possible choices for in-player implemented ABR algorithms(i.e. implementations found in the dash folder), while --server-algo shows the possible choices for server-side ABR implementations. The --cc argument shows all possible server-side implementations.

In-player ABR algorithms:

BOLA: buffer-based algorithm provided in the DASH.js player
Dynamic: default DASH.js player
BB: simple buffer-based algorithm; BBA simplified
Festive: a rate-based approach that uses a windowed harmonic mean for bandwidth estimation
RB: simple rate-based algorithm; chooses quality proportional with last segment's download time bandwidth estimation
RobustMpc: a control-theoretic rate-based approach for ABR; implementation is found in the exp/abr folder
Pensieve: adaptive bitrate algorithms using reinforcement learning
Minerva: end-to- end transport for video QoE fairness; needs both --algo and --server-algo flags

Server-side ABR algorithms(mostly composed of our original custom CC-ABR combination algorithm):

Random: chooses random video quality for each segment
Worthed: VMAF-aware planning; found in quic/chromium/src/net/abrcc/abr/abr_worthed.cc
Target: low-liberty long-term planning ABR; found in quic/chromium/src/net/abrcc/abr/abr_target.cc
Gap: Target-based ABR with specialized congestion-control; found in quic/chromium/src/net/abrcc/abr/abr_gap.cc
Remote: custom backend that exposes the CC and ABR internal states and listens for decisions from a 3rd party server

Congestion control algorithms:

Standard congestion control algorithms: Cubic, Reno, PCC, BBR, BBR2
Specialized algorithms: ABBR for Worthed, Target, Gap and Minerva

Development

Running experiments

Individual experiments can be run from folder exp by:

python3 run.py -h

More complex experiments(e.g. multiple instances, variable bandwidth traces, etc.) can be setup in Python code from the file exp/experiments.py; after setup, the experiments can be run by:

python3 experiment/py -h

Running individual components

To run a QUIC server:

quic/run.sh -s

To open a Chrome instance running QUIC, use:

quic/run.sh --chrome

To only build the C++ modules:

quic/run.sh -b

If a script is stopped in the middle of the build, to arrive in the correct state, run:

quic/install.sh --build

When only trying to develop on the front-end it may be useful to lint and build directly. From the directory dash, one can run:

npm run lint
npm run build [build-arguments]

Adding new CC/ABR functionality

For adding new CC or ABR functionality, the following files should be relevant:

+-- quic
|   +-- chromium
|       +-- src/net
|           +-- abrcc
|           |   +-- abr
|           |   +-- cc   
|           |   +-- dash_backend.cc
|           |   +-- dash_server.cc
|           +-- BUILD.gn
+-- dash
|   +-- src
|       +-- algo       
|       |   +-- interface.js
|       |   +-- selector.js
|       +-- common        
|           +-- args.js  
+-- exp
    +-- abr
    +-- run.py

► Adding a new ABR algorithm - Javascript

add a new file in dash/src/algo and implement the interface from dash/src/algo/interface.js
add the new algorithm in exp/run.sh

► Adding a new ABR algorithm - Python

implement the interface server.server.Component
the output should be a JSON with the filed decision
add the new algorithm in exp/run.sh

► Adding a new ABR algorithm - C++

implement the interface AbrInterface from the file quic/chromium/src/net/abrcc/abr/interface.h
add algorithm in function getAbr from file quic/chromium/src/net/abrcc/abr/abr.cc
add the new algorithm quic/run.sh
add the new algorithm in exp/run.sh

► Adding a new CC algorithm

add a new algorithm in enumeration from net/third_party/quiche/src/quic/core/quic_types.h
implement the new algorithm by implementing the methods that quic/chromium/src/net/abrcc/cc/cc_wrapper.cc implements
add the new algorithm in quic/chromium/src/net/abrcc/cc/cc_selector.cc
add the new algorithm in quic/run.sh
add the new algorithm in exp/run.sh

danalex97 / abrcc