Release 0.8.3

This played e.g. a 1264x722 file as 1264x720. There was some code which
dropped the aspect ratio if the video (in original resolution) wasn't
scaled by more than 4 pixels. Commit 5f3c3f8c introduced this (although
I'm not really sure what the code replaced by it did).

Just remove this "feature".

(cherry picked from commit d96fad04be)

.gitignore

@@ -28,6 +28,8 @@
 /DOCS/man/mpv.toc
 
 /waf
+/waf-*
+/waf3-*
 /build
 /.waf*
 /.lock-waf_*

.travis.yml

@@ -2,19 +2,25 @@ language: c
 
 os:
   - linux
-  - osx
+#  - osx
 env:
-  - LIBAV=libav-stable
-  - LIBAV=libav-git
-  - LIBAV=ffmpeg-stable
-  - LIBAV=ffmpeg-git
+  matrix:
+    - LIBAV=libav-stable
+    - LIBAV=libav-git
+    - LIBAV=ffmpeg-stable
+    - LIBAV=ffmpeg-git
+  global:
+    # Coverity token
+    - secure: "H21mSRlMhk4BKS0xHZvCFGJxteCP0hRVUxTuNfM2Z9HBsyutuLEYMtViLO86VtM+Tqla3xXPzUdS4ozLwI72Ax/5ZUDXACROj73yW6QhFB5D6rLut12+FjqC7M33Qv2hl0xwgNBmR5dsm1ToP37+Wn+ecJQNvN8fkTXF+HVzOEw="
 compiler:
   - clang
+  - gcc
 
 branches:
   only:
     - master
     - ci
+    - coverity_scan
 
 matrix:
   exclude:
@@ -24,6 +30,12 @@ matrix:
       env: LIBAV=libav-git
     - os: osx
       env: LIBAV=ffmpeg-git
+    - os: osx
+      compiler: gcc
+    - os: linux
+      env: LIBAV=ffmpeg-stable
+    - os: linux
+      compiler: clang
 
 before_install: ./travis-deps libass-stable $LIBAV
 script:
@@ -38,3 +50,13 @@ notifications:
       - "irc.freenode.org#mpv-player-dev"
     on_success: change
     on_failure: always
+
+addons:
+  coverity_scan:
+    project:
+      name: "mpv-player/mpv"
+      description: "Build submitted via Travis CI"
+    notification_email: mpv-team@googlegroups.com
+    build_command_prepend: "./bootstrap.py && ./waf configure"
+    build_command:   "./waf build"
+    branch_pattern: coverity_scan

DOCS/client-api-changes.rst

@@ -25,8 +25,51 @@ API changes
 
 ::
 
- --- mpv 0.5.2 is released ---
+ --- mpv 0.8.0 is released ---
+ 1.14   - add mpv_wait_async_requests()
+        - the --msg-level option changes its native type from a flat string to
+          a key-value list (setting/reading the option as string still works)
+ 1.13   - add MPV_EVENT_QUEUE_OVERFLOW
+ 1.12   - add class Handle to qthelper.hpp
+        - improve opengl_cb.h API uninitialization behavior, and fix the qml
+          example
+        - add mpv_create_client() function
+ 1.11   - add OpenGL rendering interop API - allows an application to combine
+          its own and mpv's OpenGL rendering
+          Warning: this API is not stable yet - anything in opengl_cb.h might
+                   be changed in completely incompatible ways in minor API bumps
+ --- mpv 0.7.0 is released ---
+ 1.10   - deprecate/disable everything directly related to script_dispatch
+          (most likely affects nobody)
+ 1.9    - add enum mpv_end_file_reason for mpv_event_end_file.reason
+        - add MPV_END_FILE_REASON_ERROR and the mpv_event_end_file.error field
+          for slightly better error reporting on playback failure
+        - add --stop-playback-on-init-failure option, and make it the default
+          behavior for libmpv only
+        - add qthelper.hpp set_option_variant()
+        - mark the following events as deprecated:
+            MPV_EVENT_TRACKS_CHANGED
+            MPV_EVENT_TRACK_SWITCHED
+            MPV_EVENT_PAUSE
+            MPV_EVENT_UNPAUSE
+            MPV_EVENT_METADATA_UPDATE
+            MPV_EVENT_CHAPTER_CHANGE
+          They are handled better with mpv_observe_property() as mentioned in
+          the documentation comments. They are not removed and still work.
+ 1.8    - add qthelper.hpp
+ 1.7    - add mpv_command_node(), mpv_command_node_async()
+ 1.6    - modify "core-idle" property behavior
+        - MPV_EVENT_LOG_MESSAGE now always sends complete lines
+        - introduce numeric log levels (mpv_log_level)
+ --- mpv 0.6.0 is released ---
+ 1.5    - change in X11 and "--wid" behavior again. The previous change didn't
+          work as expected, and now the behavior can be explicitly controlled
+          with the "input-x11-keyboard" option. This is only a temporary
+          measure until XEmbed is implemented and confirmed working.
+          Note: in 1.6, "input-x11-keyboard" was renamed to "input-vo-keyboard",
+          although the old option name still works.
  1.4    - subtle change in X11 and "--wid" behavior
+          (this change was added to 0.5.2, and broke some things, see #1090)
  --- mpv 0.5.0 is released ---
  1.3    - add MPV_MAKE_VERSION()
  1.2    - remove "stream-time-pos" property (no replacement)

DOCS/client_api_examples/Copyright

@@ -0,0 +1,14 @@
+All examples in this directory and its sub-directories are licensed
+under one of the following licenses:
+
+    WTFPL, ISC, Ms-PL, AGPLv3, BSD (any)
+
+Pick any license of your liking, and disregard the others.
+
+(The full text of each license is available on this website:
+  http://opensource.org/licenses/alphabetical )
+
+Additionally, you may consider the example code to be public domain.
+You are free to use any of the example code without further
+requirements or need for attribution.
+

DOCS/client_api_examples/README.md

@@ -0,0 +1,30 @@
+Client API examples
+===================
+
+All these examples use the mpv client API through libmpv.
+
+cocoa
+-----
+
+Shows how to embed the mpv video window in Objective-C/Cocoa.
+
+qt
+--
+
+Shows how to embed the mpv video window in Qt (using normal desktop widgets).
+
+qml
+---
+
+Shows how to use mpv's OpenGL video renderer in QtQuick2 with QML.
+
+qml_direct
+----------
+
+Alternative example, which typically avoids a FBO indirection. Might be
+slightly faster, but is less flexible and harder to use.
+
+simple
+------
+
+Very primitive terminal-only example. Shows some most basic API usage.

DOCS/client_api_examples/cocoa/cocoabasic.m

@@ -0,0 +1,211 @@
+// Plays a video from the command line in a window provided by mpv.
+// You likely want to play the video in your own window instead,
+// but that's not quite ready yet.
+// You may need a basic Info.plist and MainMenu.xib to make this work.
+
+// Build with: clang -o cocoabasic cocoabasic.m `pkg-config --libs --cflags mpv`
+
+#include <mpv/client.h>
+
+#include <stdio.h>
+#include <stdlib.h>
+
+static inline void check_error(int status)
+{
+    if (status < 0) {
+        printf("mpv API error: %s\n", mpv_error_string(status));
+        exit(1);
+    }
+}
+
+#import <Cocoa/Cocoa.h>
+
+@interface CocoaWindow : NSWindow
+@end
+
+@implementation CocoaWindow
+- (BOOL)canBecomeMainWindow { return YES; }
+- (BOOL)canBecomeKeyWindow { return YES; }
+@end
+
+@interface AppDelegate : NSObject <NSApplicationDelegate>
+{
+    mpv_handle *mpv;
+    dispatch_queue_t queue;
+    NSWindow *w;
+    NSView *wrapper;
+}
+@end
+
+static void wakeup(void *);
+
+@implementation AppDelegate
+
+- (void)createWindow {
+
+    int mask = NSTitledWindowMask|NSClosableWindowMask|
+               NSMiniaturizableWindowMask|NSResizableWindowMask;
+
+    self->w = [[CocoaWindow alloc]
+        initWithContentRect:NSMakeRect(0,0, 1280, 720)
+                  styleMask:mask
+                    backing:NSBackingStoreBuffered
+                      defer:NO];
+
+    [self->w setTitle:@"cocoabasic example"];
+    [self->w makeMainWindow];
+    [self->w makeKeyAndOrderFront:nil];
+
+    NSRect frame = [[self->w contentView] bounds];
+    self->wrapper = [[NSView alloc] initWithFrame:frame];
+    [self->wrapper setAutoresizingMask:NSViewWidthSizable|NSViewHeightSizable];
+    [[self->w contentView] addSubview:self->wrapper];
+    [self->wrapper release];
+
+    NSMenu *m = [[NSMenu alloc] initWithTitle:@"AMainMenu"];
+    NSMenuItem *item = [m addItemWithTitle:@"Apple" action:nil keyEquivalent:@""];
+    NSMenu *sm = [[NSMenu alloc] initWithTitle:@"Apple"];
+    [m setSubmenu:sm forItem:item];
+    [sm addItemWithTitle: @"mpv_command('stop')" action:@selector(mpv_stop) keyEquivalent:@""];
+    [sm addItemWithTitle: @"mpv_command('quit')" action:@selector(mpv_quit) keyEquivalent:@""];
+    [sm addItemWithTitle: @"quit" action:@selector(terminate:) keyEquivalent:@"q"];
+    [NSApp setMenu:m];
+    [NSApp activateIgnoringOtherApps:YES];
+}
+
+- (void) applicationDidFinishLaunching:(NSNotification *)notification {
+    [NSApp setActivationPolicy:NSApplicationActivationPolicyRegular];
+    atexit_b(^{
+        // Because activation policy has just been set to behave like a real
+        // application, that policy must be reset on exit to prevent, among
+        // other things, the menubar created here from remaining on screen.
+        [NSApp setActivationPolicy:NSApplicationActivationPolicyProhibited];
+    });
+
+    // Read filename
+    NSArray *args = [NSProcessInfo processInfo].arguments;
+    if (args.count < 2) {
+        NSLog(@"Expected filename on command line");
+        exit(1);
+    }
+    NSString *filename = args[1];
+
+    [self createWindow];
+
+    // Deal with MPV in the background.
+    queue = dispatch_queue_create("mpv", DISPATCH_QUEUE_SERIAL);
+    dispatch_async(queue, ^{
+
+        mpv = mpv_create();
+        if (!mpv) {
+            printf("failed creating context\n");
+            exit(1);
+        }
+
+        int64_t wid = (intptr_t) self->wrapper;
+        check_error(mpv_set_option(mpv, "wid", MPV_FORMAT_INT64, &wid));
+
+        // Maybe set some options here, like default key bindings.
+        // NOTE: Interaction with the window seems to be broken for now.
+        check_error(mpv_set_option_string(mpv, "input-default-bindings", "yes"));
+
+        // for testing!
+        check_error(mpv_set_option_string(mpv, "input-media-keys", "yes"));
+        check_error(mpv_set_option_string(mpv, "input-cursor", "no"));
+        check_error(mpv_set_option_string(mpv, "input-vo-keyboard", "yes"));
+
+        // request important errors
+        check_error(mpv_request_log_messages(mpv, "warn"));
+
+        check_error(mpv_initialize(mpv));
+
+        // Register to be woken up whenever mpv generates new events.
+        mpv_set_wakeup_callback(mpv, wakeup, (__bridge void *) self);
+
+        // Load the indicated file
+        const char *cmd[] = {"loadfile", filename.UTF8String, NULL};
+        check_error(mpv_command(mpv, cmd));
+    });
+}
+
+- (void) handleEvent:(mpv_event *)event
+{
+    switch (event->event_id) {
+    case MPV_EVENT_SHUTDOWN: {
+        mpv_detach_destroy(mpv);
+        mpv = NULL;
+        printf("event: shutdown\n");
+        break;
+    }
+
+    case MPV_EVENT_LOG_MESSAGE: {
+        struct mpv_event_log_message *msg = (struct mpv_event_log_message *)event->data;
+        printf("[%s] %s: %s", msg->prefix, msg->level, msg->text);
+    }
+
+    case MPV_EVENT_VIDEO_RECONFIG: {
+        dispatch_async(dispatch_get_main_queue(), ^{
+            NSArray *subviews = [self->wrapper subviews];
+            if ([subviews count] > 0) {
+                // mpv's events view
+                NSView *eview = [self->wrapper subviews][0];
+                [self->w makeFirstResponder:eview];
+            }
+        });
+    }
+
+    default:
+        printf("event: %s\n", mpv_event_name(event->event_id));
+    }
+}
+
+- (void) readEvents
+{
+    dispatch_async(queue, ^{
+        while (mpv) {
+            mpv_event *event = mpv_wait_event(mpv, 0);
+            if (event->event_id == MPV_EVENT_NONE)
+                break;
+            [self handleEvent:event];
+        }
+    });
+}
+
+static void wakeup(void *context) {
+    AppDelegate *a = (__bridge AppDelegate *) context;
+    [a readEvents];
+}
+
+// Ostensibly, mpv's window would be hooked up to this.
+- (BOOL) windowShouldClose:(id)sender
+{
+    return NO;
+}
+
+- (void) mpv_stop
+{
+    if (mpv) {
+        const char *args[] = {"stop", NULL};
+        mpv_command(mpv, args);
+    }
+}
+
+- (void) mpv_quit
+{
+    if (mpv) {
+        const char *args[] = {"quit", NULL};
+        mpv_command(mpv, args);
+    }
+}
+@end
+
+// Delete this if you already have a main.m.
+int main(int argc, const char * argv[]) {
+    @autoreleasepool {
+        NSApplication *app = [NSApplication sharedApplication];
+        AppDelegate *delegate = [AppDelegate new];
+        app.delegate = delegate;
+        [app run];
+    }
+    return EXIT_SUCCESS;
+}

DOCS/client_api_examples/qml/main.cpp

@@ -0,0 +1,137 @@
+#include "main.h"
+
+#include <stdexcept>
+#include <clocale>
+
+#include <QObject>
+#include <QtGlobal>
+#include <QOpenGLContext>
+#include <QGuiApplication>
+
+#include <QtGui/QOpenGLFramebufferObject>
+
+#include <QtQuick/QQuickWindow>
+#include <QtQuick/QQuickView>
+
+class MpvRenderer : public QQuickFramebufferObject::Renderer
+{
+    static void *get_proc_address(void *ctx, const char *name) {
+        (void)ctx;
+        QOpenGLContext *glctx = QOpenGLContext::currentContext();
+        if (!glctx)
+            return NULL;
+        return (void *)glctx->getProcAddress(QByteArray(name));
+    }
+
+    mpv::qt::Handle mpv;
+    QQuickWindow *window;
+    mpv_opengl_cb_context *mpv_gl;
+public:
+    MpvRenderer(const MpvObject *obj)
+        : mpv(obj->mpv), window(obj->window()), mpv_gl(obj->mpv_gl)
+    {
+        int r = mpv_opengl_cb_init_gl(mpv_gl, NULL, get_proc_address, NULL);
+        if (r < 0)
+            throw std::runtime_error("could not initialize OpenGL");
+    }
+
+    virtual ~MpvRenderer()
+    {
+        // Until this call is done, we need to make sure the player remains
+        // alive. This is done implicitly with the mpv::qt::Handle instance
+        // in this class.
+        mpv_opengl_cb_uninit_gl(mpv_gl);
+    }
+
+    void render()
+    {
+        QOpenGLFramebufferObject *fbo = framebufferObject();
+        int vp[4] = {0, 0, fbo->width(), fbo->height()};
+        window->resetOpenGLState();
+        mpv_opengl_cb_render(mpv_gl, fbo->handle(), vp);
+        window->resetOpenGLState();
+    }
+};
+
+MpvObject::MpvObject(QQuickItem * parent)
+    : QQuickFramebufferObject(parent), mpv_gl(0)
+{
+    mpv = mpv::qt::Handle::FromRawHandle(mpv_create());
+    if (!mpv)
+        throw std::runtime_error("could not create mpv context");
+
+    mpv_set_option_string(mpv, "terminal", "yes");
+    mpv_set_option_string(mpv, "msg-level", "all=v");
+
+    if (mpv_initialize(mpv) < 0)
+        throw std::runtime_error("could not initialize mpv context");
+
+    // Make use of the MPV_SUB_API_OPENGL_CB API.
+    mpv::qt::set_option_variant(mpv, "vo", "opengl-cb");
+
+    // Request hw decoding, just for testing.
+    mpv::qt::set_option_variant(mpv, "hwdec", "auto");
+
+    // Setup the callback that will make QtQuick update and redraw if there
+    // is a new video frame. Use a queued connection: this makes sure the
+    // doUpdate() function is run on the GUI thread.
+    mpv_gl = (mpv_opengl_cb_context *)mpv_get_sub_api(mpv, MPV_SUB_API_OPENGL_CB);
+    if (!mpv_gl)
+        throw std::runtime_error("OpenGL not compiled in");
+    mpv_opengl_cb_set_update_callback(mpv_gl, MpvObject::on_update, (void *)this);
+    connect(this, &MpvObject::onUpdate, this, &MpvObject::doUpdate,
+            Qt::QueuedConnection);
+}
+
+MpvObject::~MpvObject()
+{
+    if (mpv_gl)
+        mpv_opengl_cb_set_update_callback(mpv_gl, NULL, NULL);
+}
+
+void MpvObject::on_update(void *ctx)
+{
+    MpvObject *self = (MpvObject *)ctx;
+    emit self->onUpdate();
+}
+
+// connected to onUpdate(); signal makes sure it runs on the GUI thread
+void MpvObject::doUpdate()
+{
+    update();
+}
+
+void MpvObject::command(const QVariant& params)
+{
+    mpv::qt::command_variant(mpv, params);
+}
+
+void MpvObject::setProperty(const QString& name, const QVariant& value)
+{
+    mpv::qt::set_property_variant(mpv, name, value);
+}
+
+QQuickFramebufferObject::Renderer *MpvObject::createRenderer() const
+{
+    window()->setPersistentOpenGLContext(true);
+    window()->setPersistentSceneGraph(true);
+    return new MpvRenderer(this);
+}
+
+int main(int argc, char **argv)
+{
+    QGuiApplication app(argc, argv);
+
+    // Qt sets the locale in the QGuiApplication constructor, but libmpv
+    // requires the LC_NUMERIC category to be set to "C", so change it back.
+    std::setlocale(LC_NUMERIC, "C");
+
+    qmlRegisterType<MpvObject>("mpvtest", 1, 0, "MpvObject");
+
+    QQuickView view;
+    view.setResizeMode(QQuickView::SizeRootObjectToView);
+    view.setSource(QUrl("qrc:///mpvtest/main.qml"));
+    view.show();
+
+    return app.exec();
+}

DOCS/client_api_examples/qml/main.h

@@ -0,0 +1,36 @@
+#ifndef MPVRENDERER_H_
+#define MPVRENDERER_H_
+
+#include <QtQuick/QQuickFramebufferObject>
+
+#include <mpv/client.h>
+#include <mpv/opengl_cb.h>
+#include <mpv/qthelper.hpp>
+
+class MpvRenderer;
+
+class MpvObject : public QQuickFramebufferObject
+{
+    Q_OBJECT
+
+    mpv::qt::Handle mpv;
+    mpv_opengl_cb_context *mpv_gl;
+
+    friend class MpvRenderer;
+
+public:
+    MpvObject(QQuickItem * parent = 0);
+    virtual ~MpvObject();
+    virtual Renderer *createRenderer() const;
+public slots:
+    void command(const QVariant& params);
+    void setProperty(const QString& name, const QVariant& value);
+signals:
+    void onUpdate();
+private slots:
+    void doUpdate();
+private:
+    static void on_update(void *ctx);
+};
+
+#endif

DOCS/client_api_examples/qml/main.qml

@@ -0,0 +1,71 @@
+import QtQuick 2.0
+import QtQuick.Controls 1.0
+
+import mpvtest 1.0
+
+Item {
+    width: 1280
+    height: 720
+
+    MpvObject {
+        id: renderer
+        anchors.fill: parent
+
+        MouseArea {
+            anchors.fill: parent
+            onClicked: renderer.command(["loadfile", "../../../test.mkv"])
+        }
+    }
+
+    Rectangle {
+        id: labelFrame
+        anchors.margins: -50
+        radius: 5
+        color: "white"
+        border.color: "black"
+        opacity: 0.8
+        anchors.fill: box
+    }
+
+    Row {
+        id: box
+        anchors.bottom: renderer.bottom
+        anchors.left: renderer.left
+        anchors.right: renderer.right
+        anchors.margins: 100
+
+        Text {
+            anchors.margins: 10
+            wrapMode: Text.WordWrap
+            text: "QtQuick and mpv are both rendering stuff.\n
+                   Click to load ../../../test.mkv"
+        }
+
+        // Don't take these controls too seriously. They're for testing.
+        Column {
+            CheckBox {
+                id: checkbox
+                anchors.margins: 10
+                // Heavily filtered means good, right?
+                text: "Make video look like on a Smart TV"
+                onClicked: {
+                    if (checkbox.checked) {
+                        renderer.command(["vo_cmdline", "scale=sharpen3:scale-param1=5.0"])
+                    } else {
+                        renderer.command(["vo_cmdline", ""])
+                    }
+                }
+            }
+            Slider {
+                id: slider
+                anchors.margins: 10
+                anchors.left: checkbox.left
+                anchors.right: checkbox.right
+                minimumValue: -100
+                maximumValue:  100
+                value: 0
+                onValueChanged: renderer.setProperty("gamma", slider.value | 0)
+            }
+        }
+    }
+}

DOCS/client_api_examples/qml/mpvtest.pro

@@ -0,0 +1,11 @@
+QT += qml quick
+
+HEADERS += main.h
+SOURCES += main.cpp
+
+CONFIG += link_pkgconfig debug
+PKGCONFIG += mpv
+
+RESOURCES += mpvtest.qrc
+
+OTHER_FILES += main.qml

DOCS/client_api_examples/qml/mpvtest.qrc

@@ -0,0 +1,5 @@
+<RCC>
+    <qresource prefix="/mpvtest">
+        <file>main.qml</file>
+    </qresource>
+</RCC>

DOCS/client_api_examples/qml_direct/main.cpp

@@ -0,0 +1,154 @@
+#include "main.h"
+
+#include <stdexcept>
+#include <clocale>
+
+#include <QObject>
+#include <QtGlobal>
+#include <QOpenGLContext>
+
+#include <QGuiApplication>
+#include <QtQuick/QQuickWindow>
+#include <QtQuick/QQuickView>
+
+static void *get_proc_address(void *ctx, const char *name) {
+    (void)ctx;
+    QOpenGLContext *glctx = QOpenGLContext::currentContext();
+    if (!glctx)
+        return NULL;
+    return (void *)glctx->getProcAddress(QByteArray(name));
+}
+
+MpvRenderer::MpvRenderer(mpv::qt::Handle a_mpv, mpv_opengl_cb_context *a_mpv_gl)
+    : mpv(a_mpv), mpv_gl(a_mpv_gl), window(0), size()
+{
+    int r = mpv_opengl_cb_init_gl(mpv_gl, NULL, get_proc_address, NULL);
+    if (r < 0)
+        throw std::runtime_error("could not initialize OpenGL");
+}
+
+MpvRenderer::~MpvRenderer()
+{
+    // Until this call is done, we need to make sure the player remains
+    // alive. This is done implicitly with the mpv::qt::Handle instance
+    // in this class.
+    mpv_opengl_cb_uninit_gl(mpv_gl);
+}
+
+void MpvRenderer::paint()
+{
+    window->resetOpenGLState();
+
+    // Render to the whole window.
+    int vp[4] = {0, 0, size.width(), -size.height()};
+
+    // This uses 0 as framebuffer, which indicates that mpv will render directly
+    // to the frontbuffer. Note that mpv will always switch framebuffers
+    // explicitly. Some QWindow setups (such as using QQuickWidget) actually
+    // want you to render into a FBO in the beforeRendering() signal, and this
+    // code won't work there.
+    mpv_opengl_cb_render(mpv_gl, 0, vp);
+
+    window->resetOpenGLState();
+}
+
+MpvObject::MpvObject(QQuickItem * parent)
+    : QQuickItem(parent), mpv_gl(0), renderer(0)
+{
+    mpv = mpv::qt::Handle::FromRawHandle(mpv_create());
+    if (!mpv)
+        throw std::runtime_error("could not create mpv context");
+
+    mpv_set_option_string(mpv, "terminal", "yes");
+    mpv_set_option_string(mpv, "msg-level", "all=v");
+
+    if (mpv_initialize(mpv) < 0)
+        throw std::runtime_error("could not initialize mpv context");
+
+    // Make use of the MPV_SUB_API_OPENGL_CB API.
+    mpv::qt::set_option_variant(mpv, "vo", "opengl-cb");
+
+    // Setup the callback that will make QtQuick update and redraw if there
+    // is a new video frame. Use a queued connection: this makes sure the
+    // doUpdate() function is run on the GUI thread.
+    mpv_gl = (mpv_opengl_cb_context *)mpv_get_sub_api(mpv, MPV_SUB_API_OPENGL_CB);
+    if (!mpv_gl)
+        throw std::runtime_error("OpenGL not compiled in");
+    mpv_opengl_cb_set_update_callback(mpv_gl, MpvObject::on_update, (void *)this);
+    connect(this, &MpvObject::onUpdate, this, &MpvObject::doUpdate,
+            Qt::QueuedConnection);
+
+    connect(this, &QQuickItem::windowChanged,
+            this, &MpvObject::handleWindowChanged);
+}
+
+MpvObject::~MpvObject()
+{
+    if (mpv_gl)
+        mpv_opengl_cb_set_update_callback(mpv_gl, NULL, NULL);
+}
+
+void MpvObject::handleWindowChanged(QQuickWindow *win)
+{
+    if (!win)
+        return;
+    connect(win, &QQuickWindow::beforeSynchronizing,
+            this, &MpvObject::sync, Qt::DirectConnection);
+    connect(win, &QQuickWindow::sceneGraphInvalidated,
+            this, &MpvObject::cleanup, Qt::DirectConnection);
+    win->setClearBeforeRendering(false);
+}
+
+void MpvObject::sync()
+{
+    if (!renderer) {
+        renderer = new MpvRenderer(mpv, mpv_gl);
+        connect(window(), &QQuickWindow::beforeRendering,
+                renderer, &MpvRenderer::paint, Qt::DirectConnection);
+    }
+    renderer->window = window();
+    renderer->size = window()->size() * window()->devicePixelRatio();
+}
+
+void MpvObject::cleanup()
+{
+    if (renderer) {
+        delete renderer;
+        renderer = 0;
+    }
+}
+
+void MpvObject::on_update(void *ctx)
+{
+    MpvObject *self = (MpvObject *)ctx;
+    emit self->onUpdate();
+}
+
+// connected to onUpdate(); signal makes sure it runs on the GUI thread
+void MpvObject::doUpdate()
+{
+    window()->update();
+}
+
+void MpvObject::command(const QVariant& params)
+{
+    mpv::qt::command_variant(mpv, params);
+}
+
+int main(int argc, char **argv)
+{
+    QGuiApplication app(argc, argv);
+
+    // Qt sets the locale in the QGuiApplication constructor, but libmpv
+    // requires the LC_NUMERIC category to be set to "C", so change it back.
+    std::setlocale(LC_NUMERIC, "C");
+
+    qmlRegisterType<MpvObject>("mpvtest", 1, 0, "MpvObject");
+
+    QQuickView view;
+    view.setResizeMode(QQuickView::SizeRootObjectToView);
+    view.setSource(QUrl("qrc:///mpvtest/main.qml"));
+    view.show();
+
+    return app.exec();
+}

DOCS/client_api_examples/qml_direct/main.h

@@ -0,0 +1,50 @@
+#ifndef MPVRENDERER_H_
+#define MPVRENDERER_H_
+
+#include <QtQuick/QQuickItem>
+
+#include <mpv/client.h>
+#include <mpv/opengl_cb.h>
+#include <mpv/qthelper.hpp>
+
+class MpvRenderer : public QObject
+{
+    Q_OBJECT
+    mpv::qt::Handle mpv;
+    mpv_opengl_cb_context *mpv_gl;
+    QQuickWindow *window;
+    QSize size;
+
+    friend class MpvObject;
+public:
+    MpvRenderer(mpv::qt::Handle a_mpv, mpv_opengl_cb_context *a_mpv_gl);
+    virtual ~MpvRenderer();
+public slots:
+    void paint();
+};
+
+class MpvObject : public QQuickItem
+{
+    Q_OBJECT
+
+    mpv::qt::Handle mpv;
+    mpv_opengl_cb_context *mpv_gl;
+    MpvRenderer *renderer;
+
+public:
+    MpvObject(QQuickItem * parent = 0);
+    virtual ~MpvObject();
+public slots:
+    void command(const QVariant& params);
+    void sync();
+    void cleanup();
+signals:
+    void onUpdate();
+private slots:
+    void doUpdate();
+    void handleWindowChanged(QQuickWindow *win);
+private:
+    static void on_update(void *ctx);
+};
+
+#endif

DOCS/client_api_examples/qml_direct/main.qml

@@ -0,0 +1,49 @@
+import QtQuick 2.0
+import QtQuick.Controls 1.0
+
+import mpvtest 1.0
+
+Item {
+    width: 1280
+    height: 720
+
+    MpvObject {
+        id: renderer
+
+        // This object isn't real and not visible; it just renders into the
+        // background of the containing Window.
+        width: 0
+        height: 0
+    }
+
+    MouseArea {
+        anchors.fill: parent
+        onClicked: renderer.command(["loadfile", "../../../test.mkv"])
+    }
+
+    Rectangle {
+        id: labelFrame
+        anchors.margins: -50
+        radius: 5
+        color: "white"
+        border.color: "black"
+        opacity: 0.8
+        anchors.fill: box
+    }
+
+    Row {
+        id: box
+        anchors.bottom: parent.bottom
+        anchors.left: parent.left
+        anchors.right: parent.right
+        anchors.margins: 100
+
+        Text {
+            anchors.margins: 10
+            wrapMode: Text.WordWrap
+            text: "QtQuick and mpv are both rendering stuff.\n
+                   In this example, mpv is always in the background.\n
+                   Click to load ../../../test.mkv"
+        }
+    }
+}

DOCS/client_api_examples/qml_direct/mpvtest.pro

@@ -0,0 +1,11 @@
+QT += qml quick
+
+HEADERS += main.h
+SOURCES += main.cpp
+
+CONFIG += link_pkgconfig debug
+PKGCONFIG += mpv
+
+RESOURCES += mpvtest.qrc
+
+OTHER_FILES += main.qml

DOCS/client_api_examples/qml_direct/mpvtest.qrc

@@ -0,0 +1,5 @@
+<RCC>
+    <qresource prefix="/mpvtest">
+        <file>main.qml</file>
+    </qresource>
+</RCC>

DOCS/client_api_examples/qt/qtexample.cpp

@@ -0,0 +1,225 @@
+// This example can be built with: qmake && make
+
+#include <clocale>
+#include <sstream>
+#include <stdexcept>
+
+#include <QtGlobal>
+#include <QFileDialog>
+#include <QStatusBar>
+#include <QMenuBar>
+#include <QMenu>
+#include <QGridLayout>
+#include <QApplication>
+#include <QTextEdit>
+
+#if QT_VERSION >= 0x050000
+#include <QJsonDocument>
+#endif
+
+#include <mpv/qthelper.hpp>
+
+#include "qtexample.h"
+
+static void wakeup(void *ctx)
+{
+    // This callback is invoked from any mpv thread (but possibly also
+    // recursively from a thread that is calling the mpv API). Just notify
+    // the Qt GUI thread to wake up (so that it can process events with
+    // mpv_wait_event()), and return as quickly as possible.
+    MainWindow *mainwindow = (MainWindow *)ctx;
+    emit mainwindow->mpv_events();
+}
+
+MainWindow::MainWindow(QWidget *parent) :
+    QMainWindow(parent)
+{
+    setWindowTitle("Qt embedding demo");
+    setMinimumSize(640, 480);
+
+    QMenu *menu = menuBar()->addMenu(tr("&File"));
+    QAction *on_open = new QAction(tr("&Open"), this);
+    on_open->setShortcuts(QKeySequence::Open);
+    on_open->setStatusTip(tr("Open a file"));
+    connect(on_open, &QAction::triggered, this, &MainWindow::on_file_open);
+    menu->addAction(on_open);
+
+    QAction *on_new = new QAction(tr("&New window"), this);
+    connect(on_new, &QAction::triggered, this, &MainWindow::on_new_window);
+    menu->addAction(on_new);
+
+    statusBar();
+
+    QMainWindow *log_window = new QMainWindow(this);
+    log = new QTextEdit(log_window);
+    log->setReadOnly(true);
+    log_window->setCentralWidget(log);
+    log_window->setWindowTitle("mpv log window");
+    log_window->setMinimumSize(500, 50);
+    log_window->show();
+
+    mpv = mpv_create();
+    if (!mpv)
+        throw std::runtime_error("can't create mpv instance");
+
+    // Create a video child window. Force Qt to create a native window, and
+    // pass the window ID to the mpv wid option. Works on: X11, win32, Cocoa
+    mpv_container = new QWidget(this);
+    setCentralWidget(mpv_container);
+    mpv_container->setAttribute(Qt::WA_DontCreateNativeAncestors);
+    mpv_container->setAttribute(Qt::WA_NativeWindow);
+    // If you have a HWND, use: int64_t wid = (intptr_t)hwnd;
+    int64_t wid = mpv_container->winId();
+    mpv_set_option(mpv, "wid", MPV_FORMAT_INT64, &wid);
+
+    // Enable default bindings, because we're lazy. Normally, a player using
+    // mpv as backend would implement its own key bindings.
+    mpv_set_option_string(mpv, "input-default-bindings", "yes");
+
+    // Enable keyboard input on the X11 window. For the messy details, see
+    // --input-vo-keyboard on the manpage.
+    mpv_set_option_string(mpv, "input-vo-keyboard", "yes");
+
+    // Let us receive property change events with MPV_EVENT_PROPERTY_CHANGE if
+    // this property changes.
+    mpv_observe_property(mpv, 0, "time-pos", MPV_FORMAT_DOUBLE);
+
+    mpv_observe_property(mpv, 0, "track-list", MPV_FORMAT_NODE);
+    mpv_observe_property(mpv, 0, "chapter-list", MPV_FORMAT_NODE);
+
+    // Request log messages with level "info" or higher.
+    // They are received as MPV_EVENT_LOG_MESSAGE.
+    mpv_request_log_messages(mpv, "info");
+
+    // From this point on, the wakeup function will be called. The callback
+    // can come from any thread, so we use the QueuedConnection mechanism to
+    // relay the wakeup in a thread-safe way.
+    connect(this, &MainWindow::mpv_events, this, &MainWindow::on_mpv_events,
+            Qt::QueuedConnection);
+    mpv_set_wakeup_callback(mpv, wakeup, this);
+
+    if (mpv_initialize(mpv) < 0)
+        throw std::runtime_error("mpv failed to initialize");
+}
+
+void MainWindow::handle_mpv_event(mpv_event *event)
+{
+    switch (event->event_id) {
+    case MPV_EVENT_PROPERTY_CHANGE: {
+        mpv_event_property *prop = (mpv_event_property *)event->data;
+        if (strcmp(prop->name, "time-pos") == 0) {
+            if (prop->format == MPV_FORMAT_DOUBLE) {
+                double time = *(double *)prop->data;
+                std::stringstream ss;
+                ss << "At: " << time;
+                statusBar()->showMessage(QString::fromStdString(ss.str()));
+            } else if (prop->format == MPV_FORMAT_NONE) {
+                // The property is unavailable, which probably means playback
+                // was stopped.
+                statusBar()->showMessage("");
+            }
+        } else if (strcmp(prop->name, "chapter-list") == 0 ||
+                   strcmp(prop->name, "track-list") == 0)
+        {
+            // Dump the properties as JSON for demo purposes.
+#if QT_VERSION >= 0x050000
+            if (prop->format == MPV_FORMAT_NODE) {
+                QVariant v = mpv::qt::node_to_variant((mpv_node *)prop->data);
+                // Abuse JSON support for easily printing the mpv_node contents.
+                QJsonDocument d = QJsonDocument::fromVariant(v);
+                append_log("Change property " + QString(prop->name) + ":\n");
+                append_log(d.toJson().data());
+            }
+#endif
+        }
+        break;
+    }
+    case MPV_EVENT_VIDEO_RECONFIG: {
+        // Retrieve the new video size.
+        int64_t w, h;
+        if (mpv_get_property(mpv, "dwidth", MPV_FORMAT_INT64, &w) >= 0 &&
+            mpv_get_property(mpv, "dheight", MPV_FORMAT_INT64, &h) >= 0 &&
+            w > 0 && h > 0)
+        {
+            // Note that the MPV_EVENT_VIDEO_RECONFIG event doesn't necessarily
+            // imply a resize, and you should check yourself if the video
+            // dimensions really changed.
+            // mpv itself will scale/letter box the video to the container size
+            // if the video doesn't fit.
+            std::stringstream ss;
+            ss << "Reconfig: " << w << " " << h;
+            statusBar()->showMessage(QString::fromStdString(ss.str()));
+        }
+        break;
+    }
+    case MPV_EVENT_LOG_MESSAGE: {
+        struct mpv_event_log_message *msg = (struct mpv_event_log_message *)event->data;
+        std::stringstream ss;
+        ss << "[" << msg->prefix << "] " << msg->level << ": " << msg->text;
+        append_log(QString::fromStdString(ss.str()));
+        break;
+    }
+    case MPV_EVENT_SHUTDOWN: {
+        mpv_terminate_destroy(mpv);
+        mpv = NULL;
+        break;
+    }
+    default: ;
+        // Ignore uninteresting or unknown events.
+    }
+}
+
+// This slot is invoked by wakeup() (through the mpv_events signal).
+void MainWindow::on_mpv_events()
+{
+    // Process all events, until the event queue is empty.
+    while (mpv) {
+        mpv_event *event = mpv_wait_event(mpv, 0);
+        if (event->event_id == MPV_EVENT_NONE)
+            break;
+        handle_mpv_event(event);
+    }
+}
+
+void MainWindow::on_file_open()
+{
+    QString filename = QFileDialog::getOpenFileName(this, "Open file");
+    if (mpv) {
+        const QByteArray c_filename = filename.toUtf8();
+        const char *args[] = {"loadfile", c_filename.data(), NULL};
+        mpv_command_async(mpv, 0, args);
+    }
+}
+
+void MainWindow::on_new_window()
+{
+    (new MainWindow())->show();
+}
+
+void MainWindow::append_log(const QString &text)
+{
+    QTextCursor cursor = log->textCursor();
+    cursor.movePosition(QTextCursor::End);
+    cursor.insertText(text);
+    log->setTextCursor(cursor);
+}
+
+MainWindow::~MainWindow()
+{
+    if (mpv)
+        mpv_terminate_destroy(mpv);
+}
+
+int main(int argc, char *argv[])
+{
+    QApplication a(argc, argv);
+
+    // Qt sets the locale in the QApplication constructor, but libmpv requires
+    // the LC_NUMERIC category to be set to "C", so change it back.
+    std::setlocale(LC_NUMERIC, "C");
+
+    MainWindow w;
+    w.show();
+
+    return a.exec();
+}

DOCS/client_api_examples/qt/qtexample.h

@@ -5,6 +5,8 @@
 
 #include <mpv/client.h>
 
+class QTextEdit;
+
 class MainWindow : public QMainWindow
 {
     Q_OBJECT
@@ -13,15 +15,20 @@ public:
     explicit MainWindow(QWidget *parent = 0);
     ~MainWindow();
 
-protected:
-    virtual bool event(QEvent *event);
-
 private slots:
     void on_file_open();
+    void on_new_window();
+    void on_mpv_events();
+
+signals:
+    void mpv_events();
 
 private:
     QWidget *mpv_container;
     mpv_handle *mpv;
+    QTextEdit *log;
+
+    void append_log(const QString &text);
 
     void create_player();
     void handle_mpv_event(mpv_event *event);

DOCS/client_api_examples/qt/qtexample.pro

@@ -5,8 +5,8 @@ greaterThan(QT_MAJOR_VERSION, 4): QT += widgets
 TARGET = qtexample
 TEMPLATE = app
 
-CONFIG += link_pkgconfig
-PKGCONFIG = mpv
+CONFIG += link_pkgconfig debug
+PKGCONFIG += mpv
 
 SOURCES += qtexample.cpp
 HEADERS += qtexample.h

DOCS/client_api_examples/qtexample.cpp

@@ -1,136 +0,0 @@
-// License: pick one of: public domain, WTFPL, ISC, Ms-PL, AGPLv3
-
-// This example can be built with: qmake && make
-
-#include <sstream>
-
-#include <QFileDialog>
-#include <QStatusBar>
-#include <QMenuBar>
-#include <QMenu>
-#include <QGridLayout>
-#include <QApplication>
-
-#include "qtexample.h"
-
-static void wakeup(void *ctx)
-{
-    // This callback is invoked from any mpv thread (but possibly also
-    // recursively from a thread that is calling the mpv API). Just notify
-    // the Qt GUI thread to wake up (so that it can process events with
-    // mpv_wait_event()), and return as quickly as possible.
-    MainWindow *mainwindow = (MainWindow *)ctx;
-    QCoreApplication::postEvent(mainwindow, new QEvent(QEvent::User));
-}
-
-MainWindow::MainWindow(QWidget *parent) :
-    QMainWindow(parent)
-{
-    QMenu *menu = menuBar()->addMenu(tr("&File"));
-    QAction *on_open = new QAction(tr("&Open"), this);
-    on_open->setShortcuts(QKeySequence::Open);
-    on_open->setStatusTip(tr("Open a file"));
-    connect(on_open, SIGNAL(triggered()), this, SLOT(on_file_open()));
-    menu->addAction(on_open);
-
-    statusBar();
-
-    mpv = mpv_create();
-    if (!mpv)
-        throw "can't create mpv instance";
-
-    // Create a video child window. Force Qt to create a native window, and
-    // pass the window ID to the mpv wid option. This doesn't work on OSX,
-    // because Cocoa doesn't support this form of embedding.
-    mpv_container = new QWidget(this);
-    setCentralWidget(mpv_container);
-    mpv_container->setAttribute(Qt::WA_NativeWindow);
-    int64_t wid = mpv_container->winId();
-    mpv_set_option(mpv, "wid", MPV_FORMAT_INT64, &wid);
-
-    // Enable default bindings, because we're lazy. Normally, a player using
-    // mpv as backend would implement its own key bindings.
-    mpv_set_option_string(mpv, "input-default-bindings", "yes");
-
-    // Let us receive property change events with MPV_EVENT_PROPERTY_CHANGE if
-    // this property changes.
-    mpv_observe_property(mpv, 0, "time-pos", MPV_FORMAT_DOUBLE);
-
-    // From this point on, the wakeup function will be called. The callback
-    // can come from any thread, so we use the Qt QEvent mechanism to relay
-    // the wakeup in a thread-safe way.
-    mpv_set_wakeup_callback(mpv, wakeup, this);
-
-    if (mpv_initialize(mpv) < 0)
-        throw "mpv failed to initialize";
-}
-
-void MainWindow::handle_mpv_event(mpv_event *event)
-{
-    switch (event->event_id) {
-    case MPV_EVENT_PROPERTY_CHANGE: {
-        mpv_event_property *prop = (mpv_event_property *)event->data;
-        if (strcmp(prop->name, "time-pos") == 0) {
-            if (prop->format == MPV_FORMAT_DOUBLE) {
-                double time = *(double *)prop->data;
-                std::stringstream ss;
-                ss << "At: " << time;
-                statusBar()->showMessage(QString::fromStdString(ss.str()));
-            } else if (prop->format == MPV_FORMAT_NONE) {
-                // The property is unavailable, which probably means playback
-                // was stopped.
-                statusBar()->showMessage("");
-            }
-        }
-        break;
-    }
-    case MPV_EVENT_SHUTDOWN: {
-        mpv_terminate_destroy(mpv);
-        mpv = NULL;
-        break;
-    }
-    default: ;
-        // Ignore uninteresting or unknown events.
-    }
-}
-
-bool MainWindow::event(QEvent *event)
-{
-    // QEvent::User is sent by wakeup().
-    if (event->type() == QEvent::User) {
-        // Process all events, until the event queue is empty.
-        while (mpv) {
-            mpv_event *event = mpv_wait_event(mpv, 0);
-            if (event->event_id == MPV_EVENT_NONE)
-                break;
-            handle_mpv_event(event);
-        }
-        return true;
-    }
-    return QMainWindow::event(event);
-}
-
-void MainWindow::on_file_open()
-{
-    QString filename = QFileDialog::getOpenFileName(this, "Open file");
-    if (mpv) {
-        const QByteArray c_filename = filename.toUtf8();
-        const char *args[] = {"loadfile", c_filename.data(), NULL};
-        mpv_command_async(mpv, 0, args);
-    }
-}
-
-MainWindow::~MainWindow()
-{
-    if (mpv)
-        mpv_terminate_destroy(mpv);
-}
-
-int main(int argc, char *argv[])
-{
-    QApplication a(argc, argv);
-    MainWindow w;
-    w.show();
-
-    return a.exec();
-}

DOCS/client_api_examples/shared.h

@@ -1,10 +0,0 @@
-#include <stdio.h>
-#include <stdlib.h>
-
-static inline void check_error(int status)
-{
-    if (status < 0) {
-        printf("mpv API error: %s\n", mpv_error_string(status));
-        exit(1);
-    }
-}

DOCS/client_api_examples/simple/simple.c

@@ -1,9 +1,18 @@
+// Build with: gcc -o simple simple.c `pkg-config --libs --cflags mpv`
+
 #include <stddef.h>
 #include <stdio.h>
 #include <stdlib.h>
 
-#include "libmpv/client.h"
-#include "shared.h"
+#include <mpv/client.h>
+
+static inline void check_error(int status)
+{
+    if (status < 0) {
+        printf("mpv API error: %s\n", mpv_error_string(status));
+        exit(1);
+    }
+}
 
 int main(int argc, char *argv[])
 {
@@ -21,6 +30,7 @@ int main(int argc, char *argv[])
     // Enable default key bindings, so the user can actually interact with
     // the player (and e.g. close the window).
     check_error(mpv_set_option_string(ctx, "input-default-bindings", "yes"));
+    mpv_set_option_string(ctx, "input-vo-keyboard", "yes");
     int val = 1;
     check_error(mpv_set_option(ctx, "osc", MPV_FORMAT_FLAG, &val));
 

DOCS/compile-windows.md

@@ -0,0 +1,211 @@
+Compiling for Windows
+=====================
+
+Compiling for Windows is supported with MinGW-w64. This can be used to produce
+both 32-bit and 64-bit executables, and it works for building on Windows and
+cross-compiling from Linux and Cygwin. MinGW-w64 is available from:
+http://mingw-w64.sourceforge.net.
+
+While building a complete MinGW-w64 toolchain yourself is possible, there are a
+few build environments and scripts to help ease the process, such as MSYS2 and
+MXE. Note that MinGW environments included in Linux distributions are often
+broken, outdated and useless, and usually don't use MinGW-w64.
+
+**Warning**: the original MinGW (http://www.mingw.org) is unsupported.
+
+Cross-compilation
+=================
+
+When cross-compiling, you have to run mpv's configure with these arguments:
+
+```bash
+DEST_OS=win32 TARGET=i686-w64-mingw32 ./waf configure
+```
+
+[MXE](http://mxe.cc) makes it very easy to bootstrap a complete MingGW-w64
+environment from a Linux machine. See a working example below.
+
+Alternatively, you can try [mingw-w64-cmake](https://github.com/lachs0r/mingw-w64-cmake),
+which bootstraps a MinGW-w64 environment and builds mpv and dependencies.
+
+Example with MXE
+----------------
+
+```bash
+# Before starting, make sure you install MXE prerequisites. MXE will download
+# and build all target dependencies, but no host dependencies. For example,
+# you need a working compiler, or MXE can't build the crosscompiler.
+#
+# Refer to
+#
+#    http://mxe.cc/#requirements
+#
+# Scroll down for disto/OS-specific instructions to install them.
+
+# Download MXE. Note that compiling the required packages requires about 1.4 GB
+# or more!
+
+cd /opt
+git clone https://github.com/mxe/mxe mxe
+cd mxe
+
+# Set build options.
+
+# The JOBS environment variable controls threads to use when building. DO NOT
+# use the regular `make -j4` option with MXE as it will slow down the build.
+# Alternatively, you can set this in the make command by appending "JOBS=4"
+# to the end of command:
+echo "JOBS := 4" >> settings.mk
+
+# The MXE_TARGET environment variable builds MinGW-w64 for 32 bit targets.
+# Alternatively, you can specify this in the make command by appending
+# "MXE_TARGETS=i686-w64-mingw32" to the end of command:
+echo "MXE_TARGETS := i686-w64-mingw32.static" >> settings.mk
+
+# If you want to build 64 bit version, use this:
+# echo "MXE_TARGETS := x86_64-w64-mingw32.static" >> settings.mk
+
+# Build required packages. The following provide a minimum required to build
+# a reasonable mpv binary (though not an absolute minimum).
+
+make gcc ffmpeg libass jpeg pthreads lua
+
+# Add MXE binaries to $PATH
+export PATH=/opt/mxe/usr/bin/:$PATH
+
+# Build mpv. The target will be used to automatically select the name of the
+# build tools involved (e.g. it will use i686-w64-mingw32.static-gcc).
+
+cd ..
+git clone https://github.com/mpv-player/mpv.git
+cd mpv
+DEST_OS=win32 TARGET=i686-w64-mingw32.static ./waf configure
+# Or, if 64 bit version,
+# DEST_OS=win32 TARGET=x86_64-w64-mingw32.static ./waf configure
+./waf build
+```
+
+Native compilation with MSYS2
+=============================
+
+For Windows developers looking to get started quickly, MSYS2 can be used to
+compile mpv natively on a Windows machine. The MSYS2 repositories have binary
+packages for most of mpv's dependencies, so the process should only involve
+building mpv itself.
+
+To build 64-bit mpv on Windows:
+
+Installing MSYS2
+----------------
+
+1. Download an installer from https://msys2.github.io/
+
+   It doesn't matter whether the i686 or the x86_64 version is used. Both can
+   build 32-bit and 64-bit binaries when running on a 64-bit version of Windows.
+
+2. Add ``C:\msys64\mingw64\bin`` to your ``%PATH%``. mpv will depend on several
+   DLLs in this folder.
+
+3. Start a MinGW-w64 shell (``mingw64_shell.bat``). For a 32-bit build, use
+   ``mingw32_shell.bat``.
+
+Updating MSYS2
+--------------
+
+To prevent errors during post-install, ``msys2-runtime`` and ``pacman`` must be
+updated first.
+
+```bash
+# Check for updates to msys2-runtime and pacman. If there were updates, restart
+# MSYS2 before continuing.
+pacman -Sy --needed msys2-runtime pacman
+
+# Update everything else
+pacman -Su
+```
+
+Installing mpv dependencies
+---------------------------
+
+```bash
+# Install MSYS2 build dependencies and a MinGW-w64 compiler
+pacman -S git pkg-config python3 mingw-w64-x86_64-gcc
+
+# Install the most important MinGW-w64 dependencies. libass, libbluray and
+# lcms2 are also pulled in as dependencies of ffmpeg.
+pacman -S mingw-w64-x86_64-ffmpeg mingw-w64-x86_64-libjpeg-turbo mingw-w64-x86_64-lua
+
+# Install additional (optional) dependencies
+pacman -S mingw-w64-x86_64-libdvdnav mingw-w64-x86_64-mpg123 mingw-w64-x86_64-libguess
+```
+
+For a 32-bit build, install ``mingw-w64-i686-*`` packages instead.
+
+Building mpv
+------------
+
+Clone the latest mpv from git and install waf:
+
+```bash
+git clone https://github.com/mpv-player/mpv.git && cd mpv
+./bootstrap.py
+```
+
+Finally, compile and install mpv. Binaries will be installed to
+``/mingw64/bin``.
+
+```bash
+# For a 32-bit build, use --prefix=/mingw32 instead
+./waf configure CC=gcc --prefix=/mingw64
+./waf install
+```
+
+Or, compile and install both libmpv and mpv:
+
+```bash
+./waf configure CC=gcc --enable-libmpv-shared --prefix=/mingw64
+./waf install
+
+# waf installs libmpv to the wrong directory, so fix it up
+mv -f /mingw64/bin/pkgconfig/mpv.pc /mingw64/lib/pkgconfig/
+mv -f /mingw64/bin/libmpv.dll.a /mingw64/lib/
+sed -i 's_/mingw64/bin_/mingw64/lib_' /mingw64/lib/pkgconfig/mpv.pc
+rmdir /mingw64/bin/pkgconfig
+```
+
+Additional dependencies
+=======================
+
+pthreads
+--------
+
+mpv will use a pthreads wrapper by default. Either pthreads-win32 or
+winpthreads should work. The latter is packaged with most MinGW-w64
+environments, including MSYS2, so it shouldn't be a problem. If you don't have
+a pthreads wrapper or you want to build mpv without one, configure with:
+
+```bash
+./waf configure --enable-win32-internal-pthreads
+```
+
+libwaio
+-------
+
+If you want to use ``--input-file``, you need libwaio. It's available from
+git://midipix.org/waio
+
+To compile libwaio in MSYS2, run:
+
+```bash
+git clone git://midipix.org/waio && cd waio
+
+# 32-bit build, run from mingw32_shell.bat
+./build-mingw-nt32 lib-static CC=gcc AR=ar
+cp -r include/waio /mingw32/include
+cp lib32/libwaio.a /mingw32/lib
+
+# 64-bit build, run from mingw64_shell.bat
+./build-mingw-nt64 lib-static CC=gcc AR=ar
+cp -r include/waio /mingw64/include
+cp lib64/libwaio.a /mingw64/lib
+```

DOCS/contribute.md

@@ -4,8 +4,8 @@ How to contribute
 General
 -------
 
-The main contact for mpv development is IRC, specifically #mpv-player and
-#mpv-player-dev on Freenode.
+The main contact for mpv development is IRC, specifically #mpv-player
+and #mpv-player-dev on Freenode.
 
 Sending patches
 ---------------
@@ -118,6 +118,8 @@ mpv uses C99 with K&R formatting, with some exceptions.
         very_long_condition_b)
     {
         code();
+    } else {
+        ...
     }
     ```
 - Remove any trailing whitespace.

DOCS/crosscompile-mingw.md

@@ -1,74 +0,0 @@
-Cross Compiling to Windows
-==========================
-
-Cross compiling mpv to Windows is supported with MinGW-w64. This can be used to
-produce both 32 bit and 64 bit executables. MinGW-w64 is available from
-http://mingw-w64.sourceforge.net.
-
-You have to run mpv's configure with these arguments:
-
-```bash
-DEST_OS=win32 TARGET=i686-w64-mingw32 ./waf configure
-```
-
-While building a complete MinGW-w64 toolchain yourself is possible, people have
-created scripts to help ease the process. These are the two recommended methods:
-
-- Using [mingw-w64-cmake](https://github.com/lachs0r/mingw-w64-cmake) to setup
-  a MinGW-w64 environment. We recommend you to try this first before MXE.
-  mingw-w64-cmake will also build mpv and its dependencies.
-- Alternatively, you can use MXE: http://mxe.cc. With MXE, you have to manually
-  set the target to MinGW-w64 (even if you compile to 32 bit). A working example
-  below.
-
-**Warning**: the original MinGW (http://www.mingw.org) is unsupported.
-
-Note that MinGW environments included in Linux distributions are often broken,
-outdated and useless, and usually don't use MinGW-w64.
-
-Example with MXE
-----------------
-
-```bash
-# Download MXE. Note that compiling the required packages requires about 1.4 GB
-# or more!
-
-cd /opt
-git clone https://github.com/mxe/mxe mingw
-cd mingw
-
-# Set build options.
-
-# The JOBS environment variable controls threads to use when building. DO NOT
-# use the regular `make -j4` option with MXE as it will slow down the build.
-# Alternatively, you can set this in the make command by appending "JOBS=4"
-# to the end of command:
-echo "JOBS := 4" >> settings.mk
-
-# The MXE_TARGET environment variable builds MinGW-w64 for 32 bit targets.
-# Alternatively, you can specify this in the make command by appending
-# "MXE_TARGETS=i686-w64-mingw32" to the end of command:
-echo "MXE_TARGETS := i686-w64-mingw32" >> settings.mk
-
-# If you want to build 64 bit version, use this:
-# echo "MXE_TARGETS := x86_64-w64-mingw32" >> settings.mk
-
-# Build required packages. The following provide a minimum required to build
-# mpv.
-
-make gcc ffmpeg libass jpeg pthreads
-
-# Add MXE binaries to $PATH
-export PATH=/opt/mingw/usr/bin/:$PATH
-
-# Build mpv. The target will be used to automatically select the name of the
-# build tools involved (e.g. it will use i686-w64-mingw32-gcc).
-
-cd ..
-git clone https://github.com/mpv-player/mpv.git
-cd mpv
-DEST_OS=win32 TARGET=i686-w64-mingw32 ./waf configure
-# Or, if 64 bit version,
-# DEST_OS=win32 TARGET=x86_64-w64-mingw32 ./waf configure
-./waf build
-```

DOCS/edl-mpv.rst

@@ -27,13 +27,13 @@ The general simplified syntax is::
     <filename>,<start in seconds>,<length in seconds>
 
 If the start time is omitted, 0 is used. If the length is omitted, the
-estimated duration of the source file is used.
+estimated remaining duration of the source file is used.
 
 Note::
 
-    mpv can't use ordered chapter files or libquvi-resolved URLs in EDL
-    entries. Usage of relative or absolute paths as well as any protocol
-    prefixes is prevented for security reasons.
+    mpv can't use ordered chapter files in EDL entries. Usage of relative or
+    absolute paths as well as any protocol prefixes is prevented for security
+    reasons.
 
 
 Syntax of mpv EDL files

DOCS/man/af.rst

@@ -77,10 +77,12 @@ Available filters are:
     ``bitrate=<rate>``
         The bitrate use for the AC-3 stream. Set it to 384 to get 384 kbps.
 
+        The default is 640. Some receivers might not be able to handle this.
+
         Valid values: 32, 40, 48, 56, 64, 80, 96, 112, 128,
         160, 192, 224, 256, 320, 384, 448, 512, 576, 640.
 
-        The special value ``default`` selects a default bitrate based on the
+        The special value ``auto`` selects a default bitrate based on the
         input channel number:
 
         :1ch: 96
@@ -92,7 +94,7 @@ Available filters are:
 
     ``minchn=<n>``
         If the input channel number is less than ``<minchn>``, the filter will
-        detach itself (default: 5).
+        detach itself (default: 3).
 
 ``sweep[=speed]``
     Produces a sine sweep.
@@ -263,9 +265,8 @@ Available filters are:
     Filter for internal use only. Converts between 24-bit and 32-bit sample
     formats.
 
-``convertsignendian``
-    Filter for internal use only. Converts between signed/unsigned formats
-    and formats with different endian.
+``convertsign``
+    Filter for internal use only. Converts between signed/unsigned formats.
 
 ``volume[=<volumedb>[:...]]``
     Implements software volume control. Use this filter with caution since it
@@ -564,9 +565,10 @@ Available filters are:
              Scale tempo in sync with speed (default).
         pitch
              Reverses effect of filter. Scales pitch without altering tempo.
-             Add ``[ speed_mult 0.9438743126816935`` and ``] speed_mult
-             1.059463094352953`` to your ``input.conf`` to step by musical
-             semi-tones.
+             Add this to your ``input.conf`` to step by musical semi-tones::
+
+                [ multiply speed 0.9438743126816935
+                ] multiply speed 1.059463094352953
 
              .. warning::
 

DOCS/man/ao.rst

@@ -28,8 +28,8 @@ normal driver parameters.
 .. admonition:: Examples
 
     - ``--ao=alsa,oss,`` Try the ALSA driver, then the OSS driver, then others.
-    - ``--ao=alsa:no-block:device=[hw:0,3]`` Sets noblock-mode and the
-      device-name as first card, fourth device.
+    - ``--ao=alsa:resample=yes:device=[plughw:0,3]`` Lets ALSA resample and
+      sets the device-name as first card, fourth device.
 
 Available audio output drivers are:
 
@@ -39,8 +39,6 @@ Available audio output drivers are:
     ``device=<device>``
         Sets the device name. For ac3 output via S/PDIF, use an "iec958" or
         "spdif" device, unless you really know how to set it correctly.
-    ``no-block``
-        Sets noblock-mode.
     ``resample=yes``
         Enable ALSA resampling plugin. (This is disabled by default, because
         some drivers report incorrect audio delay in some cases.)
@@ -70,6 +68,40 @@ Available audio output drivers are:
         shells (like zsh), you have to quote the option string to prevent the
         shell from interpreting the brackets instead of passing them to mpv.
 
+        Actually, you should use the ``--audio-device`` option, instead of
+        setting the device directly.
+
+    .. warning::
+
+        Handling of multichannel/surround audio changed in mpv 0.8.0 from the
+        behavior in MPlayer/mplayer2 and older versions of mpv.
+
+        The old behavior is that the player always downmixed to stereo by
+        default. The ``--audio-channels`` (or ``--channels`` before that) option
+        had to be set to get multichannel audio. Then playing stereo would
+        use the ``default`` device (which typically allows multiple programs
+        to play audio at the same time via dmix), while playing anything with
+        more channels would open one of the hardware devices, e.g. via the
+        ``surround51`` alias (typically with exclusive access). Whether the
+        player would use exclusive access or not would depend on the file
+        being played.
+
+        The new behavior since mpv 0.8.0 always enables multichannel audio,
+        i.e. ``--audio-channels=auto`` is the default. However, since ALSA
+        provides no good way to play multichannel audio in a non-exclusive
+        way (without blocking other applications from using audio), the player
+        is restricted to the capabilities of the ``default`` device by default,
+        which means it supports only stereo and mono (at least with current
+        typical ALSA configurations). But if a hardware device is selected,
+        then multichannel audio will typically work.
+
+        The short story is: if you want multichannel audio with ALSA, use
+        ``--audio-device`` to select the device (use ``--audio-device=help``
+        to get a list of all devices and their mpv name).
+
+        You can also try
+        `Using the upmix plugin <https://github.com/mpv-player/mpv/wiki/ALSA:-Surround-Sound-and-Upmixing>`_.
+
 ``oss``
     OSS audio output driver
 
@@ -114,25 +146,18 @@ Available audio output drivers are:
         with fixed setups.
 
 ``coreaudio`` (Mac OS X only)
-    Native Mac OS X audio output driver using the AudioUnits and the CoreAudio
+    Native Mac OS X audio output driver using AudioUnits and the CoreAudio
     sound server.
 
-    ``device_id=<id>``
-        ID of output device to use (0 = default device)
-    ``help``
-        List all available output devices with their IDs.
+    Automatically redirects to ``coreaudio_exclusive`` when playing compressed
+    formats.
 
-``coreaudio_device`` (Mac OS X only)
+``coreaudio_exclusive`` (Mac OS X only)
     Native Mac OS X audio output driver using direct device access and
     exclusive mode (bypasses the sound server).
 
     Supports only compressed formats (AC3 and DTS).
 
-    ``device_id=<id>``
-        ID of output device to use (0 = default device)
-    ``help``
-        List all available output devices with their IDs.
-
 ``openal``
     Experimental OpenAL audio output driver
 
@@ -154,23 +179,15 @@ Available audio output drivers are:
         changes. Default: 250.
 
     ``latency-hacks=<yes|no>``
-        Enable hacks to workaround PulseAudio timing bugs (default: yes). If
+        Enable hacks to workaround PulseAudio timing bugs (default: no). If
         enabled, mpv will do elaborate latency calculations on its own. If
         disabled, it will use PulseAudio automatically updated timing
-        information. Disabling this might help with e.g. networked audio.
+        information. Disabling this might help with e.g. networked audio or
+        some plugins, while enabling it might help in some unknown situations
+        (it used to be required to get good behavior on old PulseAudio versions).
 
-``portaudio``
-    PortAudio audio output driver. This works on all platforms, and has
-    extensive MS Windows support.
-
-    .. note:: This driver is not very useful. It was added in the hope of
-              providing portable audio API across all platforms, but turned
-              out semi-broken and underfeatured.
-
-    ``device``
-        Specify the subdevice to use. Giving ``help`` as device name lists all
-        devices found by PortAudio. Devices can be given as numeric values,
-        starting from ``1``.
+        If you have stuttering video when using pulse, try to enable this
+        option. (Or alternatively, try to update PulseAudio.)
 
 ``dsound`` (Windows only)
     DirectX DirectSound audio output driver
@@ -181,6 +198,9 @@ Available audio output drivers are:
         Sets the device number to use. Playing a file with ``-v`` will show a
         list of available devices.
 
+    ``buffersize=<ms>``
+        DirectSound buffer size in milliseconds (default: 200).
+
 ``sdl``
     SDL 1.2+ audio output driver. Should work on any platform supported by SDL
     1.2, but may require the ``SDL_AUDIODRIVER`` environment variable to be set
@@ -227,6 +247,9 @@ Available audio output drivers are:
         Simulate broken audio drivers, which always add the fixed device
         latency to the reported audio playback position.
 
+    ``broken-delay``
+        Simulate broken audio drivers, which don't report latency correctly.
+
 ``pcm``
     Raw PCM/WAVE file writer audio output
 
@@ -237,6 +260,10 @@ Available audio output drivers are:
         Write the sound to ``<filename>`` instead of the default
         ``audiodump.wav``. If ``no-waveheader`` is specified, the default is
         ``audiodump.pcm``.
+    ``(no-)append``
+        Append to the file, instead of overwriting it. Always use this with the
+        ``no-waveheader`` option - with ``waveheader`` it's broken, because
+        it will write a WAVE header every time the file is opened.
 
 ``rsound``
     Audio output to an RSound daemon

DOCS/man/changes.rst

@@ -1,383 +1,13 @@
-CHANGES FROM OTHER VERSIONS OF MPLAYER
-======================================
+CHANGELOG
+=========
 
-**mpv** is based on mplayer2, which in turn is based on the original MPlayer
-(also called mplayer, mplayer-svn, mplayer1). Many changes have been made, a
-large part of which is incompatible or completely changes how the player
-behaves. Although there are still many similarities to its ancestors, **mpv**
-should generally be treated as a completely different program.
+There is no real changelog, but you can look at the following things:
 
-.. note::
-    These lists are incomplete.
+* The release changelog, which should contain most user-visible changes,
+  including new features and bug fixes:
 
-General Changes for MPlayer to mpv
-----------------------------------
-
-* Switch to GPLv2+. (Technically speaking, MPlayer as a whole seems to be
-  GPLv2-only, while mplayer2 is GPLv3+ - see ``Copyright`` file for details.)
-* Removal of the internal GUI, MEncoder, OSD menu, video kernel drivers for
-  Linux 2.4 (including VIDIX)
-* Large internal cleanups
-* Removal of support for dead platforms
-* New build system
-* No embedded copy of FFmpeg and other libraries
-* Better pause handling (do not unpause on a command)
-* Better MKV support (such as ordered chapters)
-* vo_vdpau improvements
-* Precise seeking support
-* Native OpenGL backend for OS X
-* General OS X improvements
-* Improvements in audio/video sync handling
-* Cleaned up terminal output
-* Gapless audio support (``--gapless-audio``)
-* Improved responsiveness on user input
-* Support for modifier keys (alt, shift, ctrl) in input.conf
-* OSS4 volume control
-* More correct color reproduction (color matrix generation)
-* Use libass for subtitle rendering by default (better quality)
-* Generally preferring FFmpeg/Libav over internal demuxers and decoders
-* Improvements when playing multiple files (``--fixed-vo``)
-* Screenshot improvements (instant screenshots without 1-frame delay, allow
-  taking screenshots even with hardware decoding)
-* Improved support for PulseAudio
-* Generally improved MS Windows support (dealing with Unicode file names,
-  improved ``--vo=direct3d``, improved window handling)
-* Better OSD rendering (using libass). This has full Unicode support, and
-  languages like Arabic should be better supported.
-* Cleaned up terminal output (nicer status line, less useless noise)
-* Support for playing URLs of popular streaming sites directly
-  (e.g. ``mpv https://www.youtube.com/watch?v=...``)
-* Improved OpenGL output (``--vo=opengl-hq``)
-* Make ``--softvol`` default (**mpv** is not a mixer control panel)
-* Improved support for .cue files
-* Screenshot improvements (can save screenshots as JPEG or PNG, configurable
-  file names, support for taking screenshots with or without subtitles - the
-  ``screenshot`` video filter is not needed anymore, and should not be put
-  into the mpv config file)
-* Removal of teletext support
-* Removal of most built-in demuxers, using libavformat instead
-* Removal of built-in network support, using libavformat instead (also,
-  support https via libavformat)
-* Replace image VOs (``--vo=jpeg`` etc.) with ``--vo=image``
-* Do not lose settings when playing a new file in the same player instance
-* New location for config files, new name for the binary.
-* Slave mode compatibility broken (see below)
-* Encoding functionality (replacement for MEncoder, see ``DOCS/encoding.rst``)
-* Remove ``--vo=gif89a``, ``--vo=md5sum``, ``--vo=yuv4mpeg``, as encoding can
-  handle these use cases. For yuv4mpeg, for example, use:
-  ``mpv input.mkv -o output.y4m --no-audio --oautofps --oneverdrop``.
-* Image subtitles (DVDs etc.) are rendered in color and use more correct
-  positioning (color can be disabled with ``--sub-gray``)
-* Wayland support
-* Support for precise scrolling which scales the parameter of commands. If the
-  input doesn't support precise scrolling the scale factor stays 1.
-* OS X: Cocoa event loop is independent from MPlayer's event loop, so user
-  actions like accessing menus and live resizing do not block the playback.
-* OS X: Apple Remote support.
-* OS X: Media Keys support.
-* Windows: Added WASAPI audio output.
-* New OSD bar with chapter marks and not positioned in the middle of the video
-  (though this can be customized with the ``--osd-bar-align-y`` option).
-* Allow customizing whether a key binding for seeking shows the video time, the
-  OSD bar, or nothing (see section `Input Command Prefixes`_).
-* Display list of chapters and audio/subtitle tracks on OSD (see section
-  `Properties`_).
-* ``--keep-open`` option to stop the player from closing the window and
-  exiting after playback ends.
-* Re-enable screensaver while the player is paused.
-* Matroska edition switching at runtime.
-* Support for libavfilter (for video->video and audio->audio). This allows
-  using most of FFmpeg's filters, which improve greatly on the old MPlayer
-  filters in features, performance, and correctness.
-* Improved downmixing and output of surround audio. Instead of using hardcoded
-  pan filters to do remixing, use libavresample. Channel maps are used to
-  identify the channel layout, so e.g. ``3.0`` and ``2.1`` audio can be
-  distinguished.
-* Allow resuming playback at a later point with ``Shift+q``, also see
-  ``quit_watch_later`` input command.
-* Support mapping multiple commands to one key.
-* Allow changing/adjusting video filters at runtime. (This is also used to make
-  the ``D`` key insert vf_yadif if deinterlacing is not supported otherwise.)
-* Native VAAPI support
-* OS X: VDA support using libavcodec hwaccel API instead of FFmpeg's decoder. Up
-  to 2-2.5x reduction in CPU usage.
-* Make hardware decoding in general work with the ``opengl`` video output.
-* Lua scripting (see `LUA SCRIPTING`_)
-* A client API, that allows embedding **mpv** into applications
-  (see ``libmpv/client.h`` in the sources)
-* General bug fixes and removal of long-standing issues
-* General code cleanups (including refactoring or rewrites of many parts)
-* Many more changes
-
-Detailed Listing of User-visible Changes
-----------------------------------------
-
-This listing is about changed command line switches, slave commands, and similar
-things. Completely removed features are not listed.
-
-Command Line Switches
-~~~~~~~~~~~~~~~~~~~~~
-
-* There is a new command line syntax, which is generally preferred over the old
-  syntax. ``-optname optvalue`` becomes ``--optname=optvalue``.
-
-  The old syntax will not be removed. However, the new syntax is mentioned in
-  all documentation and so on, and unlike the old syntax is not ambiguous,
-  so it is a good thing to know about this change.
-* In general, negating switches like ``-noopt`` now have to be written as
-  ``-no-opt`` or ``--no-opt``.
-* Per-file options are not the default anymore. You can explicitly specify
-  file-local options. See ``Usage`` section.
-* Many options have been renamed, removed or changed semantics. Some options
-  that are required for a good playback experience with MPlayer are now
-  superfluous or even worse than the defaults, so make sure to read the manual
-  before trying to use your existing configuration with **mpv**.
-* Table of renamed/replaced switches:
-
-    =========================== ========================================
-    Old                         New
-    =========================== ========================================
-    ``-no<opt>``                ``--no-<opt>`` (add a dash)
-    ``-a52drc level``           ``--ad-lavc-ac3drc=level``
-    ``-ac spdifac3``            ``--ad=spdif:ac3`` (see ``--ad=help``)
-    ``-af volnorm``             ``--af=drc`` (renamed)
-    ``-afm hwac3``              ``--ad=spdif:ac3,spdif:dts``
-    ``-ao alsa:device=hw=0.3``  ``--ao=alsa:device=[hw:0,3]``
-    ``-aspect``                 ``--video-aspect``
-    ``-ass-bottom-margin``      ``--vf=sub=bottom:top``
-    ``-ass``                    ``--sub-ass``
-    ``-audiofile-cache``        (removed; the main cache settings are used)
-    ``-audiofile``              ``--audio-file``
-    ``-benchmark``              ``--untimed`` (no stats)
-    ``-capture``                ``--stream-capture=<filename>``
-    ``-channels``               ``--audio-channels`` (changed semantics)
-    ``-cursor-autohide-delay``  ``--cursor-autohide``
-    ``-delay``                  ``--audio-delay``
-    ``-dumpstream``             ``--stream-dump=<filename>``
-    ``-dvdangle``               ``--dvd-angle``
-    ``-endpos``                 ``--length``
-    ``-font``                   ``--osd-font``
-    ``-forcedsubsonly``         ``--sub-forced-only``
-    ``-forceidx``               ``--index``
-    ``-format``                 ``--audio-format``
-    ``-fsmode-dontuse``         (removed)
-    ``-fstype``                 ``--x11-netwm`` (changed semantics)
-    ``-hardframedrop``          ``--framedrop=hard``
-    ``-identify``               (removed; use TOOLS/mpv_identify.sh)
-    ``-idx``                    ``--index``
-    ``-lavdopts ...``           ``--vd-lavc-...``
-    ``-lavfdopts``              ``--demuxer-lavf-...``
-    ``-lircconf``               ``--input-lirc-conf``
-    ``-loop 0``                 ``--loop=inf``
-    ``-mixer-channel``          AO suboptions (``alsa``, ``oss``)
-    ``-mixer``                  AO suboptions (``alsa``, ``oss``)
-    ``-mouse-movements``        ``--input-cursor``
-    ``-msgcolor``               ``--msg-color``
-    ``-msglevel``               ``--msg-level`` (changed semantics)
-    ``-msgmodule``              ``--msg-module``
-    ``-name``                   ``--x11-name``
-    ``-noar``                   ``--no-input-appleremote``
-    ``-noautosub``              ``--no-sub-auto``
-    ``-noconsolecontrols``      ``--no-input-terminal``
-    ``-nojoystick``             ``--no-input-joystick``
-    ``-nosound``                ``--no-audio``
-    ``-osdlevel``               ``--osd-level``
-    ``-panscanrange``           ``--video-zoom``, ``--video-pan-x/y``
-    ``-playing-msg``            ``--term-playing-msg``
-    ``-pp ...``                 ``'--vf=pp=[...]'``
-    ``-pphelp``                 ``--vf=pp:help``
-    ``-rawaudio ...``           ``--demuxer-rawaudio-...``
-    ``-rawvideo ...``           ``--demuxer-rawvideo-...``
-    ``-spugauss``               ``--sub-gauss``
-    ``-srate``                  ``--audio-samplerate``
-    ``-ss``                     ``--start``
-    ``-ssf <sub>``              ``--sws-...``
-    ``-stop-xscreensaver``      ``--stop-screensaver``
-    ``-sub-fuzziness``          ``--sub-auto``
-    ``-sub``                    ``--sub-file``
-    ``-subcp``                  ``--sub-codepage``
-    ``-subdelay``               ``--sub-delay``
-    ``-subfile``                ``--sub-file``
-    ``-subfont-*``              ``--sub-text-*``, ``--osd-*``
-    ``-subfont-text-scale``     ``--sub-scale``
-    ``-subfont``                ``--sub-text-font``
-    ``-subfps``                 ``--sub-fps``
-    ``-subpos``                 ``--sub-pos``
-    ``-sws``                    ``--sws-scaler``
-    ``-tvscan``                 ``--tv-scan``
-    ``-use-filename-title``     ``--title='${filename}'``
-    ``-vc ffh264vdpau`` (etc.)  ``--hwdec=vdpau``
-    ``-vobsub``                 ``--sub-file`` (pass the .idx file)
-    ``-x W``, ``-y H``          ``--geometry=WxH`` + ``--no-keepaspect``
-    ``-xineramascreen``         ``--screen`` (different values)
-    ``-xy W``                   ``--autofit=W``
-    ``-zoom``                   Inverse available as ``--video-unscaled``
-    ``dvdnav://``               ``dvdnav://menu``
-    ``dvd://1``                 ``dvd://0`` (0-based offset)
-    =========================== ========================================
-
-.. note::
-
-    ``-opt val`` becomes ``--opt=val``.
-
-.. note::
-
-    Quite some video filters, video outputs, audio filters, audio outputs, had
-    changes in their option parsing. These aren't mentioned in the table above.
-
-    Also, some video and audio filters have been removed, and you have to use
-    libavfilter (using ``--vf=lavfi=[...]`` or ``--af=lavfi=[...]``) to get
-    them back.
-
-input.conf and Slave Commands
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-* Table of renamed input commands:
-
-    This lists only commands that are not always gracefully handled by the
-    internal legacy translation layer. If an input.conf contains any legacy
-    commands, a warning will be printed when starting the player. The warnings
-    also show the replacement commands.
-
-    Properties containing ``_`` to separate words use ``-`` instead.
-
-    +--------------------------------+----------------------------------------+
-    | Old                            | New                                    |
-    +================================+========================================+
-    | ``pt_step 1 [0|1]``            | ``playlist_next [weak|force]``         |
-    |                                | (translation layer cannot deal with    |
-    |                                | whitespace)                            |
-    +--------------------------------+----------------------------------------+
-    | ``pt_step -1 [0|1]``           | ``playlist_prev [weak|force] (same)``  |
-    +--------------------------------+----------------------------------------+
-    | ``switch_ratio [<ratio>]``     | ``set video-aspect <ratio>``           |
-    |                                |                                        |
-    |                                | ``set video-aspect 0`` (reset aspect)  |
-    +--------------------------------+----------------------------------------+
-    | ``step_property_osd <prop>``   | ``cycle <prop> <step>`` (wraps),       |
-    | ``<step> <dir>``               | ``add <prop> <step>`` (clamps).        |
-    |                                | ``<dir>`` parameter unsupported. Use   |
-    |                                | a negative ``<step>`` instead.         |
-    +--------------------------------+----------------------------------------+
-    | ``step_property <prop>``       | Prefix ``cycle`` or ``add`` with       |
-    | ``<step> <dir>``               | ``no-osd``: ``no-osd cycle <prop>``    |
-    |                                | ``<step>``                             |
-    +--------------------------------+----------------------------------------+
-    | ``osd_show_property_text``     | ``show_text <text>``                   |
-    | ``<text>``                     | The property expansion format string   |
-    |                                | syntax slightly changed.               |
-    +--------------------------------+----------------------------------------+
-    | ``osd_show_text``              | Now does the same as                   |
-    |                                | ``osd_show_property_text``. Use the    |
-    |                                | ``raw`` prefix to disable property     |
-    |                                | expansion.                             |
-    +--------------------------------+----------------------------------------+
-    | ``show_tracks``                | ``show_text ${track-list}``            |
-    +--------------------------------+----------------------------------------+
-    | ``show_chapters``              | ``show_text ${chapter-list}``          |
-    +--------------------------------+----------------------------------------+
-    | ``af_switch``, ``af_add``, ... | ``af set|add|...``                     |
-    +--------------------------------+----------------------------------------+
-    | ``tv_start_scan``              | ``set tv-scan yes``                    |
-    +--------------------------------+----------------------------------------+
-    | ``tv_set_channel <val>``       | ``set tv-channel <val>``               |
-    +--------------------------------+----------------------------------------+
-    | ``tv_step_channel``            | ``cycle tv-channel``                   |
-    +--------------------------------+----------------------------------------+
-    | ``dvb_set_channel <v1> <v2>``  | ``set dvb-channel <v1>-<v2>``          |
-    +--------------------------------+----------------------------------------+
-    | ``dvb_step_channel``           | ``cycle dvb-channel``                  |
-    +--------------------------------+----------------------------------------+
-    | ``tv_set_freq <val>``          | ``set tv-freq <val>``                  |
-    +--------------------------------+----------------------------------------+
-    | ``tv_step_freq``               | ``cycle tv-freq``                      |
-    +--------------------------------+----------------------------------------+
-    | ``tv_set_norm <norm>``         | ``set tv-norm <norm>``                 |
-    +--------------------------------+----------------------------------------+
-    | ``tv_step_norm``               | ``cycle tv-norm``                      |
-    +--------------------------------+----------------------------------------+
-
-    .. note::
-
-        Due to lack of hardware and users using the TV/DVB/PVR features, and
-        due to the need to cleanup the related command code, it's possible
-        that the new commands are buggy or behave worse. This can be improved
-        if testers are available. Otherwise, some of the TV code will be
-        removed at some point.
-
-Slave mode
-~~~~~~~~~~
-
-* Slave mode was removed. A proper slave mode application needed tons of code
-  and hacks to get
-  it right. The main problem is that slave mode is a bad and incomplete
-  interface, and to get around that, applications parsed output messages
-  intended for users. It is hard to know which messages exactly are parsed by
-  slave mode applications. This makes it virtually impossible to improve
-  terminal output intended for users without possibly breaking something.
-
-  This is absolutely insane, and since initial improvements to **mpv** quickly
-  made slave mode incompatible to most applications, it was removed as useless
-  cruft. The client API (see below) is provided instead.
-
-  ``--identify`` was replaced by the ``TOOLS/mpv_identify.sh`` wrapper script.
-
-* For some time (until including release 0.4.x), mpv supported a
-  ``--slave-broken`` option. The following options are equivalent:
-
-  ::
-
-        --input-file=/dev/stdin --input-terminal=no
-
-
-  Assuming the system supports ``/dev/stdin``.
-
-  (The option was readded in 0.5.1 and sets exactly these options.)
-
-* A JSON RPC protocol giving access to the client API is planned, but nothing
-  has emerged yet.
-
-* **mpv** also provides a client API, which can be used to embed the player
-  by loading it as shared library. (See ``libmpv/client.h`` in the sources.)
-  It might also be possible to implement a custom slave mode-like protocol
-  using Lua scripting.
-
-Policy for Removed Features
----------------------------
-
-**mpv** is in active development. If something is in the way of more important
-development (such as fixing bugs or implementing new features), we sometimes
-remove features. Usually this happens only with old features that either seem
-to be useless, or are not used by anyone. Often these are obscure, or
-"inherited", or were marked experimental, but never received any particular
-praise by any users.
-
-Sometimes, features are replaced by something new. The new code will be either
-simpler or more powerful, but doesn't necessarily provide everything the old
-feature did.
-
-We can not exclude that we accidentally remove features that are actually
-popular. Generally, we do not know how much a specific functionality is used.
-If you miss a feature and think it should be re-added, please open an issue
-on the mpv bug tracker. Hopefully, a solution can be found. Often, it turns
-out that re-adding something is not much of a problem, or that there are
-better alternatives.
-
-Why this Fork?
---------------
-
-mplayer2 is practically dead, and mpv started out as a branch containing
-new/experimental development. (Some of it was merged right *after* the fork
-was made public, seemingly as an acknowledgment that development, or at
-least merging, should have been more active.)
-
-MPlayer is focused on not breaking anything, but is stuck with a horrible
-codebase resistant to cleanup. (Unless you do what mpv did - merciless and
-consequent pruning of bad, old code.) Cleanup and keeping broken things
-conflict, so the kind of development mpv strives for can't be done within
-MPlayer due to clashing development policies.
-
-Additionally, mplayer2 already had lots of changes over MPlayer, which would
-have needed to be backported to the MPlayer codebase. This would not only
-have been hard (several years of diverging development), but also would have
-been impossible due to the aforementioned MPlayer development policy.
+  https://github.com/mpv-player/mpv/releases
+* The git log, which is the "real" changelog
+* The file ``mplayer-changes.rst`` in the ``DOCS`` sub directory on the git
+  repository, which used to be in place of this section. It documents some
+  changes that happened since mplayer2 forked off MPlayer.

DOCS/man/input.rst

@@ -1,5 +1,13 @@
-INPUT.CONF
-==========
+COMMAND INTERFACE
+=================
+
+The mpv core can be controlled with commands and properties. A number of ways
+to interact with the player use them: key bindings (``input.conf``), OSD
+(showing information with properties), JSON IPC, the client API (``libmpv``),
+and the classic slave mode.
+
+input.conf
+----------
 
 The input.conf file consists of a list of key bindings, for example::
 
@@ -11,8 +19,9 @@ value (upper case if combined with ``Shift``), or a name for special keys. For
 example, ``a`` maps to the ``a`` key without shift, and ``A`` maps to ``a``
 with shift.
 
-The file is normally located in ``~/.config/mpv/input.conf`` (some platforms
-may use different paths). The default bindings are defined here::
+The file is located in the mpv configuration directory (normally at
+``~/.config/mpv/input.conf`` depending on platform). The default bindings are
+defined here::
 
     https://github.com/mpv-player/mpv/blob/master/etc/input.conf
 
@@ -100,11 +109,20 @@ List of Input Commands
     keyframes
         Always restart playback at keyframe boundaries (fast).
 
-``revert_seek``
+``revert_seek [mode]``
     Undoes the ``seek`` command, and some other commands that seek (but not
     necessarily all of them). Calling this command once will jump to the
     playback position before the seek. Calling it a second time undoes the
-    ``revert_seek`` command itself.
+    ``revert_seek`` command itself. This only works within a single file.
+
+    The first argument is optional, and can change the behavior:
+
+    mark
+        Mark the current time position. The next normal ``revert_seek`` command
+        will seek back to this point, no matter how many seeks happened since
+        last time.
+
+    Using it without any arguments gives you the default behavior.
 
 ``frame_step``
     Play one frame, then pause. Does nothing with audio-only playback.
@@ -159,7 +177,9 @@ List of Input Commands
         Take a single screenshot.
     <each-frame>
         Take a screenshot each frame. Issue this command again to stop taking
-        screenshots.
+        screenshots. Note that you should disable frame-dropping when using
+        this mode - or you might receive duplicate images in cases when a
+        frame was dropped.
 
 ``screenshot_to_file "<filename>" [subtitles|video|window]``
     Take a screenshot and save it to a given file. The format of the file will
@@ -190,7 +210,7 @@ List of Input Commands
     force
         Terminate playback if the first file is being played.
 
-``loadfile "<file>" [replace|append [options]]``
+``loadfile "<file>" [replace|append|append-play [options]]``
     Load the given file and play it.
 
     Second argument:
@@ -201,6 +221,8 @@ List of Input Commands
         Append the file to the playlist.
     <append-play>
         Append the file, and if nothing is currently playing, start playback.
+        (Always starts with the added file, even if the playlist was not empty
+        before running this command.)
 
     The third argument is a list of options and values which should be set
     while the file is playing. It is of the form ``opt1=value1,opt2=value2,..``.
@@ -227,7 +249,6 @@ List of Input Commands
     will have after moving.)
 
 ``run "command" "arg1" "arg2" ...``
-    (Unix only)
     Run the given command. Unlike in MPlayer/mplayer2 and earlier versions of
     mpv (0.2.x and older), this doesn't call the shell. Instead, the command
     is run directly, with each argument passed separately. Each argument is
@@ -257,16 +278,39 @@ List of Input Commands
     will seek to the previous position on start. The (optional) argument is
     exactly as in the ``quit`` command.
 
-``sub_add "<file>"``
-    Load the given subtitle file. It is not selected as current subtitle after
+``sub_add "<file>" [<flags> [<title> [<lang>]]]``
+    Load the given subtitle file. It is selected as current subtitle after
     loading.
 
+    The ``flags`` args is one of the following values:
+
+    <select>
+
+        Select the subtitle immediately.
+
+    <auto>
+
+        Don't select the subtitle. (Or in some special situations, let the
+        default stream selection mechanism decide.)
+
+    <cached>
+
+        Select the subtitle. If a subtitle with the same filename was already
+        added, that one is selected, instead of loading a duplicate entry.
+        (In this case, title/language are ignored, and if the was changed since
+        it was loaded, these changes won't be reflected.)
+
+    The ``title`` argument sets the track title in the UI.
+
+    The ``lang`` argument sets the track language, and can also influence
+    stream selection with ``flags`` set to ``auto``.
+
 ``sub_remove [<id>]``
     Remove the given subtitle track. If the ``id`` argument is missing, remove
     the current track. (Works on external subtitle files only.)
 
 ``sub_reload [<id>]``
-    Reload the given subtitle tracks. If the ``id`` argument is missing, remove
+    Reload the given subtitle tracks. If the ``id`` argument is missing, reload
     the current track. (Works on external subtitle files only.)
 
     This works by unloading and re-adding the subtitle track.
@@ -325,6 +369,38 @@ List of Input Commands
     Write the resume config file that the ``quit_watch_later`` command writes,
     but continue playback normally.
 
+``stop``
+    Stop playback and clear playlist. With default settings, this is
+    essentially like ``quit``. Useful for the client API: playback can be
+    stopped without terminating the player.
+
+``mouse <x> <y> [<button> [single|double]]``
+    Send a mouse event with given coordinate (``<x>``, ``<y>``).
+
+    Second argument:
+
+    <button>
+        The button number of clicked mouse button. This should be one of 0-19.
+        If ``<button>`` is omitted, only the position will be updated.
+
+    Third argument:
+
+    <single> (default)
+        The mouse event represents regular single click.
+
+    <double>
+        The mouse event represents double-click.
+
+``audio_add "<file>" [<flags> [<title> [<lang>]]]``
+    Load the given audio file. See ``sub_add`` command.
+
+``audio_remove [<id>]``
+    Remove the given audio track. See ``sub_remove`` command.
+
+``audio_reload [<id>]``
+    Reload the given audio tracks. See ``sub_reload`` command.
+
+
 Input Commands that are Possibly Subject to Change
 --------------------------------------------------
 
@@ -394,7 +470,7 @@ Input Commands that are Possibly Subject to Change
     The special argument ``!reverse`` can be used to cycle the value list in
     reverse. Compared with a command that just lists the value in reverse, this
     command will actually share the internal counter with the forward-cycling
-    key binding.
+    key binding (as long as the rest of the arguments are the same).
 
     Note that there is a static limit of (as of this writing) 10 arguments
     (this limit could be raised on demand).
@@ -448,10 +524,17 @@ Input Commands that are Possibly Subject to Change
     random points. Instead, call ``overlay_add`` again (preferably with a
     different memory region to prevent tearing).
 
-    ``offset`` is the offset of the first pixel in the source file. It is
-    passed directly to ``mmap`` and is subject to certain restrictions
-    (see ``man mmap`` for details). In particular, this value has to be a
-    multiple of the system's page size.
+    It is also possible to pass a raw memory address for use as bitmap memory
+    by passing a memory address as integer prefixed with a ``&`` character.
+    Passing the wrong thing here will crash the player. This mode might be
+    useful for use with libmpv. The ``offset`` parameter is simply added to the
+    memory address (since mpv 0.8.0, ignored before).
+
+    ``offset`` is the byte offset of the first pixel in the source file.
+    (The current implementation always mmap's the whole file from position 0 to
+    the end of the image, so large offsets should be avoided. Before mpv 0.8.0,
+    the offset was actually passed directly to ``mmap``, but it was changed to
+    make using it easier.)
 
     ``fmt`` is a string identifying the image format. Currently, only ``bgra``
     is defined. This format has 4 bytes per pixels, with 8 bits per component.
@@ -497,12 +580,106 @@ Input Commands that are Possibly Subject to Change
     ``<target>``. Each client (scripts etc.) has a unique name. For example,
     Lua scripts can get their name via ``mp.get_script_name()``.
 
-    (Scripts use this internally to dispatch key bindings, and this can also
-    be used in input.conf to reassign such bindings.)
+``script_binding "<name>"``
+    Invoke a script-provided key binding. This can be used to remap key
+    bindings provided by external Lua scripts.
 
+    The argument is the name of the binding.
 
-Undocumented commands: ``tv_last_channel`` (TV/DVB only), ``stop`` (questionable
-use), ``get_property`` (?), ``vo_cmdline`` (experimental).
+    It can optionally be prefixed with the name of the script, using ``/`` as
+    separator, e.g. ``script_binding scriptname/bindingname``.
+
+    For completeness, here is how this command works internally. The details
+    could change any time. On any matching key event, ``script_message_to``
+    or ``script_message`` is called (depending on whether the script name is
+    included), where the first argument is the string ``key-binding``, the
+    second argument is the name of the binding, and the third argument is the
+    key state as string. The key state consists of a number of letters. The
+    first letter is one of ``d`` (key was pressed down), ``u`` (was released),
+    ``r`` (key is still down, and was repeated; only if key repeat is enabled
+    for this binding), ``p`` (key was pressed; happens if up/down can't be
+    tracked). The second letter whether the event originates from the mouse,
+    either ``m`` (mouse button) or ``-`` (something else).
+
+``ab_loop``
+    Cycle through A-B loop states. The first command will set the ``A`` point
+    (the ``ab-loop-a`` property); the second the ``B`` point, and the third
+    will clear both points.
+
+``vo_cmdline "<args>"``
+    Reset the sub-option of the current VO. Currently works with ``opengl``
+    (including ``opengl-hq``). The argument is the sub-option string usually
+    passed to the VO on the command line. Not all sub-options can be set, but
+    those which can will be reset even if they don't appear in the argument.
+    This command might be changed or removed in the future.
+
+``drop_buffers``
+    Drop audio/video/demuxer buffers, and restart from fresh. Might help with
+    unseekable streams that are going out of sync.
+    This command might be changed or removed in the future.
+
+Undocumented commands: ``tv_last_channel`` (TV/DVB only),
+``get_property`` (deprecated), ``ao_reload`` (experimental/internal).
+
+Hooks
+~~~~~
+
+Hooks are synchronous events between player core and a script or similar. This
+applies to the Lua scripting interface and the client API and only. Normally,
+events are supposed to be asynchronous, and the hook API provides an awkward
+and obscure way to handle events that require stricter coordination. There are
+no API stability guarantees made. Not following the protocol exactly can make
+the player freeze randomly. Basically, nobody should use this API.
+
+There are two special commands involved. Also, the client must listen for
+client messages (``MPV_EVENT_CLIENT_MESSAGE`` in the C API).
+
+``hook_add <hook-name> <id> <priority>``
+    Subscribe to the hook identified by the first argument (basically, the
+    name of event). The ``id`` argument is an arbitrary integer chosen by the
+    user. ``priority`` is used to sort all hook handlers globally across all
+    clients. Each client can register multiple hook handlers (even for the
+    same hook-name). Once the hook is registered, it cannot be unregistered.
+
+    When a specific event happens, all registered handlers are run serially.
+    This uses a protocol every client has to follow explicitly. When a hook
+    handler is run, a client message (``MPV_EVENT_CLIENT_MESSAGE``) is sent to
+    the client which registered the hook. This message has the following
+    arguments:
+
+    1. the string ``hook_run``
+    2. the ``id`` argument the hook was registered with as string (this can be
+       used to correctly handle multiple hooks registered by the same client,
+       as long as the ``id`` argument is unique in the client)
+    3. something undefined, used by the hook mechanism to track hook execution
+       (currently, it's the hook-name, but this might change without warning)
+
+    Upon receiving this message, the client can handle the event. While doing
+    this, the player core will still react to requests, but playback will
+    typically be stopped.
+
+    When the client is done, it must continue the core's hook execution by
+    running the ``hook_ack`` command.
+
+``hook_ack <string>``
+    Run the next hook in the global chain of hooks. The argument is the 3rd
+    argument of the client message that starts hook execution for the
+    current client.
+
+The following hooks are currently defined:
+
+``on_load``
+    Called when a file is to be opened, before anything is actually done.
+    For example, you could read and write the ``stream-open-filename``
+    property to redirect an URL to something else (consider support for
+    streaming sites which rarely give the user a direct media URL), or
+    you could set per-file options with by setting the property
+    ``file-local-options/<option name>``. The player will wait until all
+    hooks are run.
+
+``on_unload``
+    Run before closing a file, and before actually uninitializing
+    everything. It's not possible to resume playback in this state.
 
 Input Command Prefixes
 ----------------------
@@ -527,7 +704,9 @@ prefixes can be specified. They are separated by whitespace.
     Do not expand properties in string arguments. (Like ``"${property-name}"``.)
 ``expand-properties`` (default)
     All string arguments are expanded as described in `Property Expansion`_.
-
+``repeatable``
+    For some commands, keeping a key pressed doesn't run the command repeatedly.
+    This prefix forces enabling key repeat in any case.
 
 All of the osd prefixes are still overridden by the global ``--osd-level``
 settings.
@@ -594,19 +773,33 @@ Property list
     ``${stream-end}``. For ordered chapters and such, the
     size of the currently played segment is returned.)
 
+``estimated-frame-count``
+    Total number of frames in current file.
+
+    .. note:: This is only an estimate. (It's computed from two unreliable
+              quantities: fps and stream length.)
+
+``estimated-frame-number``
+    Number of current frame in current stream.
+
+    .. note:: This is only an estimate. (It's computed from two unreliable
+              quantities: fps and possibly rounded timestamps.)
+
 ``path``
     Full path of the currently played file.
 
 ``media-title``
-    If libquvi is used and libquvi returns a page title for the currently
-    played URL, return the page title.
-
-    Otherwise, if the currently played file has a ``title`` tag, use that.
+    If the currently played file has a ``title`` tag, use that.
 
     Otherwise, if the media type is DVD, return the volume ID of DVD.
 
     Otherwise, return the ``filename`` property.
 
+``file-format``
+    Symbolic name of the file format. In some cases, this is a comma-separated
+    list of format names, e.g. mp4 is ``mov,mp4,m4a,3gp,3g2,mj2`` (the list
+    may grow in the future for any format).
+
 ``demuxer``
     Name of the current demuxer. (This is useless.)
 
@@ -635,8 +828,13 @@ Property list
     disabled.
 
 ``drop-frame-count``
-    Frames dropped because they arrived to late. Unavailable if video
-    is disabled
+    Video frames dropped by decoder, because video is too far behind audio (when
+    using ``--framedrop=decoder``). Sometimes, this may be incremented in other
+    situations, e.g. when video packets are damaged, or the decoder doesn't
+    follow the usual rules. Unavailable if video is disabled.
+
+``vo-drop-frame-count``
+    Frames dropped by VO (when using ``--framedrop=vo``).
 
 ``percent-pos`` (RW)
     Position in current file (0-100). The advantage over using this instead of
@@ -644,9 +842,6 @@ Property list
     estimating the playback position from the byte position, if the file
     duration is not known.
 
-``ratio-pos`` (RW)
-    Position in current file (0.0-1.0). higher precision that ``percent-pos``.
-
 ``time-pos`` (RW)
     Position in current file in seconds.
 
@@ -674,6 +869,33 @@ Property list
 ``disc-titles``
     Number of BD/DVD titles.
 
+    This has a number of sub-properties. Replace ``N`` with the 0-based edition
+    index.
+
+    ``disc-titles/count``
+        Number of titles.
+
+    ``disc-titles/id``
+        Title ID as integer. Currently, this is the same as the title index.
+
+    ``disc-titles/length``
+        Length in seconds. Can be unavailable in a number of cases (currently
+        it works for libdvdnav only).
+
+    When querying the property with the client API using ``MPV_FORMAT_NODE``,
+    or with Lua ``mp.get_property_native``, this will return a mpv_node with
+    the following contents:
+
+    ::
+
+        MPV_FORMAT_NODE_ARRAY
+            MPV_FORMAT_NODE_MAP (for each edition)
+                "id"                MPV_FORMAT_INT64
+                "length"            MPV_FORMAT_DOUBLE
+
+``disc-title-list``
+    List of BD/DVD titles.
+
 ``disc-title`` (RW)
     Current BD/DVD title number. Writing works only for ``dvdnav://`` and
     ``bd://`` (and aliases for these).
@@ -723,6 +945,10 @@ Property list
                 "title"             MPV_FORMAT_STRING
                 "default"           MPV_FORMAT_FLAG
 
+``ab-loop-a``, ``ab-loop-b`` (RW)
+    Set/get A-B loop points. See corresponding options and ``ab_loop`` command.
+    The special value ``no`` on either of these properties disables looping.
+
 ``angle`` (RW)
     Current DVD angle.
 
@@ -767,6 +993,10 @@ Property list
         MPV_FORMAT_NODE_MAP
             (key and string value for each metadata entry)
 
+``filtered-metadata``
+    Like ``metadata``, but includes only fields listed in the ``--display-tags``
+    option. This is the same set of tags that is printed to the terminal.
+
 ``chapter-metadata``
     Metadata of current chapter. Works similar to ``metadata`` property. It
     also allows the same access methods (using sub-properties).
@@ -791,11 +1021,19 @@ Property list
 ``pause`` (RW)
     Pause status. This is usually ``yes`` or ``no``. See ``--pause``.
 
+``idle``
+    Return ``yes`` if no file is loaded, but the player is staying around
+    because of the ``--idle`` option.
+
 ``core-idle``
     Return ``yes`` if the playback core is paused, otherwise ``no``. This can
     be different ``pause`` in special situations, such as when the player
     pauses itself due to low network cache.
 
+    This also returns ``yes`` if playback is restarting or if nothing is
+    playing at all. In other words, it's only ``no`` if there's actually
+    video playing. (Behavior since mpv 0.7.0.)
+
 ``cache``
     Network cache fill state (0-100.0).
 
@@ -821,9 +1059,22 @@ Property list
     Returns ``yes`` if the cache is idle, which means the cache is filled as
     much as possible, and is currently not reading more data.
 
+``demuxer-cache-duration``
+    Approximate duration of video buffered in the demuxer, in seconds. The
+    guess is very unreliable, and often the property will not be available
+    at all, even if data is buffered.
+
+``demuxer-cache-idle``
+    Returns ``yes`` if the demuxer is idle, which means the demuxer cache is
+    filled to the requested amount, and is currently not reading more data.
+
 ``paused-for-cache``
     Returns ``yes`` when playback is paused because of waiting for the cache.
 
+``cache-buffering-state``
+    Return the percentage (0-100) of the cache fill status until the player
+    will unpause (related to ``paused-for-cache``).
+
 ``eof-reached``
     Returns ``yes`` if end of playback was reached, ``no`` otherwise. Note
     that this is usually interesting only if ``--keep-open`` is enabled,
@@ -885,6 +1136,9 @@ Property list
 ``deinterlace`` (RW)
     See ``--deinterlace``.
 
+``field-dominance`` (RW)
+    See ``--field-dominance``
+
 ``colormatrix`` (RW)
     See ``--colormatrix``.
 
@@ -903,6 +1157,9 @@ Property list
 ``border`` (RW)
     See ``--border``.
 
+``on-all-workspaces`` (RW)
+    See ``--on-all-workspaces``. Unsetting may not work on all WMs.
+
 ``framedrop`` (RW)
     See ``--framedrop``.
 
@@ -931,6 +1188,17 @@ Property list
     Note that you don't know the success of the operation immediately after
     writing this property. It happens with a delay as video is reinitialized.
 
+``detected-hwdec``
+    Return the current hardware decoder that was detected and opened. Returns
+    the same values as ``hwdec``.
+
+    This is known only once the VO has opened (and possibly later). With some
+    VOs (like ``opengl``), this is never known in advance, but only when the
+    decoder attempted to create the hw decoder successfully. Also, hw decoders
+    with ``-copy`` suffix are returned only while hw decoding is active (and
+    unset afterwards). All this reflects how detecting hw decoders are
+    detected and used internally in mpv.
+
 ``panscan`` (RW)
     See ``--panscan``.
 
@@ -956,6 +1224,16 @@ Property list
         The pixel format as string. This uses the same names as used in other
         places of mpv.
 
+    ``video-params/average-bpp``
+        Average bits-per-pixel as integer. Subsampled planar formats use a
+        different resolution, which is the reason this value can sometimes be
+        odd or confusing. Can be unavailable with some formats.
+
+    ``video-params/plane-depth``
+        Bit depth for each color component as integer. This is only exposed
+        for planar or single-component formats, and is unavailable for other
+        formats.
+
     ``video-params/w``, ``video-params/h``
         Video size as integers, with no aspect correction applied.
 
@@ -1007,13 +1285,17 @@ Property list
 ``dwidth``, ``dheight``
     Video display size. This is the video size after filters and aspect scaling
     have been applied. The actual video window size can still be different
-    from this.
+    from this, e.g. if the user resized the video window manually.
+
+    These have the same values as ``video-out-params/dw`` and
+    ``video-out-params/dh``.
 
 ``video-out-params``
     Same as ``video-params``, but after video filters have been applied. If
     there are no video filters in use, this will contain the same values as
     ``video-params``. Note that this is still not necessarily what the video
-    window uses, since all real VOs do their own scaling.
+    window uses, since the user can change the window size, and all real VOs
+    do their own scaling independently from the filter chain.
 
     Has the same sub-properties as ``video-params``.
 
@@ -1033,9 +1315,16 @@ Property list
     Window size multiplier. Setting this will resize the video window to the
     values contained in ``dwidth`` and ``dheight`` multiplied with the value
     set with this property. Setting ``1`` will resize to original video size
-    (or to be exactly, the size the video filters output). ``2`` will set the
+    (or to be exact, the size the video filters output). ``2`` will set the
     double size, ``0.5`` halves the size.
 
+``window-minimized``
+    Return whether the video window is minimized or not.
+
+``display-names``
+    Names of the displays that the mpv window covers. On X11, these
+    are the xrandr names (LVDS1, HDMI1, DP1, VGA1, etc.).
+
 ``video-aspect`` (RW)
     Video aspect, see ``--video-aspect``.
 
@@ -1102,8 +1391,8 @@ Property list
     See ``--ass-style-override``.
 
 ``stream-capture`` (RW)
-    A filename, see ``--capture``. Setting this will start capture using the
-    given filename. Setting it to an empty string will stop it.
+    A filename, see ``--stream-capture``. Setting this will start capture using
+    the given filename. Setting it to an empty string will stop it.
 
 ``tv-brightness``, ``tv-contrast``, ``tv-saturation``, ``tv-hue`` (RW)
     TV stuff.
@@ -1128,6 +1417,13 @@ Property list
     ``playlist/N/filename``
         Filename of the Nth entry.
 
+    ``playlist/N/current``, ``playlist/N/playing``
+        ``yes`` if this entry is currently playing (or being loaded).
+        Unavailable or ``no`` otherwise. When changing files, ``current`` and
+        ``playing`` can be different, because the currently playing file hasn't
+        been unloaded yet; in this case, ``current`` refers to the new
+        selection. (Since mpv 0.7.0.)
+
     When querying the property with the client API using ``MPV_FORMAT_NODE``,
     or with Lua ``mp.get_property_native``, this will return a mpv_node with
     the following contents:
@@ -1137,6 +1433,8 @@ Property list
         MPV_FORMAT_NODE_ARRAY
             MPV_FORMAT_NODE_MAP (for each playlist entry)
                 "filename"  MPV_FORMAT_STRING
+                "current"   MPV_FORMAT_FLAG (might be missing; since mpv 0.7.0)
+                "playing"   MPV_FORMAT_FLAG (same)
 
 ``track-list``
     List of audio/video/sub tracks, current entry marked. Currently, the raw
@@ -1234,11 +1532,6 @@ Property list
                 "title" MPV_FORMAT_STRING
                 "time"  MPV_FORMAT_DOUBLE
 
-``quvi-format`` (RW)
-    See ``--quvi-format``. Cycling this property (``cycle``) will attempt to
-    cycle through known format, although currently this feature doesn't work
-    well at all.
-
 ``af`` (RW)
     See ``--af`` and the ``af`` command.
 
@@ -1261,15 +1554,173 @@ Property list
 
     It's also possible to write the property using this format.
 
+``video-rotate`` (RW)
+    See ``--video-rotate`` option.
+
 ``seekable``
     Return whether it's generally possible to seek in the current file.
 
+``partially-seekable``
+    Return ``yes`` if the current file is considered seekable, but only because
+    the cache is active. This means small relative seeks may be fine, but larger
+    seeks may fail anyway. Whether a seek will succeed or not is generally not
+    known in advance.
+
+    If this property returns true, ``seekable`` will also return true.
+
+``playback-abort``
+    Return whether playback is stopped or is to be stopped. (Useful in obscure
+    situations like during ``on_load`` hook processing, when the user can
+    stop playback, but the script has to explicitly end processing.)
+
+``cursor-autohide`` (RW)
+    See ``--cursor-autohide``. Setting this to a new value will always update
+    the cursor, and reset the internal timer.
+
+``osd-sym-cc``
+    Inserts the current OSD symbol as opaque OSD control code (cc). This makes
+    sense only with the ``show_text`` command or options which set OSD messages.
+    The control code is implementation specific and is useless for anything else.
+
+``osd-ass-cc``
+    ``${osd-ass-cc/0}`` disables escaping ASS sequences of text in OSD,
+    ``${osd-ass-cc/1}`` enables it again. By default, ASS sequences are
+    escaped to avoid accidental formatting, and this property can disable
+    this behavior. Note that the properties return an opaque OSD control
+    code, which only makes sense for the ``show_text`` command or options
+    which set OSD messages.
+
+    .. admonition:: Example
+
+        - ``--osd-status-msg='This is ${osd-ass-cc/0}{\\b1}bold text'``
+        - ``show_text "This is ${osd-ass-cc/0}{\b1}bold text"``
+
+    Any ASS override tags as understood by libass can be used.
+
+    Note that you need to escape the ``\`` character, because the string is
+    processed for C escape sequences before passing it to the OSD code.
+
+    A list of tags can be found here: http://docs.aegisub.org/latest/ASS_Tags/
+
+``vo-configured``
+    Return whether the VO is configured right now. Usually this corresponds to
+    whether the video window is visible. If the ``--force-window`` option is
+    used, this is usually always returns ``yes``.
+
+``packet-video-bitrate``, ``packet-audio-bitrate``, ``packet-sub-bitrate``
+    Bitrate values calculated on the packet level. This works by dividing the
+    bit size of all packets between two keyframes by their presentation
+    timestamp distance. (This uses the timestamps are stored in the file, so
+    e.g. playback speed does not influence the returned values.) In particular,
+    the video bitrate will update only per keyframe, and show the "past"
+    bitrate. To make the property more UI friendly, updates to these properties
+    are throttled in a certain way.
+
+    How exactly these values are calculated might change in the future.
+
+``audio-device-list``
+    Return the list of discovered audio devices. This is mostly for use with
+    the client API, and reflects what ``--audio-device=help`` with the command
+    line player returns.
+
+    When querying the property with the client API using ``MPV_FORMAT_NODE``,
+    or with Lua ``mp.get_property_native``, this will return a mpv_node with
+    the following contents:
+
+    ::
+
+        MPV_FORMAT_NODE_ARRAY
+            MPV_FORMAT_NODE_MAP (for each device entry)
+                "name"          MPV_FORMAT_STRING
+                "description"   MPV_FORMAT_STRING
+
+    The ``name`` is what is to be passed to the ``--audio-device`` option (and
+    often a rather cryptic audio API-specific ID), while ``description`` is
+    human readable free form text. The description is an empty string if none
+    was received.
+
+``audio-device`` (RW)
+    Set the audio device. This directly reads/writes the ``--audio-device``
+    option, but on write accesses, the audio output will be scheduled for
+    reloading.
+
+    Writing this property while no audio output is active will not automatically
+    enable audio. (This is also true in the case when audio was disabled due to
+    reinitialization failure after a previous write access to ``audio-device``.)
+
+    This property also doesn't tell you which audio device is actually in use.
+
+    How these details are handled may change in the future.
+
+``current-vo``
+    Current video output driver (name as used with ``--vo``).
+
+``current-ao``
+    Current audio output driver (name as used with ``--ao``).
+
+``audio-out-detected-device``
+    Return the audio device selected by the AO driver (only implemented for
+    some drivers: currently only ``coreaudio``).
+
+``mpv-version``
+    Return the mpv version/copyright string. Depending on how the binary was
+    built, it might contain either a release version, or just a git hash.
+
+``mpv-configuration``
+    Return the configuration arguments which were passed to the build system
+    (typically the way ``./waf configure ...`` was invoked).
+
 ``options/<name>`` (RW)
     Read-only access to value of option ``--<name>``. Most options can be
     changed at runtime by writing to this property. Note that many options
     require reloading the file for changes to take effect. If there is an
     equivalent property, prefer setting the property instead.
 
+``file-local-options/<name>``
+    Similar to ``options/<name>``, but when setting an option through this
+    property, the option is reset to its old value once the current file has
+    stopped playing. Trying to write an option while no file is playing (or
+    is being loaded) results in an error.
+
+    (Note that if an option is marked as file-local, even ``options/`` will
+    access the local value, and the ``old`` value, which will be restored on
+    end of playback, can not be read or written until end of playback.)
+
+``option-info/<name>``
+    Additional per-option information.
+
+    This has a number of sub-properties. Replace ``<name>`` with the name of
+    a top-level option. No guarantee of stability is given to any of these
+    sub-properties - they may change radically in the feature.
+
+    ``option-info/<name>/name``
+        Returns the name of the option.
+
+    ``option-info/<name>/type``
+        Return the name of the option type, like ``String`` or ``Integer``.
+        For many complex types, this isn't very accurate.
+
+    ``option-info/<name>/set-from-commandline``
+
+        Return ``yes`` if the option was set from the mpv command line,
+        ``no`` otherwise. What this is set to if the option is e.g. changed
+        at runtime is left undefined (meaning it could change in the future).
+
+    ``option-info/<name>/default-value``
+        The default value of the option. May not always be available.
+
+    ``option-info/<name>/min``, ``option-info/<name>/max``
+        Integer minimum and maximum values allowed for the option. Only
+        available if the options are numeric, and the minimum/maximum has been
+        set internally. It's also possible that only one of these is set.
+
+    ``option-info/<name>/choices``
+        If the option is a choice option, the possible choices. Choices that
+        are integers may or may not be included (they can be implied by ``min``
+        and ``max``). Note that options which behave like choice options, but
+        are not actual choice options internally, may not have this info
+        available.
+
 ``property-list``
     Return the list of top-level properties.
 

DOCS/man/ipc.rst

@@ -0,0 +1,222 @@
+JSON IPC
+========
+
+mpv can be controlled by external programs using the JSON-based IPC protocol. It
+can be enabled by specifying the path to a unix socket using the option
+``--input-unix-socket``. Clients can connect to this socket and send commands to
+the player or receive events from it.
+
+.. warning::
+
+    This is not intended to be a secure network protocol. It is explicitly
+    insecure: there is no authentication, no encryption, and the commands
+    themselves are insecure too. For example, the ``run`` command is exposed,
+    which can run arbitrary system commands. The use-case is controlling the
+    player locally. This is not different from the MPlayer slave protocol.
+
+Socat example
+-------------
+
+You can use the ``socat`` tool to send commands (and receive reply) from the
+shell. Assuming mpv was started with:
+
+::
+
+    mpv file.mkv --input-unix-socket=/tmp/mpvsocket
+
+Then you can control it using socat:
+
+::
+
+    > echo '{ "command": ["get_property", "playback-time"] }' | socat - /tmp/mpvsocket
+    {"data":190.482000,"error":"success"}
+
+In this case, socat copies data between stdin/stdout and the mpv socket
+connection.
+
+See the ``--idle`` option how to make mpv start without exiting immediately or
+playing a file.
+
+It's also possible to send input.conf style text-only commands:
+
+::
+
+    > echo 'show_text ${playback-time}' | socat - /tmp/mpvsocket
+
+But you won't get a reply over the socket. (This particular command shows the
+playback time on the player's OSD.)
+
+Protocol
+--------
+
+Clients can execute commands on the player by sending JSON messages of the
+following form:
+
+::
+
+    { "command": ["command_name", "param1", "param2", ...] }
+
+where ``command_name`` is the name of the command to be executed, followed by a
+list of parameters. Parameters must be formatted as native JSON values
+(integers, strings, booleans, ...). Every message **must** be terminated with
+``\n``. Additionally, ``\n`` must not appear anywhere inside the message. In
+practice this means that messages should be minified before being sent to mpv.
+
+mpv will then send back a reply indicating whether the command was run
+correctly, and an additional field holding the command-specific return data (it
+can also be null).
+
+::
+
+    { "error": "success", "data": null }
+
+mpv will also send events to clients with JSON messages of the following form:
+
+::
+
+    { "event": "event_name" }
+
+where ``event_name`` is the name of the event. Additional event-specific fields
+can also be present. See `List of events`_ for a list of all supported events.
+
+If the first character (after skipping whitespace) is not ``{``, the command
+will be interpreted as non-JSON text command, as they are used in input.conf
+(or ``mpv_command_string()`` in the client API). Additionally, line starting
+with ``#`` and empty lines are ignored.
+
+Currently, embedded 0 bytes terminate the current line, but you should not
+rely on this.
+
+Commands
+--------
+
+Additionally to  the commands described in `List of Input Commands`_, a few
+extra commands can also be used as part of the protocol:
+
+``client_name``
+    Return the name of the client as string. This is the string ``ipc-N`` with
+    N being an integer number.
+
+``get_time_us``
+    Return the current mpv internal time in microseconds as a number. This is
+    basically the system time, with an arbitrary offset.
+
+``get_property``
+    Return the value of the given property. The value will be sent in the data
+    field of the replay message.
+
+    Example:
+
+    ::
+
+        { "command": ["get_property", "volume"] }
+        { "data": 50.0, "error": "success" }
+
+``get_property_string``
+    Like ``get_property``, but the resulting data will always be a string.
+
+    Example:
+
+    ::
+
+        { "command": ["get_property_string", "volume"] }
+        { "data": "50.000000", "error": "success" }
+
+``set_property``
+    Set the given property to the given value. See `Properties`_ for more
+    information about properties.
+
+    Example:
+
+    ::
+
+        { "command": ["set_property", "pause", true] }
+        { "error": "success" }
+
+``set_property_string``
+    Like ``set_property``, but the argument value must be passed as string.
+
+    Example:
+
+    ::
+
+        { "command": ["set_property_string", "pause", "yes"] }
+        { "error": "success" }
+
+``observe_property``
+    Watch a property for changes. If the given property is changed, then an
+    event of type ``property-change`` will be generated
+
+    Example:
+
+    ::
+
+        { "command": ["observe_property", 1, "volume"] }
+        { "error": "success" }
+        { "event": "property-change", "id": 1, "data": 52.0, "name": "volume" }
+
+``observe_property_string``
+    Like ``observe_property``, but the resulting data will always be a string.
+
+    Example:
+
+    ::
+
+        { "command": ["observe_property_string", 1, "volume"] }
+        { "error": "success" }
+        { "event": "property-change", "id": 1, "data": "52.000000", "name": "volume" }
+
+``unobserve_property``
+    Undo ``observe_property`` or ``observe_property_string``. This requires the
+    numeric id passed to the observe command as argument.
+
+    Example:
+
+    ::
+
+        { "command": ["unobserve_property", 1] }
+        { "error": "success" }
+
+``request_log_messages``
+    Enable output of mpv log messages. They will be received as events. The
+    parameter to this command is the log-level (see ``mpv_request_log_messages``
+    C API function).
+
+    Log message output is meant for humans only (mostly for debugging).
+    Attempting to retrieve information by parsing these messages will just
+    lead to breakages with future mpv releases. Instead, make a feature request,
+    and ask for a proper event that returns the information you need.
+
+``enable_event``, ``disable_event``
+    Enables or disables the named event. Mirrors the ``mpv_request_event`` C
+    API function. If the string ``all`` is used instead of an event name, all
+    events are enabled or disabled.
+
+    By default, most events are enabled, and there is not much use for this
+    command.
+
+``suspend``
+    Suspend the mpv main loop. There is a long-winded explanation of this in
+    the C API function ``mpv_suspend()``. In short, this prevents the player
+    from displaying the next video frame, so that you don't get blocked when
+    trying to access the player.
+
+``resume``
+    Undo one ``suspend`` call. ``suspend`` increments an internal counter, and
+    ``resume`` decrements it. When 0 is reached, the player is actually resumed.
+
+``get_version``
+    Returns the client API version the C API of the remote mpv instance
+    provides. (Also see ``DOCS/client-api-changes.rst``.)
+
+UTF-8
+-----
+
+Normally, all strings are in UTF-8. Sometimes it can happen that strings are
+in some broken encoding (often happens with file tags and such, and filenames
+on many Unixes are not required to be in UTF-8 either). This means that mpv
+sometimes sends invalid JSON. If that is a problem for the client application's
+parser, it should filter the raw data for invalid UTF-8 sequences and perform
+the desired replacement, before feeding the data to its JSON parser.
+
+mpv will not attempt to construct invalid UTF-8 with broken escape sequences.

DOCS/man/lua.rst

@@ -1,10 +1,16 @@
 LUA SCRIPTING
 =============
 
-mpv can load Lua scripts. Scripts in ``~/.mpv/lua/`` will be loaded on program
-start, or if passed to ``--lua``. mpv provides the built-in module ``mp``, which
-provides functions to send commands to the mpv core and to retrieve information
-about playback state, user settings, file information, and so on.
+mpv can load Lua scripts. Scripts passed to the ``--script`` option, or found in
+the ``scripts`` subdirectory of the mpv configuration directory (usually
+``~/.config/mpv/scripts/``) will be loaded on program start. mpv also appends the
+``scripts`` subdirectory to the end of Lua's path so you can import scripts from
+there too. Since it's added to the end, don't name scripts you want to import
+the same as Lua libraries because they will be overshadowed by them.
+
+mpv provides the built-in module ``mp``, which contains functions to send
+commands to the mpv core and to retrieve information about playback state, user
+settings, file information, and so on.
 
 These scripts can be used to control mpv in a similar way to slave mode.
 Technically, the Lua code uses the client API internally.
@@ -16,23 +22,24 @@ A script which leaves fullscreen mode when the player is paused:
 
 ::
 
-    function on_pause()
-        mp.set_property("fullscreen", "no")
+    function on_pause_change(name, value)
+        if value == true then
+            mp.set_property("fullscreen", "no")
+        end
     end
-    mp.register_event("pause", on_pause)
+    mp.observe_property("pause", "bool", on_pause_change)
 
-This script provides a pretty weird feature, but Lua scripting was made to
-allow users implement features which are not going to be added to the mpv core.
 
-Mode of operation
------------------
+Details on the script initialization and lifecycle
+--------------------------------------------------
 
-Your script will be loaded by the player at program start from ``~/.mpv/lua/``,
-or ``--lua``, or in some cases, internally (like ``--osc``). Each script runs
-in its own thread. Your script is first run "as is", and once that is done,
-the event loop is entered. This event loop will dispatch events received by mpv
-and call your own event handlers which you have registered with
-``mp.register_event``, or timers added with ``mp.add_timeout`` or similar.
+Your script will be loaded by the player at program start from the ``scripts``
+configuration subdirectory, or from a path specified with the ``--script``
+option. Some scripts are loaded internally (like ``--osc``). Each script runs in
+its own thread. Your script is first run "as is", and once that is done, the event loop
+is entered. This event loop will dispatch events received by mpv and call your
+own event handlers which you have registered with ``mp.register_event``, or
+timers added with ``mp.add_timeout`` or similar.
 
 When the player quits, all scripts will be asked to terminate. This happens via
 a ``shutdown`` event, which by default will make the event loop return. If your
@@ -47,6 +54,15 @@ The event loop will wait for events and dispatch events registered with
 ``mp.register_event``. It will also handle timers added with ``mp.add_timeout``
 and similar (by waiting with a timeout).
 
+Since mpv 0.6.0, the player will wait until the script is fully loaded before
+continuing normal operation. The player considers a script as fully loaded as
+soon as it starts waiting for mpv events (or it exits). In practice this means
+the player will more or less hang until the script returns from the main chunk
+(and ``mp_event_loop`` is called), or the script calls ``mp_event_loop`` or
+``mp.dispatch_events`` directly. This is done to make it possible for a script
+to fully setup event handlers etc. before playback actually starts. In older
+mpv versions, this happened asynchronously.
+
 mp functions
 ------------
 
@@ -78,6 +94,15 @@ The ``mp`` module is preloaded, although it can be loaded manually with
     the ``expand-properties`` prefix, or the ``mp.get_property`` family of
     functions.
 
+``mp.command_native(table [,def])``
+    Similar to ``mp.commandv``, but pass the argument list as table. This has
+    the advantage that in at least some cases, arguments can be passed as
+    native types.
+
+    Returns a result table on success (usually empty), or ``def, error`` on
+    error. ``def`` is the second parameter provided to the function, and is
+    nil if it's missing.
+
 ``mp.get_property(name [,def])``
     Return the value of the given property as string. These are the same
     properties as used in input.conf. See `Properties`_ for a list of
@@ -156,7 +181,7 @@ The ``mp`` module is preloaded, although it can be loaded manually with
     Return the current mpv internal time in seconds as a number. This is
     basically the system time, with an arbitrary offset.
 
-``mp.add_key_binding(key, name|fn [,fn])``
+``mp.add_key_binding(key, name|fn [,fn [,flags]])``
     Register callback to be run on a key binding. The binding will be mapped to
     the given ``key``, which is a string describing the physical key. This uses
     the same key names as in input.conf, and also allows combinations
@@ -173,8 +198,23 @@ The ``mp`` module is preloaded, although it can be loaded manually with
     overwritten. You can omit the name, in which case a random name is generated
     internally.
 
-    Internally, key bindings are dispatched via the ``script_message_to`` input
-    command and ``mp.register_script_message``.
+    The last argument is used for optional flags. This is a table, which can
+    have the following entries:
+
+        ``repeatable``
+            If set to ``true``, enables key repeat for this specific binding.
+
+        ``complex``
+            If set to ``true``, then ``fn`` is called on both key up and down
+            events (as well as key repeat, if enabled), with the first
+            argument being a table. This table has an ``event`` entry, which
+            is set to one of the strings ``down``, ``repeat``, ``up`` or
+            ``press`` (the latter if key up/down can't be tracked). It further
+            has an ``is_mouse`` entry, which tells whether the event was caused
+            by a mouse button.
+
+    Internally, key bindings are dispatched via the ``script_message_to`` or
+    ``script_binding`` input commands and ``mp.register_script_message``.
 
     Trying to map multiple commands to a key will essentially prefer a random
     binding, while the other bindings are not called. It is guaranteed that
@@ -197,7 +237,7 @@ The ``mp`` module is preloaded, although it can be loaded manually with
 
     ::
 
-        y script_message something
+        y script_binding something
 
 
     This will print the message when the key ``y`` is pressed. (``x`` will
@@ -208,7 +248,7 @@ The ``mp`` module is preloaded, although it can be loaded manually with
 
     ::
 
-        y script_message_to fooscript something
+        y script_binding fooscript.something
 
 ``mp.add_forced_key_binding(...)``
     This works almost the same as ``mp.add_key_binding``, but registers the
@@ -319,7 +359,7 @@ The ``mp`` module is preloaded, although it can be loaded manually with
 
 
 ``mp.get_opt(key)``
-    Return a setting from the ``--lua-opts`` option. It's up to the user and
+    Return a setting from the ``--script-opts`` option. It's up to the user and
     the script how this mechanism is used. Currently, all scripts can access
     this equally, so you should be careful about collisions.
 
@@ -455,7 +495,7 @@ Example implementation::
         optionB = -0.5,
         optionC = true,
     }
-    options.read_options(options, "myscript")
+    read_options(options, "myscript")
     print(option.optionA)
 
 
@@ -471,12 +511,12 @@ Example config::
     optionC=no
 
 
-Command-line options are read from the ``--lua-opts`` parameter. To avoid
+Command-line options are read from the ``--script-opts`` parameter. To avoid
 collisions, all keys have to be prefixed with ``identifier-``.
 
 Example command-line::
 
-     --lua-opts=myscript-optionA=TEST:myscript-optionB=0:myscript-optionC=yes
+     --script-opts=myscript-optionA=TEST,myscript-optionB=0,myscript-optionC=yes
 
 
 mp.utils options
@@ -486,6 +526,13 @@ This built-in module provides generic helper functions for Lua, and have
 strictly speaking nothing to do with mpv or video/audio playback. They are
 provided for convenience. Most compensate for Lua's scarce standard library.
 
+Be warned that any of these functions might disappear any time. They are not
+strictly part of the guaranteed API.
+
+``utils.getcwd()``
+    Returns the directory that mpv was launched from. On error, ``nil, error``
+    is returned.
+
 ``utils.readdir(path [, filter])``
     Enumerate all entries at the given path on the filesystem, and return them
     as array. Each entry is a directory entry (without the path).
@@ -522,6 +569,64 @@ provided for convenience. Most compensate for Lua's scarce standard library.
     Return the concatenation of the 2 paths. Tries to be clever. For example,
     if ```p2`` is an absolute path, p2 is returned without change.
 
+``utils.subprocess(t)``
+    Runs an external process and waits until it exits. Returns process status
+    and the captured output.
+
+    The parameter ``t`` is a table. The function reads the following entries:
+
+        ``args``
+            Array of strings. The first array entry is the executable. This
+            can be either an absolute path, or a filename with no path
+            components, in which case the ``PATH`` environment variable is
+            used to resolve the executable. The other array elements are
+            passed as command line arguments.
+
+        ``cancellable``
+            Optional. If set to ``true`` (default), then if the user stops
+            playback or goes to the next file while the process is running,
+            the process will be killed.
+
+        ``max_size``
+            Optional. The maximum size in bytes of the data that can be captured
+            from stdout. (Default: 16 MB.)
+
+    The function returns a table as result with the following entries:
+
+        ``status``
+            The raw exit status of the process. It will be negative on error.
+
+        ``stdout``
+            Captured output stream as string, limited to ``max_size``.
+
+        ``error``
+            ``nil`` on success. The string ``killed`` if the process was
+            terminated in an unusual way. The string ``init`` if the process
+            could not be started.
+
+            On Windows, ``killed`` is only returned when the process has been
+            killed by mpv as a result of ``cancellable`` being set to ``true``.
+
+    In all cases, ``mp.resume_all()`` is implicitly called.
+
+``utils.parse_json(str [, trail])``
+    Parses the given string argument as JSON, and returns it as a Lua table. On
+    error, returns ``nil, error``. (Currently, ``error`` is just a string
+    reading ``error``, because there is no fine-grained error reporting of any
+    kind.)
+
+    The returned value uses similar conventions as ``mp.get_property_native()``
+    to distinguish empty objects and arrays.
+
+    If the ``trail`` parameter is ``true`` (or any value equal to ``true``),
+    then trailing non-whitespace text is tolerated by the function, and the
+    trailing text is returned as 3rd return value. (The 3rd return value is
+    always there, but with ``trail`` set, no error is raised.)
+
+``utils.to_string(v)``
+    Turn the given value into a string. Formats tables and their contents. This
+    doesn't do anything special; it is only needed because Lua is terrible.
+
 Events
 ------
 
@@ -539,7 +644,7 @@ Example:
         print("start of playback!")
     end
 
-    mp.register_event("playback-start", my_fn)
+    mp.register_event("file-loaded", my_fn)
 
 
 
@@ -558,33 +663,18 @@ List of events
     Happens after a file was loaded and begins playback.
 
 ``seek``
-    Happens on seeking (including ordered chapter segment changes).
+    Happens on seeking. (This might include cases when the player seeks
+    internally, even without user interaction. This includes e.g. segment
+    changes when playing ordered chapters Matroska files.)
 
 ``playback-restart``
     Start of playback after seek or after file was loaded.
 
-``tracks-changed``
-    The list of video/audio/sub tracks was updated. (This happens on playback
-    start, and very rarely during playback.)
-
-``track-switched``
-    A video/audio/subtitle track was switched on or off. This usually happens
-    when the user (or a script) changes the subtitle track and so on.
-
 ``idle``
     Idle mode is entered. This happens when playback ended, and the player was
     started with ``--idle`` or ``--force-window``. This mode is implicitly ended
     when the ``start-file`` or ``shutdown`` events happen.
 
-``pause``
-    Playback was paused. This also happens when for example the player is
-    paused on low network cache. Then the event type indicates the pause state
-    (like the property "pause" as opposed to the "core-idle" property), and you
-    might receive multiple ``pause`` events in a row.
-
-``unpause``
-    Playback was unpaused. See above for details.
-
 ``tick``
     Called after a video frame was displayed. This is a hack, and you should
     avoid using it. Use timers instead and maybe watch pausing/unpausing events
@@ -592,7 +682,7 @@ List of events
 
 ``shutdown``
     Sent when the player quits, and the script should terminate. Normally
-    handled automatically. See `Mode of operation`_.
+    handled automatically. See `Details on the script initialization and lifecycle`_.
 
 ``log-message``
     Receives messages enabled with ``mp.enable_messages``. The message data
@@ -611,13 +701,8 @@ List of events
         (undocumented) existing ones.
 
     ``text``
-        The log message. Note that this is the direct output of a printf()
-        style output API. The text will contain embedded newlines, and it's
-        possible that a single message contains multiple lines, or that a
-        message contains a partial line.
-
-        It's safe to display messages only if they end with a newline character,
-        and to buffer them otherwise.
+        The log message. The text will end with a newline character. Sometimes
+        it can contain multiple lines.
 
     Keep in mind that these messages are meant to be hints for humans. You
     should not parse them, and prefix/level/text of messages might change
@@ -632,9 +717,6 @@ List of events
 ``command-reply``
     Undocumented (not useful for Lua scripts).
 
-``script-input-dispatch``
-    Undocumented (used internally).
-
 ``client-message``
     Undocumented (used internally).
 
@@ -644,8 +726,25 @@ List of events
 ``audio-reconfig``
     Happens on audio output or filter reconfig.
 
-``metadata-update``
-    Metadata (like file tags) was updated.
+The following events also happen, but are deprecated: ``tracks-changed``,
+``track-switched``, ``pause``, ``unpause``, ``metadata-update``,
+``chapter-change``. Use ``mp.observe_property()`` instead.
 
-``chapter-change``
-    The current chapter possibly changed.
+Extras
+------
+
+This documents experimental features, or features that are "too special" to
+guarantee a stable interface.
+
+``mp.add_hook(type, priority, fn)``
+    Add a hook callback for ``type`` (a string identifying a certain kind of
+    hook). These hooks allow the player to call script functions and wait for
+    their result (normally, the Lua scripting interface is asynchronous from
+    the point of view of the player core). ``priority`` is an arbitrary integer
+    that allows ordering among hooks of the same kind. Using the value 50 is
+    recommended as neutral default value. ``fn`` is the function that will be
+    called during execution of the hook.
+
+    See `Hooks`_ for currently existing hooks and what they do - only the hook
+    list is interesting; handling hook execution is done by the Lua script
+    function automatically.

DOCS/man/mpv.rst

@@ -12,8 +12,7 @@ a media player
 SYNOPSIS
 ========
 
-| **mpv** [options] [file|URL|-]
-| **mpv** [options] --playlist=PLAYLIST
+| **mpv** [options] [file|URL|PLAYLIST|-]
 | **mpv** [options] files
 
 DESCRIPTION
@@ -47,6 +46,10 @@ UP and DOWN
     Seek forward/backward 1 minute. Shift+arrow does a 5 second exact seek (see
     ``--hr-seek``).
 
+Ctrl+LEFT and Ctrl+RIGHT
+    Seek to the previous/next subtitle. Subject to some restrictions and
+    might not work always; see ``sub_seek`` command.
+
 [ and ]
     Decrease/increase current playback speed by 10%.
 
@@ -60,7 +63,7 @@ BACKSPACE
     Go backward/forward in the playlist.
 
 ENTER
-    Go forward in the playlist, even over the end.
+    Go forward in the playlist.
 
 p / SPACE
     Pause (pressing again unpauses).
@@ -73,7 +76,7 @@ p / SPACE
     Step backward. Pressing once will pause, every consecutive press will
     play one frame in reverse and then go into pause mode again.
 
-q / ESC
+q
     Stop playing and quit.
 
 Q
@@ -98,6 +101,9 @@ m
 f
     Toggle fullscreen (see also ``--fs``).
 
+ESC
+    Exit fullscreen mode.
+
 T
     Toggle stay-on-top (see also ``--ontop``).
 
@@ -123,6 +129,12 @@ j and J
 x and z
     Adjust subtitle delay by +/- 0.1 seconds.
 
+l
+    Set/clear A-B loop points. See ``ab_loop`` command for details.
+
+Ctrl + and Ctrl -
+    Adjust audio delay by +/- 0.1 seconds.
+
 V
     Toggle subtitle VSFilter aspect compatibility mode. See
     ``--ass-vsfilter-aspect-compat`` for more info.
@@ -145,9 +157,16 @@ PGUP and PGDWN
     "previous" will actually go to the beginning of the current chapter; see
     ``--chapter-seek-threshold``.
 
+Shift+PGUP and Shift+PGDWN
+    Seek backward or forward by 10 minutes. (This used to be mapped to
+    PGUP/PGDWN without Shift.)
+
 D
     Activate/deactivate deinterlacer.
 
+A
+    Cycle aspect ratio override.
+
 (The following keys are valid only when using a video output that supports the
 corresponding adjustment, or the software equalizer (``--vf=eq``).)
 
@@ -219,11 +238,43 @@ is the same as ``--no-fs``.
 If an option is marked as *(XXX only)*, it will only work in combination with
 the *XXX* option or if *XXX* is compiled in.
 
-.. note::
+Escaping spaces and other special characters
+--------------------------------------------
 
-    The suboption parser (used for example for ``--ao=pcm`` suboptions)
-    supports a special kind of string-escaping intended for use with external
-    GUIs.
+Keep in mind that the shell will partially parse and mangle the arguments you
+pass to mpv. For example, you might need to quote or escape options and
+filenames:
+
+    ``mpv "filename with spaces.mkv" --title="window title"``
+
+It gets more complicated if the suboption parser is involved. The suboption
+parser puts several options into a single string, and passes them to a
+component at once, instead of using multiple options on the level of the
+command line.
+
+The suboption parser can quote strings with ``"``, ``'``, and ``[...]``.
+Additionally, there is a special form of quoting with ``%n%`` described below.
+
+For example, the ``opengl`` VO can take multiple options:
+
+    ``mpv test.mkv --vo=opengl:scale=lanczos:icc-profile=file.icc,xv``
+
+This passes ``scale=lanczos`` and ``icc-profile=file.icc`` to ``opengl``,
+and also specifies ``xv`` as fallback VO. If the icc-profile path contains
+spaces or characters like ``,`` or ``:``, you need to quote them:
+
+    ``mpv '--vo=opengl:icc-profile="file with spaces.icc",xv'``
+
+Shells may actually strip some quotes from the string passed to the commandline,
+so the example quotes the string twice, ensuring that mpv recieves the ``"``
+quotes.
+
+The ``[...]`` from of quotes wraps everything between ``[`` and ``]``. It's
+useful with shells that don't interpret these characters in the middle of
+an argument (like bash).
+
+A special kind of string-escaping intended for use with external scripts and
+programs is started with ``%``.
 
 It has the following format::
 
@@ -237,6 +288,15 @@ It has the following format::
 
     ``mpv --ao=pcm:file=%`expr length "$NAME"`%"$NAME" test.avi``
 
+Suboptions passed to the client API are also subject to escaping. Using
+``mpv_set_option_string()`` is exactly like passing ``--name=data`` to the
+command line (but without shell processing of the string). Some options
+support passing values in a more structured way instead of flat strings, and
+can avoid the suboption parsing mess. For example, ``--vf`` supports
+``MPV_FORMAT_NODE``, which let's you pass suboptions as a nested data structure
+of maps and arrays. (``--vo`` supports this in the same way, although this
+fact is undocumented.)
+
 Paths
 -----
 
@@ -255,7 +315,7 @@ need to escape special characters. To work this around, the path can be
 additionally wrapped in the ``%n%string_of_length_n`` syntax (see above).
 
 Some mpv options interpret paths starting with ``~``. Currently, the prefix
-``~~/`` expands to the mpv configuration directory (usually ``~/.mpv/``).
+``~~/`` expands to the mpv configuration directory (usually ``~/.config/mpv/``).
 ``~/`` expands to the user's home directory. (The trailing ``/`` is always
 required.)
 
@@ -324,6 +384,17 @@ setting them to *no*. Even suboptions can be specified in this way.
         # Use quotes for text that can contain spaces:
         status-msg="Time: ${time-pos}"
 
+Escaping spaces and special characters
+--------------------------------------
+
+This is done like with command line options. The shell is not involved here,
+but option values still need to be quoted as a whole if it contains certain
+characters like spaces. A config entry can be quoted with ``"`` and ``'``,
+as well as with the ``%n%`` syntax mentioned before. This is like passing
+the exact contents of the quoted string as command line option. C-style escapes
+are currently _not_ interpreted on this level, although some options to this
+manually. (This is a mess and should probably be changed at some point.)
+
 Putting Command Line Options into the Configuration File
 --------------------------------------------------------
 
@@ -345,11 +416,11 @@ File-specific Configuration Files
 You can also write file-specific configuration files. If you wish to have a
 configuration file for a file called 'video.avi', create a file named
 'video.avi.conf' with the file-specific options in it and put it in
-``~/.mpv/``. You can also put the configuration file in the same directory
-as the file to be played, as long as you give the ``--use-filedir-conf``
+``~/.config/mpv/``. You can also put the configuration file in the same directory
+as the file to be played. Both require you to set the ``--use-filedir-conf``
 option (either on the command line or in your global config file). If a
 file-specific configuration file is found in the same directory, no
-file-specific configuration is loaded from ``~/.mpv``. In addition, the
+file-specific configuration is loaded from ``~/.config/mpv``. In addition, the
 ``--use-filedir-conf`` option enables directory-specific configuration files.
 For this, mpv first tries to load a mpv.conf from the same directory
 as the file played and then tries to load any file-specific configuration.
@@ -370,12 +441,11 @@ profile name ``default`` to continue with normal options.
     ::
 
         [vo.vdpau]
-        # Use hardware decoding (might break playback of some h264 files)
+        # Use hardware decoding
         hwdec=vdpau
 
         [protocol.dvd]
         profile-desc="profile for dvd:// streams"
-        vf=pp=hb/vb/dr/al/fd
         alang=en
 
         [extension.flv]
@@ -404,6 +474,52 @@ taking screenshots is handled by the VOs, and adding the screenshot filter will
 break hardware decoding. (The filter may still be useful for taking screenshots
 at a certain point within the video chain when using multiple video filters.)
 
+TERMINAL STATUS LINE
+====================
+
+During playback, mpv shows the playback status on the terminal. It looks like
+something like this:
+
+    ``AV: 00:03:12 / 00:24:25 (13%) A-V: -0.000``
+
+The status line can be overridden with the ``--term-status-msg`` option.
+
+The following is a list of things that can show up in the status line. Input
+properties, that can be used to get the same information manually, are also
+listed.
+
+- ``AV:`` or ``V:`` (video only) or ``A:`` (audio only)
+- The current time position in ``HH:MM:SS`` format (``playback-time`` property)
+- The total file duration (absent if unknown) (``length`` property)
+- Playback speed, e.g. `` x2.0``. Only visible if the speed is not normal. This
+  is the user-requested speed, and not the actual speed  (usually they should
+  be the same, unless playback is too slow). (``speed`` property.)
+- Playback percentage, e.g. ``(13%)``. How much of the file has been played.
+  Normally calculated out of playback position and duration, but can fallback
+  to other methods (like byte position) if these are not available.
+  (``percent-pos`` property.)
+- The audio/video sync as ``A-V:  0.000``. This is the difference between
+  audio and video time. Normally it should be 0 or close to 0. If it's growing,
+  it might indicate a playback problem. (``avsync`` property.)
+- Total A/V sync change, e.g. ``ct: -0.417``. Normally invisible. Can show up
+  if there is audio "missing", or not enough frames can be dropped. Usually
+  this will indicate a problem. (``total-avsync-change`` property.)
+- Encoding state in ``{...}``, only shown in encoding mode.
+- Dropped frames, e.g. ``Dropped: 4``. Shows up only if the count is not 0. Can
+  grow if the video framerate is higher than that of the display, or if video
+  rendering is too slow. Also can be incremented on "hiccups" and when the video
+  frame couldn't be displayed on time. (``vo-drop-frame-count`` property.)
+  If the decoder drops frames, the number of decoder-dropped frames is appended
+  to the display as well, e.g.: ``Dropped: 4/34``. This should almost never
+  happen, unless decoder-framedropping is enabled with one of the
+  ``--framedrop`` options, the stream contains errors, or a weird codec is in
+  use. (``drop-frame-count`` property.)
+- Cache state, e.g. ``Cache:  2s+134KB``. Visible if the stream cache is enabled.
+  The first value shows the amount of video buffered in the demuxer in seconds,
+  the second value shows *additional* data buffered in the stream cache in
+  kilobytes. (``demuxer-cache-duration`` and ``cache-used`` properties.)
+
+
 PROTOCOLS
 =========
 
@@ -412,6 +528,10 @@ PROTOCOLS
     be specified. mpv will never attempt to guess whether a filename is
     actually a network address. A protocol prefix is always required.
 
+    Note that not all prefixes are documented here. Undocumented prefixes are
+    either aliases to documented protocols, or are just redirections to
+    protocols implemented and documented in FFmpeg.
+
 ``-``
     Play data from stdin.
 
@@ -421,7 +541,7 @@ PROTOCOLS
 ``bd://[title][/device]`` ``--bluray-device=PATH``
     Play a Blu-Ray disc. Currently, this does not accept ISO files. Instead,
     you must mount the ISO file as filesystem, and point ``--bluray-device``
-    to the mounted directly.
+    to the mounted directory directly.
 
 ``bdnav://[title][/device]``
     Play a Blu-Ray disc, with navigation features enabled. This feature is
@@ -501,6 +621,8 @@ PROTOCOLS
 
 .. include:: lua.rst
 
+.. include:: ipc.rst
+
 .. include:: changes.rst
 
 ENVIRONMENT VARIABLES
@@ -644,18 +766,69 @@ FILES
 ``~/.config/mpv/input.conf``
     key bindings (see `INPUT.CONF`_ section)
 
-``~/.config/mpv/lua/``
-    All files in this directly are loaded as if they were passed to the
-    ``--lua`` option. They are loaded in alphabetical order, and sub-directories
+``~/.config/mpv/scripts/``
+    All files in this directory are loaded as if they were passed to the
+    ``--script`` option. They are loaded in alphabetical order, and sub-directories
     and files with no ``.lua`` extension are ignored. The ``--load-scripts=no``
     option disables loading these files.
 
+``~/.config/mpv/watch_later/``
+    Contains temporary config files needed for resuming playback of files with
+    the watch later feature. See for example the ``Q`` key binding, or the
+    ``quit_watch_later`` input command.
+
+    Each file is a small config file which is loaded if the corresponding media
+    file is loaded. It contains the playback position and some (not necessarily
+    all) settings that were changed during playback. The filenames are hashed
+    from the full paths of the media files. It's in general not possible to
+    extract the media filename from this hash. However, you can set the
+    ``--write-filename-in-watch-later-config`` option, and the player will
+    add the media filename to the contents of the resume config file.
+
+``~/.config/mpv/lua-settings/osc.conf``
+    This is loaded by the OSC script. See the `ON SCREEN CONTROLLER`_ docs
+    for details.
+
+    Other files in this directory are specific to the corresponding scripts
+    as well, and the mpv core doesn't touch them.
+
 Note that the environment variables ``$XDG_CONFIG_HOME`` and ``$MPV_HOME`` can
 override the standard directory ``~/.config/mpv/``.
 
 Also, the old config location at ``~/.mpv/`` is still read, and if the XDG
 variant does not exist, will still be preferred.
 
+FILES ON WINDOWS
+================
+
+On win32 (if compiled with MinGW, but not Cygwin), the default config file
+locations are different. They are generally located under ``%APPDATA%/mpv/``.
+For example, the path to mpv.conf is ``%APPDATA%/mpv/mpv.conf``, which maps to
+a system and user-specific path, for example
+
+    ``C:\users\USERNAME\Application Data\mpv\mpv.conf``
+
+You can find the exact path by running ``echo %APPDATA%\mpv\mpv.conf`` in cmd.exe.
+
+Other config files (such as ``input.conf``) are in the same directory. See the
+`FILES`_ section above.
+
+The environment variable ``$MPV_HOME`` completely overrides these, like on
+UNIX.
+
+Config files located in the same directory as ``mpv.exe`` are loaded with
+lower priority. Some config files are loaded only once, which means that
+e.g. of 2 ``input.conf`` files located in two config directories, only the
+one from the directory with higher priority will be loaded.
+
+A third config directory with lowest priority is the directory named ``mpv``
+in the same directory as ``mpv.exe``. This used to be the directory with
+highest priority, but is now discouraged to use and might be removed in the
+future.
+
+Note that mpv likes to mix ``/`` and ``\`` path separators for simplicity.
+kernel32.dll accepts this, but cmd.exe does not.
+
 EXAMPLES OF MPV USAGE
 =====================
 

DOCS/man/osc.rst

@@ -127,7 +127,7 @@ Key Bindings
 
 These key bindings are active by default if nothing else is already bound to
 these keys. In case of collision, the function needs to be bound to a
-different key. See `Script Commands`_ section.
+different key. See the `Script Commands`_ section.
 
 =============   ================================================
 del             Hide the OSC permanently until mpv is restarted.
@@ -138,7 +138,7 @@ Configuration
 
 The OSC offers limited configuration through a config file
 ``lua-settings/osc.conf`` placed in mpv's user dir and through the
-``--lua-opts`` command-line option. Options provided through the command-line
+``--script-opts`` command-line option. Options provided through the command-line
 will override those from the config file.
 
 Config Syntax
@@ -161,7 +161,7 @@ To avoid collisions with other scripts, all options need to be prefixed with
 
 Example::
 
-    --lua-opts=osc-optionA=value1:osc-optionB=value2
+    --script-opts=osc-optionA=value1,osc-optionB=value2
 
 
 Configurable Options
@@ -225,9 +225,14 @@ Configurable Options
     | Minimum amount of pixels the mouse has to move between ticks to make
       the OSC show up
 
-``seektooltip``
-    | Default: yes
-    | Display a tooltip over the seekbar indicating time at mouse position.
+``layout``
+    | Default: box
+    | The layout for the OSC. Currently available are: box, slimbox,
+      bottombar and topbar.
+
+``seekbarstyle``
+    | Default: slider
+    | Sets the style of the seekbar, slider (diamond marker) or bar (fill)
 
 Script Commands
 ~~~~~~~~~~~~~~~
@@ -241,6 +246,10 @@ in ``input.conf``, or sent by other scripts.
 ``disable-osc``
     Hide the OSC permanently. This is also what the ``del`` key does.
 
+``osc-message``
+    Show a message on screen using the OSC. First argument is the message,
+    second the duration in seconds.
+
 
 Example
 

DOCS/man/vf.rst

@@ -143,8 +143,8 @@ Available filters are:
         Accurate rounding for the vertical scaler, which may be faster or
         slower than the default rounding.
 
-        :0: Disable accurate rounding (default).
-        :1: Enable accurate rounding.
+        :no:  Disable accurate rounding (default).
+        :yes: Enable accurate rounding.
 
 ``dsize[=w:h:aspect-method:r:aspect]``
     Changes the intended display size/aspect at an arbitrary point in the
@@ -231,150 +231,6 @@ Available filters are:
     ``<fmt>``
         Format name, e.g. rgb15, bgr24, 420p, etc. (default: 420p).
 
-``pp[=[filter1[:option1[:option2...]]/[-]filter2...]]``
-    Enables the specified chain of post-processing subfilters. Subfilters must
-    be separated by '/' and can be disabled by prepending a '-'. Each
-    subfilter and some options have a short and a long name that can be used
-    interchangeably, i.e. ``dr``/``dering`` are the same. All subfilters share
-    common options to determine their scope:
-
-    ``a/autoq``
-        Automatically switch the subfilter off if the CPU is too slow.
-    ``c/chrom``
-        Do chrominance filtering, too (default).
-    ``y/nochrom``
-        Do luminance filtering only (no chrominance).
-    ``n/noluma``
-        Do chrominance filtering only (no luminance).
-
-    .. note::
-
-        ``--vf=pp:help`` shows a list of available subfilters.
-
-    .. note::
-
-        Unlike in MPlayer or in earlier versions, you must quote the pp string
-        if it contains ``:`` characters, e.g. ``'--vf=pp=[...]'``.
-
-    Available subfilters are:
-
-    ``hb/hdeblock[:difference[:flatness]]``
-        horizontal deblocking filter
-
-        :<difference>: Difference factor where higher values mean more
-                       deblocking (default: 32).
-        :<flatness>:   Flatness threshold where lower values mean more
-                       deblocking (default: 39).
-
-    ``vb/vdeblock[:difference[:flatness]]``
-        vertical deblocking filter
-
-        :<difference>: Difference factor where higher values mean more
-                       deblocking (default: 32).
-        :<flatness>:   Flatness threshold where lower values mean more
-                       deblocking (default: 39).
-
-    ``ha/hadeblock[:difference[:flatness]]``
-        accurate horizontal deblocking filter
-
-        :<difference>: Difference factor where higher values mean more
-                       deblocking (default: 32).
-        :<flatness>:   Flatness threshold where lower values mean more
-                       deblocking (default: 39).
-
-    ``va/vadeblock[:difference[:flatness]]``
-        accurate vertical deblocking filter
-
-        :<difference>: Difference factor where higher values mean more
-                       deblocking (default: 32).
-        :<flatness>:   Flatness threshold where lower values mean more
-                       deblocking (default: 39).
-
-    The horizontal and vertical deblocking filters share the difference and
-    flatness values so you cannot set different horizontal and vertical
-    thresholds.
-
-    ``h1/x1hdeblock``
-        experimental horizontal deblocking filter
-
-    ``v1/x1vdeblock``
-        experimental vertical deblocking filter
-
-    ``dr/dering``
-        deringing filter
-
-    ``tn/tmpnoise[:threshold1[:threshold2[:threshold3]]]``
-        temporal noise reducer
-
-        :<threshold1>: larger -> stronger filtering
-        :<threshold2>: larger -> stronger filtering
-        :<threshold3>: larger -> stronger filtering
-
-    ``al/autolevels[:f/fullyrange]``
-        automatic brightness / contrast correction
-
-        :f/fullyrange: Stretch luminance to (0-255).
-
-    ``lb/linblenddeint``
-        Linear blend deinterlacing filter that deinterlaces the given block by
-        filtering all lines with a (1 2 1) filter.
-
-    ``li/linipoldeint``
-        Linear interpolating deinterlacing filter that deinterlaces the given
-        block by linearly interpolating every second line.
-
-    ``ci/cubicipoldeint``
-        Cubic interpolating deinterlacing filter deinterlaces the given block
-        by cubically interpolating every second line.
-
-    ``md/mediandeint``
-        Median deinterlacing filter that deinterlaces the given block by
-        applying a median filter to every second line.
-
-    ``fd/ffmpegdeint``
-        FFmpeg deinterlacing filter that deinterlaces the given block by
-        filtering every second line with a (-1 4 2 4 -1) filter.
-
-    ``l5/lowpass5``
-        Vertically applied FIR low-pass deinterlacing filter that deinterlaces
-        the given block by filtering all lines with a (-1 2 6 2 -1) filter.
-
-    ``fq/forceQuant[:quantizer]``
-        Overrides the quantizer table from the input with the constant
-        quantizer you specify.
-
-        :<quantizer>: quantizer to use
-
-    ``de/default``
-        default pp filter combination (hb:a,vb:a,dr:a)
-
-    ``fa/fast``
-        fast pp filter combination (h1:a,v1:a,dr:a)
-
-    ``ac``
-        high quality pp filter combination (ha:a:128:7,va:a,dr:a)
-
-    .. note::
-
-        This filter is only available if FFmpeg/Libav has been compiled
-        with libpostproc enabled.
-
-    .. admonition:: Examples
-
-        ``--vf=pp=hb/vb/dr/al``
-            horizontal and vertical deblocking, deringing and automatic
-            brightness/contrast
-
-        ``--vf=pp=de/-al``
-            default filters without brightness/contrast correction
-
-        ``--vf=pp=[default/tmpnoise:1:2:3]``
-            Enable default filters & temporal denoiser.
-
-        ``--vf=pp=[hb:y/vb:a]``
-            Horizontal deblocking on luminance only, and switch vertical
-            deblocking on or off automatically depending on available CPU time.
-
 ``lavfi=graph[:sws-flags[:o=opts]]``
     Filter video using FFmpeg's libavfilter.
 
@@ -445,10 +301,6 @@ Available filters are:
     ``uniform``
         uniform noise (Gaussian otherwise)
 
-    ``hq``
-        high quality (slightly better looking, slightly slower) - not available
-        when using libavfilter
-
 ``hqdn3d[=luma_spatial:chroma_spatial:luma_tmp:chroma_tmp]``
     This filter aims to reduce image noise producing smooth images and making
     still images really still (This should enhance compressibility.).
@@ -489,19 +341,6 @@ Available filters are:
         and just plain white. A value of 0.0 turns the gamma correction all
         the way down while 1.0 leaves it at its full strength (default: 1.0).
 
-``ilpack[=mode]``
-    When interlaced video is stored in YUV 4:2:0 formats, chroma interlacing
-    does not line up properly due to vertical downsampling of the chroma
-    channels. This filter packs the planar 4:2:0 data into YUY2 (4:2:2) format
-    with the chroma lines in their proper locations, so that in any given
-    scanline, the luma and chroma data both come from the same field.
-
-    ``<mode>``
-        Select the sampling mode.
-
-        :0: nearest-neighbor sampling, fast but incorrect
-        :1: linear interpolation (default)
-
 ``unsharp[=lx:ly:la:cx:cy:ca]``
     unsharp mask / Gaussian blur
 
@@ -519,9 +358,6 @@ Available filters are:
         :<0: blur
         :>0: sharpen
 
-``swapuv``
-    Swap U & V plane.
-
 ``pullup[=jl:jr:jt:jb:sb:mp]``
     Pulldown reversal (inverse telecine) filter, capable of handling mixed
     hard-telecine, 24000/1001 fps progressive, and 30000/1001 fps progressive
@@ -553,120 +389,6 @@ Available filters are:
         video. The main purpose of setting ``mp`` to a chroma plane is to reduce
         CPU load and make pullup usable in realtime on slow machines.
 
-``divtc[=options]``
-    Inverse telecine for deinterlaced video. If 3:2-pulldown telecined video
-    has lost one of the fields or is deinterlaced using a method that keeps
-    one field and interpolates the other, the result is a juddering video that
-    has every fourth frame duplicated. This filter is intended to find and
-    drop those duplicates and restore the original film framerate. Two
-    different modes are available: One-pass mode is the default and is
-    straightforward to use, but has the disadvantage that any changes in the
-    telecine phase (lost frames or bad edits) cause momentary judder until the
-    filter can resync again. Two-pass mode avoids this by analyzing the entire
-    video beforehand so it will have forward knowledge about the phase changes
-    and can resync at the exact spot. These passes do *not* correspond to pass
-    one and two of the encoding process. You must run an extra pass using
-    ``divtc`` pass one before the actual encoding throwing the resulting video
-    away. Then use ``divtc`` pass two for the actual encoding. If you use
-    multiple encoder passes, use ``divtc`` pass two for all of them.
-
-    The options are:
-
-    ``pass=1|2``
-        Use two pass mode.
-
-    ``file=<filename>``
-        Set the two pass log filename (default: ``framediff.log``).
-
-    ``threshold=<value>``
-        Set the minimum strength the telecine pattern must have for the filter
-        to believe in it (default: 0.5). This is used to avoid recognizing
-        false pattern from the parts of the video that are very dark or very
-        still.
-
-    ``window=<numframes>``
-        Set the number of past frames to look at when searching for pattern
-        (default: 30). Longer window improves the reliability of the pattern
-        search, but shorter window improves the reaction time to the changes
-        in the telecine phase. This only affects the one-pass mode. The
-        two-pass mode currently uses fixed window that extends to both future
-        and past.
-
-    ``phase=0|1|2|3|4``
-        Sets the initial telecine phase for one pass mode (default: 0). The
-        two-pass mode can see the future, so it is able to use the correct
-        phase from the beginning, but one-pass mode can only guess. It catches
-        the correct phase when it finds it, but this option can be used to fix
-        the possible juddering at the beginning. The first pass of the two
-        pass mode also uses this, so if you save the output from the first
-        pass, you get constant phase result.
-
-    ``deghost=<value>``
-        Set the deghosting threshold (0-255 for one-pass mode, -255-255 for
-        two-pass mode, default 0). If nonzero, deghosting mode is used. This
-        is for video that has been deinterlaced by blending the fields
-        together instead of dropping one of the fields. Deghosting amplifies
-        any compression artifacts in the blended frames, so the parameter
-        value is used as a threshold to exclude those pixels from deghosting
-        that differ from the previous frame less than specified value. If two
-        pass mode is used, then negative value can be used to make the filter
-        analyze the whole video in the beginning of pass-2 to determine
-        whether it needs deghosting or not and then select either zero or the
-        absolute value of the parameter. Specify this option for pass 2, it
-        makes no difference on pass 1.
-
-``phase[=t|b|p|a|u|T|B|A|U][:v]``
-    Delay interlaced video by one field time so that the field order changes.
-    The intended use is to fix PAL videos that have been captured with the
-    opposite field order to the film-to-video transfer. The options are:
-
-    ``t``
-        Capture field order top-first, transfer bottom-first. Filter will
-        delay the bottom field.
-
-    ``b``
-        Capture bottom-first, transfer top-first. Filter will delay the top
-        field.
-
-    ``p``
-        Capture and transfer with the same field order. This mode only exists
-        for the documentation of the other options to refer to, but if you
-        actually select it, the filter will faithfully do nothing ;-)
-
-    ``a``
-        Capture field order determined automatically by field flags, transfer
-        opposite. Filter selects among ``t`` and ``b`` modes on a frame by frame
-        basis using field flags. If no field information is available, then this
-        works just like ``u``.
-
-    ``u``
-        Capture unknown or varying, transfer opposite. Filter selects among
-        ``t`` and ``b`` on a frame by frame basis by analyzing the images and
-        selecting the alternative that produces best match between the fields.
-
-    ``T``
-        Capture top-first, transfer unknown or varying. Filter selects among
-        ``t`` and ``p`` using image analysis.
-
-    ``B``
-        Capture bottom-first, transfer unknown or varying. Filter selects
-        among ``b`` and ``p`` using image analysis.
-
-    ``A``
-        Capture determined by field flags, transfer unknown or varying. Filter
-        selects among ``t``, ``b`` and ``p`` using field flags and image
-        analysis. If no field information is available, then this works just
-        like ``U``. This is the default mode.
-
-    ``U``
-        Both capture and transfer unknown or varying. Filter selects among
-        ``t``, ``b`` and ``p`` using image analysis only.
-
-    ``v``
-        Verbose operation. Prints the selected mode for each frame and the
-        average squared difference between fields for ``t``, ``b``, and ``p``
-        alternatives. (Ignored when libavfilter is used.)
-
 ``yadif=[mode[:enabled=yes|no]]``
     Yet another deinterlacing filter
 
@@ -897,13 +619,64 @@ Available filters are:
         filters work anyway.)
 
     ``concurrent-frames``
-        Number of frames that should be requested in parallel (default: 2). The
+        Number of frames that should be requested in parallel. The
         level of concurrency depends on the filter and how quickly mpv can
         decode video to feed the filter. This value should probably be
         proportional to the number of cores on your machine. Most time,
         making it higher than the number of cores can actually make it
         slower.
 
+        By default, this uses the special value ``auto``, which sets the option
+        to the number of detected logical CPU cores.
+
+    The following variables are defined by mpv:
+
+    ``video_in``
+        The mpv video source as vapoursynth clip. Note that this has no length
+        set, which confuses many filters. Using ``Trim`` on the clip with a
+        high dummy length can turn it into a finite clip.
+
+    ``video_in_dw``, ``video_in_dh``
+        Display size of the video. Can be different from video size if the
+        video does not use square pixels (e.g. DVD).
+
+    ``container_fps``
+        FPS value as reported by file headers. This value can be wrong or
+        completely broken (e.g. 0 or NaN). Even if the value is correct,
+        if another filter changes the real FPS (by dropping or inserting
+        frames), the value of this variable might not be useful. Note that
+        the ``--fps`` command line option overrides this value.
+
+        Useful for some filters which insist on having a FPS.
+
+    ``display_fps``
+        Refresh rate of the current display. Note that this value can be 0.
+
+``vapoursynth-lazy``
+    The same as ``vapoursynth``, but doesn't load Python scripts. Instead, a
+    custom backend using Lua and the raw VapourSynth API is used. The syntax
+    is completely different, and absolutely no conveniencve features are
+    provided. There's no type checking either, and you can trigger crashes.
+
+    .. admonition:: Example:
+
+        ::
+
+            video_out = invoke("morpho", "Open", {clip = video_in})
+
+    The special variable ``video_in`` is the mpv video source, while the
+    special variable ``video_out`` is used to read video from. The 1st argument
+    is the plugin (queried with ``getPluginByNs``), the 2nd is the filter name,
+    and the 3rd argument is a table with the arguments. Positional arguments
+    are not supported. The types must match exactly. Since Lua is terrible and
+    can't distinguish integers and floats, integer arguments must be prefixed
+    with ``i_``, in which case the prefix is removed and the argument is cast
+    to an integer. Should the argument's name start with ``i_``, you're out of
+    luck.
+
+    Clips (VSNodeRef) are passed as light userdata, so trying to pass any
+    other userdata type will result in hard crashes.
+
 ``vavpp``
     VA-AP-API video post processing. Works with ``--vo=vaapi`` and ``--vo=opengl``
     only. Currently deinterlaces. This filter is automatically inserted if
@@ -919,6 +692,10 @@ Available filters are:
             Show only first field (going by ``--field-dominance``).
         bob
             bob deinterlacing (default).
+        weave, motion-adaptive, motion-compensated
+            Advanced deinterlacing algorithms. Whether these actually work
+            depends on the GPU hardware, the GPU drivers, driver bugs, and
+            mpv bugs.
 
 ``vdpaupp``
     VDPAU video post processing. Works with ``--vo=vdpau`` and ``--vo=opengl``

DOCS/man/vo.rst

@@ -233,18 +233,29 @@ Available video output drivers are:
         Always force textures to power of 2, even if the device reports
         non-power-of-2 texture sizes as supported.
 
-    ``texture-memory=N``
+    ``texture-memory=<mode>``
         Only affects operation with shaders/texturing enabled, and (E)OSD.
-        Values for N:
+        Possible values:
 
-            0
-                default, will often use an additional shadow texture + copy
-            1
-                use ``D3DPOOL_MANAGED``
-            2
-                use ``D3DPOOL_DEFAULT``
-            3
-                use ``D3DPOOL_SYSTEMMEM``, but without shadow texture
+        ``default`` (default)
+            Use ``D3DPOOL_DEFAULT``, with a ``D3DPOOL_SYSTEMMEM`` texture for
+            locking. If the driver supports ``D3DDEVCAPS_TEXTURESYSTEMMEMORY``,
+            ``D3DPOOL_SYSTEMMEM`` is used directly.
+
+        ``default-pool``
+            Use ``D3DPOOL_DEFAULT``. (Like ``default``, but never use a
+            shadow-texture.)
+
+        ``default-pool-shadow``
+            Use ``D3DPOOL_DEFAULT``, with a ``D3DPOOL_SYSTEMMEM`` texture for
+            locking. (Like ``default``, but always force the shadow-texture.)
+
+        ``managed``
+            Use ``D3DPOOL_MANAGED``.
+
+        ``scratch``
+            Use ``D3DPOOL_SCRATCH``, with a ``D3DPOOL_SYSTEMMEM`` texture for
+            locking.
 
     ``swap-discard``
         Use ``D3DSWAPEFFECT_DISCARD``, which might be faster.
@@ -259,13 +270,6 @@ Available video output drivers are:
 
     .. note:: This driver is for compatibility with old systems.
 
-``corevideo`` (Mac OS X 10.6 and later)
-    Mac OS X CoreVideo video output driver. Uses the CoreVideo APIs to fill
-    PixelBuffers and generate OpenGL textures from them (useful as a fallback
-    for ``opengl``).
-
-    .. note:: This driver is for compatibility with old systems.
-
 ``opengl``
     OpenGL video output driver. It supports extended scaling methods, dithering
     and color management.
@@ -274,88 +278,88 @@ Available video output drivers are:
     ``opengl-hq`` to use this driver with defaults set to high quality
     rendering.
 
-    Requires at least OpenGL 2.1 and the ``GL_ARB_texture_rg`` extension. For
-    older drivers, ``opengl-old`` may work.
+    Requires at least OpenGL 2.1.
 
     Some features are available with OpenGL 3 capable graphics drivers only
     (or if the necessary extensions are available).
 
+    OpenGL ES 2.0 and 3.0 are supported as well.
+
     Hardware decoding over OpenGL-interop is supported to some degree. Note
     that in this mode, some corner case might not be gracefully handled, and
     color space conversion and chroma upsampling is generally in the hand of
     the hardware decoder APIs.
 
-    ``lscale=<filter>``
+    ``scale=<filter>``
 
         ``bilinear``
-            Bilinear hardware texture filtering (fastest, mid-quality).
-            This is the default.
-
-        ``lanczos2``
-            Lanczos scaling with radius=2. Provides good quality and speed.
-
-        ``lanczos3``
-            Lanczos with radius=3.
+            Bilinear hardware texture filtering (fastest, very low quality).
+            This is the default for compatibility reasons.
 
         ``spline36``
-            This is the default when using ``opengl-hq``.
+            Mid quality and speed. This is the default when using ``opengl-hq``.
 
-        ``bicubic_fast``
-            Bicubic filter. Has a blurring effect on the image, even if no
-            scaling is done.
+        ``lanczos``
+            Lanczos scaling. Provides mid quality and speed. Generally worse
+            than ``spline36``, but it results in a slightly sharper image
+            which is good for some content types. The number of taps can be
+            controlled with ``scale-radius``, but is best left unchanged.
 
-        ``sharpen3``
-            Unsharp masking (sharpening) with radius=3 and a default strength
-            of 0.5 (see ``lparam1``).
+            This filter corresponds to the old ``lanczos3`` alias if the default
+            radius is used, while ``lanczos2`` corresponds to a radius of 2.
 
-        ``sharpen5``
-            Unsharp masking (sharpening) with radius=5 and a default strength
-            of 0.5 (see ``lparam1``).
+        ``ewa_lanczos``
+            Elliptic weighted average Lanczos scaling. Also known as Jinc.
+            Relatively slow, but very good quality. The number of taps can
+            be controlled with ``scale-radius``. Adding extra taps makes the
+            filter sharper but adds more ringing.
+
+            This filter supports antiringing (see ``scale-antiring``).
 
         ``mitchell``
             Mitchell-Netravali. The ``b`` and ``c`` parameters can be set with
-            ``lparam1`` and ``lparam2``. Both are set to 1/3 by default.
+            ``scale-param1`` and ``scale-param2``. Both are set to 1/3 by default.
+            This filter is very good at downscaling (see ``scale-down``).
 
+        There are some more filters, but most are not as useful. For a complete
+        list, pass ``help`` as value, e.g.::
 
-        There are some more filters. For a complete list, pass ``help`` as
-        value, e.g.::
+            mpv --vo=opengl:scale=help
 
-            mpv --vo=opengl:lscale=help
-
-    ``lparam1=<value>``
+    ``scale-param1=<value>``
         Set filter parameters. Ignored if the filter is not tunable. These are
         unset by default, and use the filter specific default if applicable.
 
-    ``lparam2=<value>``
-        See ``lparam1``.
+    ``scale-param2=<value>``
+        See ``scale-param1``.
+
+    ``scale-radius=<r>``
+        Set radius for filters listed below, must be a float number between 1.0
+        and 16.0. Defaults to be 3.0 if not specified.
+
+            ``sinc``, ``lanczos``, ``ewa_lanczos``, ``blackman``, ``gaussian``
+
+        Note that depending on filter implementation details and video scaling
+        ratio, the radius that actually being used might be different
+        (most likely being increased a bit).
+
+    ``scale-antiring=<value>``
+        Set the antiringing strength. This tries to eliminate ringing, but can
+        introduce other artifacts in the process. Must be a float number
+        between 0.0 and 1.0. The default value of 0.0 disables antiringing
+        entirely.
+
+        Note that this currently only affects ``ewa_lanczos``.
 
     ``scaler-resizes-only``
         Disable the scaler if the video image is not resized. In that case,
-        ``bilinear`` is used instead whatever is set with ``lscale``. Bilinear
+        ``bilinear`` is used instead whatever is set with ``scale``. Bilinear
         will reproduce the source image perfectly if no scaling is performed.
-        Note that this option never affects ``cscale``, although the different
-        processing chain might do chroma scaling differently if ``lscale`` is
-        disabled.
-
-    ``stereo=<value>``
-        Select a method for stereo display. You may have to use
-        ``--video-aspect`` to fix the aspect value. Experimental, do not expect
-        too much from it.
-
-        no
-            Normal 2D display
-        red-cyan
-            Convert side by side input to full-color red-cyan stereo.
-        green-magenta
-            Convert side by side input to full-color green-magenta stereo.
-        quadbuffer
-            Convert side by side input to quad buffered stereo. Only supported
-            by very few OpenGL cards.
+        Note that this option never affects ``cscale``.
 
     ``srgb``
         Convert and color correct the output to sRGB before displaying it on
-        the screen. This option enables linear light scaling. It also forces
-        the options ``indirect`` and ``gamma``.
+        the screen. This option enables ``linear-scaling``.
 
         This option is equivalent to using ``icc-profile`` with an sRGB ICC
         profile, but it is implemented without a 3DLUT and does not require
@@ -398,7 +402,8 @@ Available video output drivers are:
         Used in ``dither=fruit`` mode only.
 
     ``dither=<fruit|ordered|no>``
-        Select dithering algorithm (default: fruit).
+        Select dithering algorithm (default: fruit). (Normally, the
+        ``dither-depth`` option controls whether dithering is enabled.)
 
     ``temporal-dither``
         Enable temporal dithering. (Only active if dithering is enabled in
@@ -414,32 +419,67 @@ Available video output drivers are:
 
     ``swapinterval=<n>``
         Interval in displayed frames between two buffer swaps.
-        1 is equivalent to enable VSYNC, 0 to disable VSYNC.
+        1 is equivalent to enable VSYNC, 0 to disable VSYNC. Defaults to 1 if
+        not specified.
 
-    ``no-scale-sep``
-        When using a separable scale filter for luma, usually two filter
-        passes are done. This is often faster. However, it forces
-        conversion to RGB in an extra pass, so it can actually be slower
-        if used with fast filters on small screen resolutions. Using
-        this options will make rendering a single operation.
-        Note that chroma scalers are always done as 1-pass filters.
+    ``cscale=<filter>``
+        As ``scale``, but for interpolating chroma information. If the image
+        is not subsampled, this option is ignored entirely. Note that the
+        implementation is currently always done as a single pass, so using
+        it with separable filters will result in slow performance for very
+        little visible benefit.
 
-    ``cscale=<n>``
-        As ``lscale``, but for chroma (2x slower with little visible effect).
-        Note that with some scaling filters, upscaling is always done in
-        RGB. If chroma is not subsampled, this option is ignored, and the
-        luma scaler is used instead. Setting this option is often useless.
+    ``scale-down=<filter>``
+        Like ``scale``, but apply these filters on downscaling instead. If this
+        option is unset, the filter implied by ``scale`` will be applied.
+
+    ``cscale-param1``, ``cscale-param2``, ``cscale-radius``, ``cscale-antiring``
+        Set filter parameters and radius for ``cscale``.
+
+        See ``scale-param1``, ``scale-param2``, ``scale-radius`` and
+        ``scale-antiring``.
+
+    ``linear-scaling``
+        Scale in linear light. This is automatically enabled if ``srgb``,
+        ``icc-profile`` or ``sigmoid-upscaling`` is set. It should only
+        be used with a ``fbo-format`` that has at least 16 bit precision.
 
     ``fancy-downscaling``
         When using convolution based filters, extend the filter size
         when downscaling. Trades quality for reduced downscaling performance.
 
+        This is automatically disabled for anamorphic video, because this
+        feature doesn't work correctly with different scale factors in
+        different directions.
+
+    ``sigmoid-upscaling``
+        When upscaling, use a sigmoidal color transform to avoid emphasizing
+        ringing artifacts. This also enables ``linear-scaling``.
+
+    ``sigmoid-center``
+        The center of the sigmoid curve used for ``sigmoid-upscaling``, must
+        be a float between 0.0 and 1.0. Defaults to 0.75 if not specified.
+
+    ``sigmoid-slope``
+        The slope of the sigmoid curve used for ``sigmoid-upscaling``, must
+        be a float between 1.0 and 20.0. Defaults to 6.5 if not specified.
+
     ``no-npot``
         Force use of power-of-2 texture sizes. For debugging only.
         Borders will be distorted due to filtering.
 
     ``glfinish``
-        Call ``glFinish()`` before swapping buffers
+        Call ``glFinish()`` before and after swapping buffers (default: disabled).
+        Slower, but might help getting better results when doing framedropping.
+        Can completely ruin performance. The details depend entirely on the
+        OpenGL driver.
+
+    ``waitvsync``
+        Call ``glXWaitVideoSyncSGI`` after each buffer swap (default: disabled).
+        This may or may not help with video timing accuracy and frame drop. It's
+        possible that this makes video output slower, or has no effect at all.
+
+        X11/GLX only.
 
     ``sw``
         Continue even if a software renderer is detected.
@@ -455,19 +495,12 @@ Available video output drivers are:
             Cocoa/OS X
         win
             Win32/WGL
-        x11
-            X11/GLX
+        x11, x11es
+            X11/GLX (the ``es`` variant forces GLES)
         wayland
             Wayland/EGL
-
-    ``indirect``
-        Do YUV conversion and scaling as separate passes. This will first render
-        the video into a video-sized RGB texture, and draw the result on screen.
-        The luma scaler is used to scale the RGB image when rendering to screen.
-        The chroma scaler is used only on YUV conversion, and only if the video
-        is chroma-subsampled (usually the case).
-        This mechanism is disabled on RGB input.
-        Specifying this option directly is generally useful for debugging only.
+        x11egl, x11egles
+            X11/EGL (the ``es`` variant forces GLES)
 
     ``fbo-format=<fmt>``
         Selects the internal format of textures used for FBOs. The format can
@@ -475,28 +508,34 @@ Available video output drivers are:
         always used, and typically only when using extended scalers.)
         ``fmt`` can be one of: rgb, rgba, rgb8, rgb10, rgb10_a2, rgb16, rgb16f,
         rgb32f, rgba12, rgba16, rgba16f, rgba32f.
-        Default: rgb.
+        Default: rgba.
 
-    ``gamma=<0.0..10.0>``
-        Set a gamma value. If gamma is adjusted in other ways (like with
-        the ``--gamma`` option or key bindings and the ``gamma`` property), the
-        value is multiplied with the other gamma value.
+    ``gamma=<0.1..2.0>``
+        Set a gamma value (default: 1.0). If gamma is adjusted in other ways
+        (like with the ``--gamma`` option or key bindings and the ``gamma``
+        property), the value is multiplied with the other gamma value.
 
-        Setting this value to 1.0 can be used to always enable gamma control.
-        (Disables delayed enabling.)
+        Recommended values based on the environmental brightness:
+
+        1.0
+            Brightly illuminated (default)
+        0.9
+            Slightly dim
+        0.8
+            Pitch black room
 
     ``icc-profile=<file>``
         Load an ICC profile and use it to transform linear RGB to screen output.
         Needs LittleCMS 2 support compiled in. This option overrides the ``srgb``
-        property, as using both is somewhat redundant. It also enables linear
-        light scaling.
+        property, as using both is somewhat redundant. It also enables
+        ``linear-scaling``.
 
 
     ``icc-profile-auto``
         Automatically select the ICC display profile currently specified by
         the display settings of the operating system.
 
-        NOTE: Only implemented on OS X with Cocoa.
+        NOTE: Only implemented on OS X and X11
 
     ``icc-cache=<file>``
         Store and load the 3D LUT created from the ICC profile in this file.
@@ -518,16 +557,6 @@ Available video output drivers are:
         3
             absolute colorimetric
 
-    ``approx-gamma``
-        Approximate the actual gamma function as a pure power curve of
-        1.95. A number of video editing programs and studios apparently use this
-        for mastering instead of the true curve. Most notably, anything in the
-        Apple ecosystem uses this approximation - including all programs
-        compatible with it. It's a sound idea to try enabling this flag first
-        when watching videos and shows to see if things look better that way.
-
-        This only affects the output when using either ``icc-profile`` or ``srgb``.
-
     ``3dlut-size=<r>x<g>x<b>``
         Size of the 3D LUT generated from the ICC profile in each dimension.
         Default is 128x256x64.
@@ -543,8 +572,8 @@ Available video output drivers are:
             if the video contains alpha information (which is extremely rare). May
             not be supported on all platforms. If alpha framebuffers are
             unavailable, it silently falls back on a normal framebuffer. Note
-            that when using FBO indirections (such as with ``opengl-hq``), an FBO
-            format with alpha must be specified with the ``fbo-format`` option.
+            that if you set the ``fbo-format`` option to a non-default value,
+            a format with alpha must be specified, or this won't work.
         no
             Ignore alpha component.
 
@@ -557,12 +586,58 @@ Available video output drivers are:
         have any advantages over normal textures. Note that hardware decoding
         overrides this flag.
 
+    ``background=<color>``
+        Color used to draw parts of the mpv window not covered by video.
+        See ``--osd-color`` option how colors are defined.
+
+    ``smoothmotion``
+        Reduce stuttering caused by mismatches in video fps and display
+        refresh rate (also known as judder).
+
+        Instead of drawing source frames for variable durations, smoothmotion
+        will blend frames that overlap the transition between two frames in
+        the source material.
+
+        For example, a 24 Hz clip played back on a 60 Hz display would normally
+        result in a pattern like this::
+
+            A A A B B C C C D D E E E F F
+
+        which has different lengths, alternating between 3 and 2. This
+        difference in frame duration is what causes judder.
+
+        With smoothmotion enabled, the pattern changes to::
+
+            A A A+B B B C C C+D D D E E E+F F F
+
+        where A+B is a blend of A and B. In this pattern, each frame gets a
+        (consistent) duration of roughly 2.5 - resulting in smooth motion.
+
+        GPU drivers or compositing window managers overriding vsync behavior
+        can lead to bad results. If the framerate is close to or over the
+        display refresh rate, results can be bad as well.
+
+        .. note:: On systems other than Linux or OS X, you currently must set
+                  the ``--display-fps`` option, or the results will be bad.
+
+    ``smoothmotion-threshold=<0.0-0.5>``
+        Mix threshold at which interpolation is skipped (default: 0.0 – never
+        skip).
+
+        For example, with a ``smoothmotion-threshold`` of 0.1, if the
+        smoothmotion algorithm would try to blend two frames by a ratio of
+        95% A + 5% B, it would simply display A instead. (Since the
+        distance, 0.05, is lower than the threshold)
+
+        Setting this to 0.5 would be similar to disabling smoothmotion
+        completely, since it would always just display the nearest frame.
+
 ``opengl-hq``
     Same as ``opengl``, but with default settings for high quality rendering.
 
     This is equivalent to::
 
-        --vo=opengl:lscale=spline36:dither-depth=auto:fbo-format=rgba16
+        --vo=opengl:scale=spline36:scale-down=mitchell:dither-depth=auto:fbo-format=rgba16:fancy-downscaling:sigmoid-upscaling
 
     Note that some cheaper LCDs do dithering that gravely interferes with
     ``opengl``'s dithering. Disabling dithering with ``dither-depth=no`` helps.
@@ -574,188 +649,6 @@ Available video output drivers are:
     float texture support, and some OS X setups being very slow with ``rgb16``
     but fast with ``rgb32f``.
 
-``opengl-old``
-    OpenGL video output driver, old version. Video size must be smaller
-    than the maximum texture size of your OpenGL implementation. Intended to
-    work even with the most basic OpenGL implementations, but also makes use
-    of newer extensions which allow support for more color spaces.
-
-    The code performs very few checks, so if a feature does not work, this
-    might be because it is not supported by your card and/or OpenGL
-    implementation, even if you do not get any error message. Use ``glxinfo``
-    or a similar tool to display the supported OpenGL extensions.
-
-    .. note:: This driver is for compatibility with old systems.
-
-    ``(no-)ati-hack``
-        ATI drivers may give a corrupted image when PBOs are used (when using
-        ``force-pbo``). This option fixes this, at the expense of using a bit
-        more memory.
-    ``(no-)force-pbo``
-        Always uses PBOs to transfer textures even if this involves an extra
-        copy. Currently this gives a little extra speed with NVIDIA drivers
-        and a lot more speed with ATI drivers. May need the ``ati-hack``
-        suboption to work correctly.
-    ``(no-)scaled-osd``
-        Scales the OSD and subtitles instead of rendering them at display size
-        (default: disabled).
-    ``rectangle=<0,1,2>``
-        Select usage of rectangular textures, which saves video RAM, but often
-        is slower (default: 0).
-
-        0
-            Use power-of-two textures (default).
-        1
-            Use the ``GL_ARB_texture_rectangle`` extension.
-        2
-            Use the ``GL_ARB_texture_non_power_of_two`` extension. In some
-            cases only supported in software and thus very slow.
-
-    ``swapinterval=<n>``
-        Minimum interval between two buffer swaps, counted in displayed frames
-        (default: 1). 1 is equivalent to enabling VSYNC, 0 to disabling VSYNC.
-        Values below 0 will leave it at the system default. This limits the
-        framerate to (horizontal refresh rate / n). Requires
-        ``GLX_SGI_swap_control`` support to work. With some (most/all?)
-        implementations this only works in fullscreen mode.
-    ``ycbcr``
-        Use the ``GL_MESA_ycbcr_texture`` extension to convert YUV to RGB. In
-        most cases this is probably slower than doing software conversion to
-        RGB.
-    ``yuv=<n>``
-        Select the type of YUV to RGB conversion. The default is
-        auto-detection deciding between values 0 and 2.
-
-        0
-            Use software conversion. Compatible with all OpenGL versions.
-            Provides brightness, contrast and saturation control.
-        1
-            Same as 2. This used to use NVIDIA-specific extensions, which
-            did not provide any advantages over using fragment programs, except
-            possibly on very ancient graphics cards. It produced a gray-ish
-            output, which is why it has been removed.
-        2
-            Use a fragment program. Needs the ``GL_ARB_fragment_program``
-            extension and at least three texture units. Provides brightness,
-            contrast, saturation and hue control.
-        3
-            Use a fragment program using the ``POW`` instruction. Needs the
-            ``GL_ARB_fragment_program`` extension and at least three texture
-            units. Provides brightness, contrast, saturation, hue and gamma
-            control. Gamma can also be set independently for red, green and
-            blue. Method 4 is usually faster.
-        4
-            Use a fragment program with additional lookup. Needs the
-            ``GL_ARB_fragment_program`` extension and at least four texture
-            units. Provides brightness, contrast, saturation, hue and gamma
-            control. Gamma can also be set independently for red, green and
-            blue.
-        5
-            Use ATI-specific method (for older cards). This uses an
-            ATI-specific extension (``GL_ATI_fragment_shader`` - not
-            ``GL_ARB_fragment_shader``!). At least three texture units are
-            needed. Provides saturation and hue control. This method is fast
-            but inexact.
-        6
-            Use a 3D texture to do conversion via lookup. Needs the
-            ``GL_ARB_fragment_program extension`` and at least four texture
-            units. Extremely slow (software emulation) on some (all?) ATI
-            cards since it uses a texture with border pixels. Provides
-            brightness, contrast, saturation, hue and gamma control. Gamma can
-            also be set independently for red, green and blue. Speed depends
-            more on GPU memory bandwidth than other methods.
-
-    ``lscale=<n>``
-        Select the scaling function to use for luminance scaling. Only valid
-        for yuv modes 2, 3, 4 and 6.
-
-        0
-            Use simple linear filtering (default).
-        1
-            Use bicubic B-spline filtering (better quality). Needs one
-            additional texture unit. Older cards will not be able to handle
-            this for chroma at least in fullscreen mode.
-        2
-            Use cubic filtering in horizontal, linear filtering in vertical
-            direction. Works on a few more cards than method 1.
-        3
-            Same as 1 but does not use a lookup texture. Might be faster on
-            some cards.
-        4
-            Use experimental unsharp masking with 3x3 support and a default
-            strength of 0.5 (see ``filter-strength``).
-        5
-            Use experimental unsharp masking with 5x5 support and a default
-            strength of 0.5 (see ``filter-strength``).
-
-    ``cscale=<n>``
-        Select the scaling function to use for chrominance scaling. For
-        details see ``lscale``.
-    ``filter-strength=<value>``
-        Set the effect strength for the ``lscale``/``cscale`` filters that
-        support it.
-    ``stereo=<value>``
-        Select a method for stereo display. You may have to use
-        ``--video-aspect`` to fix the aspect value. Experimental, do not expect
-        too much from it.
-
-        0
-            Normal 2D display
-        1
-            Convert side by side input to full-color red-cyan stereo.
-        2
-            Convert side by side input to full-color green-magenta stereo.
-        3
-            Convert side by side input to quad buffered stereo. Only supported
-            by very few OpenGL cards.
-
-    The following options are only useful if writing your own fragment programs.
-
-    ``customprog=<filename>``
-        Load a custom fragment program from ``<filename>``.
-    ``customtex=<filename>``
-        Load a custom "gamma ramp" texture from ``<filename>``. This can be used
-        in combination with ``yuv=4`` or with the ``customprog`` option.
-    ``(no-)customtlin``
-        If enabled (default) use ``GL_LINEAR`` interpolation, otherwise use
-        ``GL_NEAREST`` for customtex texture.
-    ``(no-)customtrect``
-        If enabled, use ``texture_rectangle`` for the ``customtex`` texture.
-        Default is disabled.
-    ``(no-)mipmapgen``
-        If enabled, mipmaps for the video are automatically generated. This
-        should be useful together with the ``customprog`` and the ``TXB``
-        instruction to implement blur filters with a large radius. For most
-        OpenGL implementations, this is very slow for any non-RGB formats.
-        Default is disabled.
-
-    Normally there is no reason to use the following options; they mostly
-    exist for testing purposes.
-
-    ``(no-)glfinish``
-        Call ``glFinish()`` before swapping buffers. Slower but in some cases
-        more correct output (default: disabled).
-    ``(no-)manyfmts``
-        Enables support for more (RGB and BGR) color formats (default: enabled).
-        Needs OpenGL version >= 1.2.
-    ``slice-height=<0-...>``
-        Number of lines copied to texture in one piece (default: 0). 0 for
-        whole image.
-    ``sw``
-        Continue even if a software renderer is detected.
-
-    ``backend=<sys>``
-        auto
-            auto-select (default)
-        cocoa
-            Cocoa/OS X
-        win
-            Win32/WGL
-        x11
-            X11/GLX
-        wayland
-            Wayland/EGL
-
 ``sdl``
     SDL 2.0+ Render video output driver, depending on system with or without
     hardware acceleration. Should work on all platforms supported by SDL 2.0.
@@ -880,3 +773,30 @@ Available video output drivers are:
         Use 3 buffers instead of 2. This can lead to more fluid playback, but
         uses more memory.
 
+``opengl-cb``
+    For use with libmpv direct OpenGL embedding; useless in any other contexts.
+    (See ``<mpv/opengl_cb.h>``.)
+    Usually, ``opengl-cb`` renders frames asynchronously by client and this
+    can cause some frame drops. In order to provide a way to handle this
+    situation, ``opengl-cb`` has its own frame queue and calls update callback
+    more frequently if the queue is not empty regardless of existence of new frame.
+    Once the queue is filled, ``opengl-cb`` drops frames automatically.
+
+    With default options, ``opengl-cb`` renders only the latest frame and drops
+    all frames handed over while waiting render function after update callback.
+
+    ``frame-queue-size=<1..100>``
+        The maximum count of frames which the frame queue can hold (default: 1)
+
+    ``frame-drop-mode=<pop|clear>``
+        Select the behavior when the frame queue is full.
+
+        pop
+            Drop the oldest frame in the frame queue. (default)
+        clear
+            Drop all frames in the frame queue.
+
+    This also supports many of the suboptions the ``opengl`` VO has. Runs
+    ``mpv --vo=opengl-cb:help`` for a list.
+
+    This also supports the ``vo_cmdline`` command.

DOCS/mplayer-changes.rst

@@ -0,0 +1,443 @@
+CHANGES FROM OTHER VERSIONS OF MPLAYER
+======================================
+
+**mpv** is based on mplayer2, which in turn is based on the original MPlayer
+(also called mplayer, mplayer-svn, mplayer1). Many changes have been made, a
+large part of which is incompatible or completely changes how the player
+behaves. Although there are still many similarities to its ancestors, **mpv**
+should generally be treated as a completely different program.
+
+.. note::
+    These lists are incomplete.
+
+General Changes from MPlayer to mpv
+-----------------------------------
+
+This listing is about changes introduced by mplayer2 and mpv relatively to
+MPlayer.
+
+Player
+~~~~~~
+
+* New name for the binary (``mpv``). New location for config files (either
+  ``~/.config/mpv/mpv.conf``, or if you want, ``~/.mpv/config``).
+* Encoding functionality (replacement for MEncoder, see the `ENCODING`_ section).
+* Support for Lua scripting (see the `LUA SCRIPTING`_ section).
+* Better pause handling (e.g. do not unpause on a command).
+* Precise seeking support.
+* Improvements in audio/video sync handling.
+* Do not lose settings when playing a new file in the same player instance.
+* Slave mode compatibility broken (see below).
+* Re-enable screensaver while the player is paused.
+* Allow resuming playback at a later point with ``Shift+q``, also see the
+  ``quit_watch_later`` input command.
+* ``--keep-open`` option to stop the player from closing the window and
+  exiting after playback ends.
+* A client API, that allows embedding **mpv** into applications
+  (see ``libmpv/client.h`` in the sources).
+
+Input
+~~~~~
+
+* Improved default keybindings. MPlayer bindings are also available (see
+  ``etc/mplayer-input.conf`` in the source tree).
+* Improved responsiveness on user input.
+* Support for modifier keys (alt, shift, ctrl) in input.conf.
+* Allow customizing whether a key binding for seeking shows the video time, the
+  OSD bar, or nothing (see the `Input Command Prefixes`_ section).
+* Support mapping multiple commands to one key.
+
+Audio
+~~~~~
+
+* Support for gapless audio (see the ``--gapless-audio`` option).
+* Support for OSS4 volume control.
+* Improved support for PulseAudio.
+* Make ``--softvol`` default (**mpv** is not a mixer control panel).
+* By default, do pitch correction if playback speed is increased.
+* Improved downmixing and output of surround audio:
+
+  - Instead of using hardcoded pan filters to do remixing, libavresample is used
+  - Channel maps are used to identify the channel layout, so e.g. ``3.0`` and
+    ``2.1`` audio can be distinguished.
+
+Video
+~~~~~
+
+* Wayland support.
+* Native support for VAAPI and VDA. Improved VDPAU video output.
+* Improved OpenGL output (see the ``opengl-hq`` video output).
+* Make hardware decoding work with the ``opengl`` video output.
+* Support for libavfilter (for video->video and audio->audio). This allows
+  using most of FFmpeg's filters, which improve greatly on the old MPlayer
+  filters in features, performance, and correctness.
+* More correct color reproduction (color matrix generation), including support
+  for BT.2020 (Ultra HD) and linear XYZ (Digital Cinema) inputs.
+* Support for color managed displays, via ICC profiles.
+* High-quality image resamplers (see the ``opengl`` ``scale`` suboption).
+* Support for scaling in (sigmoidized) linear light.
+* Better subtitle rendering using libass by default.
+* Improvements when playing multiple files (``-fixed-vo`` is default, do not
+  reset settings by default when playing a new file).
+* Replace image video outputs (``--vo=jpeg`` etc.) with ``--vo=image``.
+* Removal of ``--vo=gif89a``, ``--vo=md5sum``, ``--vo=yuv4mpeg``, as encoding
+  can handle these use cases. For yuv4mpeg, for example, use::
+
+    mpv input.mkv -o output.y4m --no-audio --oautofps --oneverdrop
+
+* Image subtitles (DVDs etc.) are rendered in color and use more correct
+  positioning (color for image subs can be disabled with ``--sub-gray``).
+
+OSD and terminal
+~~~~~~~~~~~~~~~~
+
+* Cleaned up terminal output: nicer status line, less useless noise.
+* Improved OSD rendering using libass, with full Unicode support.
+* New OSD bar with chapter marks. Not positioned in the middle of the video
+  (this can be customized with the ``--osd-bar-align-y`` option).
+* Display list of chapters and audio/subtitle tracks on OSD (see the
+  `Properties`_ section).
+
+Screenshots
+~~~~~~~~~~~
+
+* Instant screenshots without 1-frame delay.
+* Support for taking screenshots even with hardware decoding.
+* Support for saving screenshots as JPEG or PNG.
+* Support for configurable file names.
+* Support for taking screenshots with or without subtitles.
+
+Note that the ``screenshot`` video filter is not needed anymore, and should not
+be put into the mpv config file.
+
+Miscellaneous
+~~~~~~~~~~~~~
+
+* Better MKV support (e.g. ordered chapters, 3D metadata).
+* Matroska edition switching at runtime.
+* Support for playing URLs of popular streaming sites directly.
+  (e.g. ``mpv https://www.youtube.com/watch?v=...``).
+  Requires a recent version of ``youtube-dl`` to be installed. Can be
+  disabled with ``ytdl=no`` in the mpv config file.
+* Support for precise scrolling which scales the parameter of commands. If the
+  input doesn't support precise scrolling the scale factor stays 1.
+* Allow changing/adjusting video filters at runtime. (This is also used to make
+  the ``D`` key insert vf_yadif if deinterlacing is not supported otherwise).
+* Improved support for .cue files.
+
+Mac OS X
+~~~~~~~~
+
+* Native OpenGL backend.
+* Cocoa event loop is independent from MPlayer's event loop, so user
+  actions like accessing menus and live resizing do not block the playback.
+* Apple Remote support.
+* Media Keys support.
+* VDA support using libavcodec hwaccel API instead of FFmpeg's decoder with up
+  to 2-2.5x reduction in CPU usage.
+
+Windows
+~~~~~~~
+
+* Improved support for Unicode file names.
+* Improved window handling.
+* Do not block playback when moving the window.
+* Improved Direct3D video output.
+* Added WASAPI audio output.
+
+Internal changes
+~~~~~~~~~~~~~~~~
+
+* Switch to GPLv2+ (see ``Copyright`` file for details).
+* Removal of lots of cruft:
+
+  - Internal GUI (replaced by the OSC, see the `ON SCREEN CONTROLLER`_ section).
+  - MEncoder (replaced by native encoding, see the `ENCODING`_ section).
+  - OSD menu.
+  - Kernel video drivers for Linux 2.4 (including VIDIX).
+  - Teletext support.
+  - Support for dead platforms.
+  - Most built-in demuxers have been replaced by their libavformat counterparts.
+  - Built-in network support has been replaced by libavformat's (which also
+    supports https URLs).
+  - Embedded copies of libraries (such as FFmpeg).
+
+* General code cleanups (including refactoring or rewrites of many parts).
+* New build system.
+* Many bug fixes and removal of long-standing issues.
+* Generally preferring FFmpeg/Libav over internal demuxers, decoders, and
+  filters.
+
+Detailed Listing of User-visible Changes
+----------------------------------------
+
+This listing is about changed command line switches, slave commands, and similar
+things. Completely removed features are not listed.
+
+Command Line Switches
+~~~~~~~~~~~~~~~~~~~~~
+
+* There is a new command line syntax, which is generally preferred over the old
+  syntax. ``-optname optvalue`` becomes ``--optname=optvalue``.
+
+  The old syntax will not be removed. However, the new syntax is mentioned in
+  all documentation and so on, and unlike the old syntax is not ambiguous,
+  so it is a good thing to know about this change.
+* In general, negating switches like ``-noopt`` now have to be written as
+  ``-no-opt`` or ``--no-opt``.
+* Per-file options are not the default anymore. You can explicitly specify
+  file-local options. See ``Usage`` section.
+* Many options have been renamed, removed or changed semantics. Some options
+  that are required for a good playback experience with MPlayer are now
+  superfluous or even worse than the defaults, so make sure to read the manual
+  before trying to use your existing configuration with **mpv**.
+* Table of renamed/replaced switches:
+
+    =========================== ========================================
+    Old                         New
+    =========================== ========================================
+    ``-no<opt>``                ``--no-<opt>`` (add a dash)
+    ``-a52drc level``           ``--ad-lavc-ac3drc=level``
+    ``-ac spdifac3``            ``--ad=spdif:ac3`` (see ``--ad=help``)
+    ``-af volnorm``             ``--af=drc`` (renamed)
+    ``-afm hwac3``              ``--ad=spdif:ac3,spdif:dts``
+    ``-ao alsa:device=hw=0.3``  ``--ao=alsa:device=[hw:0,3]``
+    ``-aspect``                 ``--video-aspect``
+    ``-ass-bottom-margin``      ``--vf=sub=bottom:top``
+    ``-ass``                    ``--sub-ass``
+    ``-audiofile-cache``        (removed; the main cache settings are used)
+    ``-audiofile``              ``--audio-file``
+    ``-benchmark``              ``--untimed`` (no stats)
+    ``-capture``                ``--stream-capture=<filename>``
+    ``-channels``               ``--audio-channels`` (changed semantics)
+    ``-cursor-autohide-delay``  ``--cursor-autohide``
+    ``-delay``                  ``--audio-delay``
+    ``-dumpstream``             ``--stream-dump=<filename>``
+    ``-dvdangle``               ``--dvd-angle``
+    ``-endpos``                 ``--length``
+    ``-fixed-vo``               (removed; always the default)
+    ``-font``                   ``--osd-font``
+    ``-forcedsubsonly``         ``--sub-forced-only``
+    ``-forceidx``               ``--index``
+    ``-format``                 ``--audio-format``
+    ``-fsmode-dontuse``         (removed)
+    ``-fstype``                 ``--x11-netwm`` (changed semantics)
+    ``-hardframedrop``          ``--framedrop=hard``
+    ``-identify``               (removed; use TOOLS/mpv_identify.sh)
+    ``-idx``                    ``--index``
+    ``-lavdopts ...``           ``--vd-lavc-...``
+    ``-lavfdopts``              ``--demuxer-lavf-...``
+    ``-lircconf``               ``--input-lirc-conf``
+    ``-loop 0``                 ``--loop=inf``
+    ``-mixer-channel``          AO suboptions (``alsa``, ``oss``)
+    ``-mixer``                  AO suboptions (``alsa``, ``oss``)
+    ``-mouse-movements``        ``--input-cursor``
+    ``-msgcolor``               ``--msg-color``
+    ``-msglevel``               ``--msg-level`` (changed semantics)
+    ``-msgmodule``              ``--msg-module``
+    ``-name``                   ``--x11-name``
+    ``-noar``                   ``--no-input-appleremote``
+    ``-noautosub``              ``--no-sub-auto``
+    ``-noconsolecontrols``      ``--no-input-terminal``
+    ``-nojoystick``             ``--no-input-joystick``
+    ``-nosound``                ``--no-audio``
+    ``-osdlevel``               ``--osd-level``
+    ``-panscanrange``           ``--video-zoom``, ``--video-pan-x/y``
+    ``-playing-msg``            ``--term-playing-msg``
+    ``-pp ...``                 ``'--vf=lavfi=[pp=...]'``
+    ``-pphelp``                 (See FFmpeg libavfilter documentation.)
+    ``-rawaudio ...``           ``--demuxer-rawaudio-...``
+    ``-rawvideo ...``           ``--demuxer-rawvideo-...``
+    ``-spugauss``               ``--sub-gauss``
+    ``-srate``                  ``--audio-samplerate``
+    ``-ss``                     ``--start``
+    ``-ssf <sub>``              ``--sws-...``
+    ``-stop-xscreensaver``      ``--stop-screensaver``
+    ``-sub-fuzziness``          ``--sub-auto``
+    ``-sub``                    ``--sub-file``
+    ``-subcp``                  ``--sub-codepage``
+    ``-subdelay``               ``--sub-delay``
+    ``-subfile``                ``--sub-file``
+    ``-subfont-*``              ``--sub-text-*``, ``--osd-*``
+    ``-subfont-text-scale``     ``--sub-scale``
+    ``-subfont``                ``--sub-text-font``
+    ``-subfps``                 ``--sub-fps``
+    ``-subpos``                 ``--sub-pos``
+    ``-sws``                    ``--sws-scaler``
+    ``-tvscan``                 ``--tv-scan``
+    ``-use-filename-title``     ``--title='${filename}'``
+    ``-vc ffh264vdpau`` (etc.)  ``--hwdec=vdpau``
+    ``-vobsub``                 ``--sub-file`` (pass the .idx file)
+    ``-x W``, ``-y H``          ``--geometry=WxH`` + ``--no-keepaspect``
+    ``-xineramascreen``         ``--screen`` (different values)
+    ``-xy W``                   ``--autofit=W``
+    ``-zoom``                   Inverse available as ``--video-unscaled``
+    ``dvdnav://``               ``dvdnav://menu``
+    ``dvd://1``                 ``dvd://0`` (0-based offset)
+    =========================== ========================================
+
+.. note::
+
+    ``-opt val`` becomes ``--opt=val``.
+
+.. note::
+
+    Quite some video filters, video outputs, audio filters, audio outputs, had
+    changes in their option parsing. These aren't mentioned in the table above.
+
+    Also, some video and audio filters have been removed, and you have to use
+    libavfilter (using ``--vf=lavfi=[...]`` or ``--af=lavfi=[...]``) to get
+    them back.
+
+input.conf and Slave Commands
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+* Table of renamed input commands:
+
+    This lists only commands that are not always gracefully handled by the
+    internal legacy translation layer. If an input.conf contains any legacy
+    commands, a warning will be printed when starting the player. The warnings
+    also show the replacement commands.
+
+    Properties containing ``_`` to separate words use ``-`` instead.
+
+    +--------------------------------+----------------------------------------+
+    | Old                            | New                                    |
+    +================================+========================================+
+    | ``pt_step 1 [0|1]``            | ``playlist_next [weak|force]``         |
+    |                                | (translation layer cannot deal with    |
+    |                                | whitespace)                            |
+    +--------------------------------+----------------------------------------+
+    | ``pt_step -1 [0|1]``           | ``playlist_prev [weak|force] (same)``  |
+    +--------------------------------+----------------------------------------+
+    | ``switch_ratio [<ratio>]``     | ``set video-aspect <ratio>``           |
+    |                                |                                        |
+    |                                | ``set video-aspect 0`` (reset aspect)  |
+    +--------------------------------+----------------------------------------+
+    | ``step_property_osd <prop>``   | ``cycle <prop> <step>`` (wraps),       |
+    | ``<step> <dir>``               | ``add <prop> <step>`` (clamps).        |
+    |                                | ``<dir>`` parameter unsupported. Use   |
+    |                                | a negative ``<step>`` instead.         |
+    +--------------------------------+----------------------------------------+
+    | ``step_property <prop>``       | Prefix ``cycle`` or ``add`` with       |
+    | ``<step> <dir>``               | ``no-osd``: ``no-osd cycle <prop>``    |
+    |                                | ``<step>``                             |
+    +--------------------------------+----------------------------------------+
+    | ``osd_show_property_text``     | ``show_text <text>``                   |
+    | ``<text>``                     | The property expansion format string   |
+    |                                | syntax slightly changed.               |
+    +--------------------------------+----------------------------------------+
+    | ``osd_show_text``              | Now does the same as                   |
+    |                                | ``osd_show_property_text``. Use the    |
+    |                                | ``raw`` prefix to disable property     |
+    |                                | expansion.                             |
+    +--------------------------------+----------------------------------------+
+    | ``show_tracks``                | ``show_text ${track-list}``            |
+    +--------------------------------+----------------------------------------+
+    | ``show_chapters``              | ``show_text ${chapter-list}``          |
+    +--------------------------------+----------------------------------------+
+    | ``af_switch``, ``af_add``, ... | ``af set|add|...``                     |
+    +--------------------------------+----------------------------------------+
+    | ``tv_start_scan``              | ``set tv-scan yes``                    |
+    +--------------------------------+----------------------------------------+
+    | ``tv_set_channel <val>``       | ``set tv-channel <val>``               |
+    +--------------------------------+----------------------------------------+
+    | ``tv_step_channel``            | ``cycle tv-channel``                   |
+    +--------------------------------+----------------------------------------+
+    | ``dvb_set_channel <v1> <v2>``  | ``set dvb-channel <v1>-<v2>``          |
+    +--------------------------------+----------------------------------------+
+    | ``dvb_step_channel``           | ``cycle dvb-channel``                  |
+    +--------------------------------+----------------------------------------+
+    | ``tv_set_freq <val>``          | ``set tv-freq <val>``                  |
+    +--------------------------------+----------------------------------------+
+    | ``tv_step_freq``               | ``cycle tv-freq``                      |
+    +--------------------------------+----------------------------------------+
+    | ``tv_set_norm <norm>``         | ``set tv-norm <norm>``                 |
+    +--------------------------------+----------------------------------------+
+    | ``tv_step_norm``               | ``cycle tv-norm``                      |
+    +--------------------------------+----------------------------------------+
+
+    .. note::
+
+        Due to lack of hardware and users using the TV/DVB/PVR features, and
+        due to the need to cleanup the related command code, it's possible
+        that the new commands are buggy or behave worse. This can be improved
+        if testers are available. Otherwise, some of the TV code will be
+        removed at some point.
+
+Slave mode
+~~~~~~~~~~
+
+* Slave mode was removed. A proper slave mode application needed tons of code
+  and hacks to get
+  it right. The main problem is that slave mode is a bad and incomplete
+  interface, and to get around that, applications parsed output messages
+  intended for users. It is hard to know which messages exactly are parsed by
+  slave mode applications. This makes it virtually impossible to improve
+  terminal output intended for users without possibly breaking something.
+
+  This is absolutely insane, and since initial improvements to **mpv** quickly
+  made slave mode incompatible to most applications, it was removed as useless
+  cruft. The client API (see below) is provided instead.
+
+  ``--identify`` was replaced by the ``TOOLS/mpv_identify.sh`` wrapper script.
+
+* For some time (until including release 0.4.x), mpv supported a
+  ``--slave-broken`` option. The following options are equivalent:
+
+  ::
+
+        --input-file=/dev/stdin --input-terminal=no
+
+
+  Assuming the system supports ``/dev/stdin``.
+
+  (The option was readded in 0.5.1 and sets exactly these options.)
+
+* A JSON RPC protocol giving access to the client API is also supported. See
+  `JSON IPC`_ for more information.
+
+* **mpv** also provides a client API, which can be used to embed the player
+  by loading it as shared library. (See ``libmpv/client.h`` in the sources.)
+  It might also be possible to implement a custom slave mode-like protocol
+  using Lua scripting.
+
+Policy for Removed Features
+---------------------------
+
+**mpv** is in active development. If something is in the way of more important
+development (such as fixing bugs or implementing new features), we sometimes
+remove features. Usually this happens only with old features that either seem
+to be useless, or are not used by anyone. Often these are obscure, or
+"inherited", or were marked experimental, but never received any particular
+praise by any users.
+
+Sometimes, features are replaced by something new. The new code will be either
+simpler or more powerful, but doesn't necessarily provide everything the old
+feature did.
+
+We can not exclude that we accidentally remove features that are actually
+popular. Generally, we do not know how much a specific functionality is used.
+If you miss a feature and think it should be re-added, please open an issue
+on the mpv bug tracker. Hopefully, a solution can be found. Often, it turns
+out that re-adding something is not much of a problem, or that there are
+better alternatives.
+
+Why this Fork?
+--------------
+
+mplayer2 is practically dead, and mpv started out as a branch containing
+new/experimental development. (Some of it was merged right *after* the fork
+was made public, seemingly as an acknowledgment that development, or at
+least merging, should have been more active.)
+
+MPlayer is focused on not breaking anything, but is stuck with a horrible
+codebase resistant to cleanup. (Unless you do what mpv did - merciless and
+consequent pruning of bad, old code.) Cleanup and keeping broken things
+conflict, so the kind of development mpv strives for can't be done within
+MPlayer due to clashing development policies.
+
+Additionally, mplayer2 already had lots of changes over MPlayer, which would
+have needed to be backported to the MPlayer codebase. This would not only
+have been hard (several years of diverging development), but also would have
+been impossible due to the aforementioned MPlayer development policy.

DOCS/tech-overview.txt

@@ -1,4 +1,4 @@
-This file intends to give a big picture of how mpv is structured.
+This file intends to give a big picture overview of how mpv is structured.
 
 player/*.c:
     Essentially makes up the player applications, including the main() function
@@ -31,15 +31,28 @@ player/*.c:
             * loop, or exit if no next file or quit is requested
               (see enum stop_play_reason)
         * call exit_player_with_rc()
+    * run_playloop():
+        * calls fill_audio_out_buffers()
+            This checks whether new audio needs to be decoded, and pushes it
+            to the AO.
+        * calls write_video()
+            Decode new video, and push it to the VO.
+        * determines whether playback of the current file has ended
+        * determines when to start playback after seeks
+        * and calls a whole lot of other stuff
+            (Really, this function does everything.)
 
     Things worth saying about the playback core:
-    - the currently played tracks are in sh_video and sh_audio
+    - most state is in MPContext (core.h), which is not available to the
+      subsystems
+    - the currently played tracks are in mpctx->current_tracks, and decoder
+      state in d_video/d_audio/d_sub
     - the timeline stuff is used only with MKV ordered chapters (and some other
       minor features: cue, edl)
-    - most state is in MPContext (mp_core.h), which is not available to the
-      subsystems
     - the other subsystems rarely call back into the frontend, and the frontend
       polls them instead (probably a good thing)
+    - one exceptions are wakeup callbacks, which notify a "higher" component
+      of a changed situation in a subsystem
 
     I like to call the player/*.c files the "frontend".
 
@@ -103,7 +116,7 @@ options/options.h, options/options.c
     options.c. Most default values for options and MPOpts are in
     mp_default_opts at the end of options.c.
 
-    MPOpts is unfortunarely quite monolithic, and virtually accessed by
+    MPOpts is unfortunately quite monolithic, and virtually accessed by
     everything.But some components (like video outputs and video filters) have
     their own sub-option tables separate from MPOpts.
 
@@ -111,7 +124,7 @@ options/options.h, options/options.c
     parser-mpcmd.c, and uses the option table in options.c.
 
 input/input.c:
-    This translates keyboard input comming from libvo and other sources (such
+    This translates keyboard input comming from VOs and other sources (such
     as remote control devices like Apple IR or client API commands) to the
     key bindings listed in the user's (or the builtin) input.conf and turns
     them into items of type struct mp_cmd. These commands are queued, and read
@@ -122,7 +135,7 @@ input/input.c:
     of input commands somewhere else.
 
 common/msg.h:
-    All terminal output should go through mp_msg().
+    All terminal output must go through mp_msg().
 
 stream/*:
     File input is implemented here. stream.h/.c provides a simple stream based
@@ -181,7 +194,7 @@ video/out/:
     vo_opengl can pick a windowing system at runtime, e.g. the same binary can
     provide both X11 and Cocoa support on OSX.
 
-    VOs can be reconfigured at runtime. A config() call can change the video
+    VOs can be reconfigured at runtime. A vo_config() call can change the video
     resolution and format, without destroying the window.
 
     vo_vdpau and vo_opengl should be taken as reference.
@@ -203,9 +216,12 @@ audio/filter/:
 audio/out/:
     Audio outputs.
 
-    Unlike VOs, AOs can't be reconfigured on a format change. Without
-    --gapless-audio, even playing a new file will close and re-open the audio
-    device.
+    Unlike VOs, AOs can't be reconfigured on a format change. On audio format
+    changes, the AO will simply be closed and re-opened.
+
+    There are wrappers to support for two types of audio APIs: push.c and
+    pull.c. ao.c calls into one of these. They contain generic code to deal
+    with the data flow these APIs impose.
 
     Note that mpv synchronizes the video to the audio. That's the reason
     why buggy audio drivers can have a bad influence on playback quality.
@@ -218,12 +234,14 @@ sub/:
     the OSD text renderer (which uses libass, and takes care of all the tricky
     fontconfig/freetype API usage and text layouting).
 
-    Subtitle loading is now in demux/ instead. demux_libass.c wraps loading
-    .ass subtitles via libass. demux_lavf.c loads most subtitle types via
-    FFmpeg. demux_subreader.c is the old MPlayer code. It's used as last
-    fallback, or to handle some text subtitle types on Libav. (It also can
-    load UTF-16 encoded subtitles without requiring the use of -sub-codepage.)
-    demux_subreader.c should eventually go away (maybe).
+    The VOs call osd.c to render OSD and subtitle (via e.g. osd_draw()). osd.c
+    in turn asks dec_sub.c for subtitle overlay bitmaps, which relays the
+    request to one of the sd_*.c subtitle decoders/renderers.
+
+    Subtitle loading is in demux/. The MPlayer subreader.c is mostly gone - parts
+    of it survive in demux_subreader.c. It's used as last fallback, or to handle
+    some text subtitle types on Libav. It should go away eventually. Normally,
+    subtitles are loaded via demux_lavf.c.
 
     The subtitles are passed to dec_sub.c and the subtitle decoders in sd_*.c
     as they are demuxed. All text subtitles are rendered by sd_ass.c. If text

README.md

@@ -1,16 +1,19 @@
 mpv
 ===
 
-[![Build Status](https://api.travis-ci.org/mpv-player/mpv.png)](https://travis-ci.org/mpv-player/mpv)
-
 Overview
 --------
 
-**mpv** is a movie player based on MPlayer and mplayer2. It supports a wide
+**mpv** is a media player based on MPlayer and mplayer2. It supports a wide
 variety of video file formats, audio and video codecs, and subtitle types.
 
-If you are wondering what's different from mplayer2 and MPlayer you can read
-more about the [changes][changes].
+Releases can be found on the [release list][releases].
+
+Downloads
+---------
+
+For semi-official builds and third-party packages please see
+[mpv.io](http://mpv.io/installation/).
 
 Compilation
 -----------
@@ -44,16 +47,25 @@ Essential dependencies (incomplete list):
 
 - gcc or clang
 - X development headers (xlib, X extensions, libvdpau, libGL, libXv, ...)
-- Audio output development headers (libasound, pulseaudio)
-- FFmpeg libraries (libavutil libavcodec libavformat libswscale libavresample)
+- Audio output development headers (libasound/ALSA, pulseaudio)
+- FFmpeg libraries (libavutil libavcodec libavformat libswscale libavfilter
+  and either libswresample or libavresample)
   At least FFmpeg 2.1.4 or Libav 10 is required.
-- libjpeg (for screenshots)
-- libquvi if you want to play Youtube videos directly
+- zlib
+- iconv (normally provided by the system libc)
+- libass
+- Lua (optional, required for the OSC pseudo-GUI and youtube-dl integration)
+- libjpeg (optional, used for screenshots only)
+- Enca (optional, for subtitle charset detection)
+- vdpau and vaapi libraries for hardware decoding on Linux (optional)
 
 Libass dependencies:
 
 - gcc or clang, yasm on x86 and x86_64
 - fribidi, freetype, fontconfig development headers (for libass)
+- harfbuzz (optional, required for correct rendering of combining characters,
+  particularly for correct rendering of non-English text on OSX, and
+  Arabic/Indic scripts on any platform)
 
 FFmpeg dependencies:
 
@@ -74,6 +86,9 @@ If you are running Mac OSX and using homebrew we provide [homebrew-mpv][homebrew
 to date formula that compiles mpv with sensible dependencies and defaults for
 OSX.
 
+If you want to build a Windows binary, you either have to use MSYS2 and MinGW,
+or cross-compile from Linux with MinGW. See [Windows compilation][windows_compilation].
+
 FFmpeg vs. Libav
 ----------------
 
@@ -114,22 +129,44 @@ For small changes you can just send us pull requests through GitHub. For bigger
 changes come and talk to us on IRC before you start working on them. It will
 make code review easier for both parties later on.
 
+Relation to MPlayer and mplayer2
+--------------------------------
+
+mpv is based on mplayer2, which in turn is based on the original MPlayer
+(also called mplayer, mplayer-svn, mplayer1). Many changes have been made, a
+large part of which is incompatible or completely changes how the player
+behaves. Although there are still many similarities to its ancestors, mpv
+should generally be treated as a completely different program.
+
+mpv was forked because we wanted to modernize MPlayer. This includes
+removing cruft (including features which stopped making sense 10 years ago),
+and of course adding modern features. Such huge and intrusive changes made it
+infeasible to work directly with MPlayer, which is mostly focused on
+preservation, so a fork had to be made. (Actually, mpv is based on mplayer2,
+which already started this process of removing cruft.)
+
+In general, mpv should be considered a completely new program, rather than a
+MPlayer drop-in replacement.
+
+If you are wondering what's different from mplayer2 and MPlayer, an incomplete
+list of changes is located [here][mplayer-changes].
+
 Contact
 -------
 
-These forms of contact are meant to ask questions about mpv usage, give
-feedback on mpv and discuss it's development.
+Most activity happens on the IRC channel and the github issue tracker. The
+mailing lists are mostly unused.
 
-If possible, please avoid posting bugs here and use the [issue tracker][issue-tracker]
-instead.
-
- - **Users IRC Channel**: `#mpv-player` on `irc.freenode.net`
+ - **Github issue tracker**: [issue tracker][issue-tracker] (report bugs here)
+ - **User IRC Channel**: `#mpv-player` on `irc.freenode.net`
+ - **Developer IRC Channel**: `#mpv-player-dev` on `irc.freenode.net`
  - **Users Mailing List**: `mpv-users@googlegroups.com` ([Archive / Subscribe][mpv-users]).
  - **Devel Mailing List**: `mpv-devel@googlegroups.com` ([Archive / Subscribe][mpv-devel])
 
-To contact the `mpv` team in private write to `mpv-team@googlegroups.com`.
+To contact the `mpv` team in private write to `mpv-team@googlegroups.com`. Use
+only if discretion is required.
 
-[changes]: https://github.com/mpv-player/mpv/blob/master/DOCS/man/changes.rst
+[releases]: https://github.com/mpv-player/mpv/releases
 [mpv-build]: https://github.com/mpv-player/mpv-build
 [homebrew-mpv]: https://github.com/mpv-player/homebrew-mpv
 [issue-tracker]:  https://github.com/mpv-player/mpv/issues
@@ -137,3 +174,5 @@ To contact the `mpv` team in private write to `mpv-team@googlegroups.com`.
 [mpv-devel]: https://groups.google.com/forum/?hl=en#!forum/mpv-devel
 [ffmpeg_vs_libav]: https://github.com/mpv-player/mpv/wiki/FFmpeg-versus-Libav
 [release-policy]: https://github.com/mpv-player/mpv/blob/master/DOCS/release-policy.md
+[windows_compilation]: https://github.com/mpv-player/mpv/blob/master/DOCS/compile-windows.md
+[mplayer-changes]: https://github.com/mpv-player/mpv/blob/master/DOCS/mplayer-changes.rst

RELEASE_NOTES

@@ -1,158 +1,234 @@
-Release 0.5.3
-=============
-
-Bug fixes
----------
-
-- Fix build failure introduced by the previous release.
-
-This listing is not complete. There are many more bug fixes and changes. The
-complete change log can be viewed by running ``git log 41f2ad3..41f2ad3`` in
-the git repository.
-
-Release 0.5.2
+Release 0.8.3
 =============
 
 Changes
 -------
 
-- Inherit event flags from parent X11 window when using --wid.
-- Properly resume playlists loaded at runtime (this makes mpv try to resume a
-  playlist when loaded like "mpv playlist.m3u").
-- Don't honor $XDG_CONFIG_DIRS anymore for global paths (this fixes a regression
-  on systems that set the variable by default to somewhere else then /etc,
-  making mpv skip previously created config files).
-- Allow up to 256 MB of extradata to make broken files work.
+- Documentation fixes and updates.
+- (Client API) Clarify `mpv_opengl_cb_render`'s viewport parameter behavior.
 
 Bug fixes
 ---------
 
-- Restore old speed change behavior (this fixes a temporary lack of sound after
-  restoring normal speed e.g. when pressing Backspace).
-- Fix quit handling when seeking past EOF while paused.
-- Prevent burning CPU when seeking while paused.
-- Don't add the playlist base path twice when using --playlist.
-- Fix a crash when the initialization of the EGL context fails on Wayland.
-- Make EOF handling properly event-based (this fixes a bug that made mpv hang
-  when changing from one file to the next with --gapless-audio=no).
-- Assume icy title data is terminated with ';' (this fixes handling of streams
-  with metadata containing apostrophes).
+- (X11) Fix crash on `vo_xv:no-colorkey` with the Overlay adapter. (bug #1629)
+- Make the video equalizer work correctly on some VAAPI drivers. (bug #1647)
+- Prevent OSD from disappearing when clicking on mozplugger. (bug #1672)
+- The new DVB-S2 support code, using S2API, now builds on FreeBSD.
+- Fix decoding of seekable matroska from unseekable network stream. (bug #1656)
+- (OSX) Fix crashing when closing a VO's window (usually at exit). (bug #1657)
+- (OSX) Unhide the mouse cursor when over the Dock or Launchpad. (bug #513)
+- (OSX) Fix mouse cursor autohiding when the player is fullscreen.
+- `vf_vavpp` (VAAPI postprocessing) now deinterlaces video correctly.
+- `smb://` streams now use the stream cache (used to be inefficient).
+- (Windows) Do not hide the mouse cursor when it is hovering the window menu.
+- Fix 8-channel output on `ao_jack`. (bug #1688)
+- Fix `--mf-fps` parameter on JPEG files. (bug #1689)
+- Fix anamorphic scaling being ignored if it was very minor.
 
-This listing is not complete. There are many more bug fixes and changes. The
-complete change log can be viewed by running ``git log 0f1d6c0..e3d3a47`` in
-the git repository.
+This listing is not complete. A complete changelog can be seen by running
+`git log v0.8.2..v0.8.3` in the git repository.
 
-Release 0.5.1
+Release 0.8.2
+=============
+
+Bug fixes
+---------
+
+- Fix OSD placement accidentally messed up in 0.8.1.
+
+Release 0.8.1
 =============
 
 Changes
 -------
 
-- Add audio/flac to the MIME type list in mpv.desktop.
-- The --slave-broken option has been reintroduced and is equivalent to using
-  --input-file=/dev/stdin and --input-terminal=no.
+- DOCS/client-api-changes has been correctly updated for the v0.8.0 release
+  series.
+- Quality and major perfomance improvements to smoothmotion.
+- Silence the "[ytdl_hook] WARNING: video doesn't have subtitles" warning.
+- Other documentation updates.
 
 Bug fixes
 ---------
 
-- Fix screenshots with anamorphic videos in the vdpau vo.
-- Fix a crash happening when mpv fails to create a vdpau mixer in the vdpau vo.
-- Don't quit when the --loop-file option is used.
-- Always load the cursor theme in the wayland vo (this fixes a crash caused by
-  moving the mouse cursor over the video).
-- Properly return non-zero from the zsh completion script when no matches are
-  found (this fixes the use of user-defined zsh completion matchers).
-- Fix the description of the opengl-hq vo default options in the manpage.
-- Remove duplicated content from the manpage that was accidentally added in the
-  manpage reorganization from the previous release.
-- Avoid clobbering playback position on video end (when both audio and video
-  streams reached the end, the playback poisition was briefly set at 0).
-- Avoid overwriting user input in the coreaudio_device ao.
-
-This listing is not complete. There are many more bug fixes and changes. The
-complete change log can be viewed by running ``git log 6729e39..fdd648b`` in
-the git repository.
-
-Release 0.5.0
-=============
-
-Changes
--------
-
-- Support setting the start time relative to the start PTS with --start.
-- Use /dev/sr0 as default cdrom/dvd device on Linux.
-- Change "cache" property representation to float.
-- Split the ao_coreaudio audio output into ao_coreaudio (which uses the
-  AudioUnits and the CoreAudio sound server) and ao_coreaudio_device (which uses
-  direct device access).
-- Complete supported URL schemes in the zsh completion script.
-- Enable compiler optimizations (-O2) during build.
-- Allow precise seeking with percent-based seeks too.
-- Do precise seeks when clicking on the OSC seekbar.
-- Remove support for older VDA hwaccel versions on Mac OS X (requires recent
-  versions of ffmpeg/libav).
-- Remove the last remains of slave mode (--slave-broken option). Support for
-  reading input commands from stdin can be emulated using: --input-terminal=no
-  --input-file=/dev/stdin.
-- Some key binding were remapped or removed:
-  + "LEFT" and "RIGHT" have been remapped to seek 5 seconds instead of 10.
-  + "c" for changing the YUV color space was unmapped.
-  + OSD level cycling has been remapped from "o" to "O".
-  + "o" is now mapped to the show_progress command (like "P").
-  + "PGUP" and "PGDWN" have been remapped to chapter-based seeks (the old
-    bindings "@" and "!" are still available). The old behvaiour has been
-    remapped to "Shift+PGUP" and "Shift+PGDWM".
-  + Increasing/decreasing audio delay have been remapped from "+" and "-" to
-    "Ctrl++" and "Ctrl+-".
-  + "(" and ")" for adjusting audio balance have been unmapped.
-  + "F" for toggling the "sub-forced-only" option has been unmapped.
-  + "TAB" for cycling TS programs has been unmapped.
-  + "A" for cycling DVD angle has been unmapped.
-  + "U" for stopping playback has been unmapped.
-  + "l" and "L" for cycling quvi format have been unmapped.
-- Make it possible to build the client API (libmpv) on Mac OS X.
-- Do necessary checks for nested Wayland compositors which only have limited
-  interfaces.
-- The options in the manpage have been re-organized into sections and ordered by
-  usage to make it easier to navigate.
-- The "hard" framedrop mode has been removed (this behaviour is still available
-  via the --vd-lavc-framedrop option).
-- Show the basename of a subtitle file only (without the directory part).
-
-Bug fixes
----------
-
-- Use a default color space for files with no video (this fixes color managed
-  OSD messages when no video channel is present).
-- Fix key equivalent dispatching for Cocoa on Mac OS X.
-- Disable non-interleaved audio formats by default with ao_alsa, since some
-  ALSA plugins don't cope well with them (non-interleaved formats can still be
-  enabled using the "non-interleaved" ao_alsa option).
-- Fix deadlock in the client API when calling mpv_terminate_destroy() before
-  mpv_initialize().
-- Fix flushing of filter chain (this fixes a bug where the last frames would get
-  dropped on EOF, if buffered by filters).
-- Actually use the channels.conf configuration file for DVB.
-- Restore the --dvbin-file option.
-- Fix off by one error in the command parser which caused a segfault when using
-  the mp.commandv() Lua function with 10 or more arguments.
+- Attempt to fix OpenGL shader compilation on Intel windows drivers. (bug
+  #1536)
+- Attempt to improve the OpenGL shader's compatibility with GLES2.
+- (Windows) Fix noise when seeking while using wasapi:exclusive. (bug #1529)
+- Fix the waf-based build system when used with newer versions of waf with
+  python3.
+- Documentation fixes. (includes bug #1608)
 
 New features
 ------------
 
-- Search for config files in $XDG_CONFIG_HOME and $XDG_CONFIG_DIRS in addition
-  to ~/.mpv. The config file has also been renamed to mpv.conf (although the
-  old file still works and will be loaded even if the new one exists).
-- Add "playback-time" property that returns the current playback time always
-  starting at 0. This is now used to show the playback time in the OSD and the
-  status line, fixing the shown playback time for transport streams that start
-  at a completely random timestamp.
-- Add cache-related "cache-free", "cache-used" and "cache-idle" properties.
-- Add option to list supported protocols (--list-protocols).
-- Allow setting libavformat stream options with the --stream-lavf-o option.
-- Support running the demuxer in a separate thread and prefetch packets (this
-  can be enabled using the --demuxer-thread option).
+- mpv now tries to load '.vtt' subtitles.
 
-This listing is not complete. There are many more bug fixes and changes. The
-complete change log can be viewed by running ``git log cb250d4..52f2f67`` in
-the git repository.
+This listing is not complete. A complete changelog can be seen by running
+`git log v0.8.0..v0.8.1` in the git repository.
+
+Release 0.8.0
+=============
+
+Changes
+-------
+
+Changes that may break users' config files have been annotated with a `(!)`.
+
+- `(!)` vo_opengl_old has been removed. OpenGL rendering now requires hardware
+  that can do at least OpenGL 2.1, the oldest version supported by vo_opengl.
+- `(!)` vf_pp has been removed. A version of it can still be accessed through
+  lavfilter (e.g. --vf=lavfi=[pp...]), but it receives no QP information.
+  Also, vf_dlopen no longer passes QP information to its loaded plugin either
+  (it's always 0).
+- `(!)` vf_softpulldown, vf_swapuv, vf_phase, vf_divtc and vf_ilpack have all
+  been removed. Ports or alternative versions of these filters are available
+  through libavfilter (vf_lavfi).
+- vf_pullup and vf_noise now are simply wrappers to their libavfilter
+  equivalents. Both are only currently available on FFmpeg (not Libav).
+- `(!)` ao_portaudio has been removed. There is good support for the native
+  audio drivers of all major desktop platforms, as well as ao_sdl and
+  ao_openal as fallbacks.
+- `(!)` vo_opengl's `lscale` suboption has been renamed to `scale`; `lradius`
+  is now `scale-radius`, `lparam1` and `lparam2` are now respectively
+  `scale-param1` and `scale-param2`; `lscale-down` is now `scale-down`.
+  The `cscale` suboption remains as is.
+- `(!)` Several of the `vo_opengl` radius-preset aliases supported by `scale`
+  have been removed; use `scale-radius` to set if needed. For example, use
+  `--vo=opengl:scale=lanczos:scale-radius=2` instead of `scale=lanczos2`.
+  The default radius is recommended for most filters.
+- `(!)` vo_opengl no longer supports the `stereo` suboption. The anaglyph
+  effect can be reproduced with the stereo3d filter. The quadbuffer support,
+  which requires expensive specialized hardware to begin with, is removed.
+- `(!)` The `approx-gamma` suboption to vo_opengl has been removed. The
+  BT.1886 specification says that it's actually how it's supposed to be done
+  so it is now the default when `srgb` or `icc-profile` are enabled. This does
+  not include BT.1886's gamma drop.
+- `(!)` The `no-scale-sep` and `indirect` suboptions to vo_opengl have been
+  removed. These are now autodetected and enabled whenever they would have
+  benefit.
+- `(!)` The `--lua` and `--lua-opts` parameters / options are now called
+  `--script` and `--script-opts`, respectively. The `lua` subdir of the mpv
+  config dir is also now expected to be called `scripts` instead.
+- `(!)` The `--fixed-vo` option has been removed. It has been the default for
+  a long time anyway, and disabling fixed-vo is not useful.
+- vo_opengl_hq has been updated to take into account new features.
+  `fancy-downscaling` and `sigmoid-upscaling` are enabled,
+  "mitchell" is now the default for `scale-down`.
+- The `sub-visibility` OSD message is now clearer about whether subtitles
+  are hidden or just not available / selected.
+- The device IDs given to `--audio-device` for use with ao_coreaudio now use
+  UIDs, so they don't change when devices are added/removed or after reboots.
+- `--msg-level` now also accepts ',' as separator.
+- (Client API) The client API now refuses to initialize if the LC_NUMERIC
+  locale is not "C".
+- (Client API) The native type of the `msg-level` parameter is now a key-value
+  list. Setting or reading it as a string still works.
+- (Slave API) The `get_property` command is now deprecated.
+- Documentation updates.
+- PDF documentation is now disabled by default due to rst2pdf being fickle,
+  causing weird build errors.
+- Print desync messages with negative A/V sync as well. While rare, it could
+  happen with some uses of `--autosync`.
+
+Bug fixes
+---------
+
+- (Windows) Avoid resizing the video window when player is minimized, might
+  address bug #1547.
+- (NetBSD) Fix build with v4l2.
+- (Linux) Attempt to address conflicts with the pulseaudio mixer. (bug #1578)
+- Multiple cdda:// fixes. (bugs #1555, #1560)
+- VP9 timestamps no longer cause "missing PTS" warnings with new enough FFmpeg
+  builds.
+- Fix a crash when using H.264 hardware decoding on new enough libavcodecs.
+  (bug #1587)
+
+New features
+------------
+
+- vo_opengl now supports frame blending to eliminate stuttering when the video
+  framerate does not nicely match the display framerate through the
+  `smoothmotion` suboption. This is not meant to artificially increase the
+  video's FPS, so there is no "soap opera effect" or difficulties with some
+  video types (e.g. anime).
+- vo_opengl now supports sigmoidal upscaling (e.g. for fullscreen), which
+  reduces ringing induced by upscaling, enabled through the
+  `sigmoid-upscaling` suboption.
+- vo_opengl now supports ewa_lanczos (Jinc) scaling, which provides higher
+  quality with less aliasing. It supports an experimental `scale-antiringing`
+  parameter, which tries to further reduce video ringing.
+- vo_opengl now has a `linear-scaling` suboption, that makes the scalers work
+  in linear light. Implied by the `srgb`, `icc-profile` or the new
+  `sigmoid-upscaling` suboption.
+- vo_opengl has improved downscaling for higher downscale ratios when
+  `fancy-downscaling` is enabled.
+- Add `--keep-open=always` to make `--keep-open` apply to all files instead of
+  only the last.
+- mpv now filters the tags that are printed on the console to try to hide
+  useless metadata. The filter works as a whitelist, and can be configured
+  with the `--display-tags` option.
+- Add a `--sub-scale-by-window` option that, when set to 'no', prevents
+  subtitles from changing their pixel size when the window changes sizes.
+- vo_opengl now technically has GLES 2 and 3 support (but not GLES 1). GLES 3
+  support is only tested on Mesa's software emulation. GLES 2 has been tested
+  on nvidia drivers. Both GLES modes are feature deficient and inefficient due
+  to GLES limitations, so they should not be preferred over the standard
+  OpenGL mode.
+- (X11) vo_opengl now supports the `icc-profile-auto` option on X11 hosts.
+- The 'A' key now by default cycles through a list of preset aspect ratios.
+  Meant to be used to work around broken files.
+- There is now a "force" mode for `--loop`. Works like "inf", but tries to
+  open files/streams even if there was an error on the previous attempt.
+- There is now a `--log-file` option to write mpv's log messages to a specifed
+  file.
+- There is now a `--audio-file-auto` option to automatically load an external
+  audio file with certain constraints. Will only load external audio if the
+  playing file has a video stream. Set to "exact" by default. (bug #967)
+- There is now a `--network-timeout` option to specify a timeout in seconds
+  for network access. If 0 (default), uses the libavformat default. If a
+  protocol that doesn't support timeouts is used, this option is ignored.
+- (X11) The XF86 special keys are now all mappable in `input.conf`. All keys
+  documented in `XF86keysym.h` are available, but only as their numeric codes.
+- (Linux) The DVB implementation now supports DVB-S2 through S2API.
+- (Linux) The VDR format for `channels.conf` is now supported and preferred.
+  See http://linuxtv.org/vdrwiki/index.php/Syntax_of_channels.conf for the
+  syntax. Tuning to DVB-S2 channels requires the VDR-format `channels.conf`.
+- (Linux) There is now a `--dvbin-full-transponder` option for handling
+  special broadcast cases where PIDs switch, or just to work around incomplete
+  PID data.
+- (Client API) There is now an opengl_cb VO, which receives the OpenGL context
+  from the libmpv client. This allows a client to render libmpv video directly
+  to a provided OpenGL context without having to use --wid embedding.
+- (Client API) The aforementioned --wid parameter can now be set at any time,
+  but has no effect if a file is already loaded.
+- (Client API) The list of DVD titles can now be queried.
+- (Client API) There is now a `filtered-metadata` property, containing only
+  the tags allowed by `--display-tags`.
+- (Client API) There is now support for XEmbed `--wid` targets, such as a
+  `GtkSocket`'s `gtk_socket_get_id()`.
+- (Client API) There is now a `file-format` property with a symbolic name
+  for the file format. In some cases this might be a comma separated list
+  of various different extensions due to libavformat idiosyncrasies.
+- (Client API) There is now a `mouse` command for generating mouse events
+  over the video window.
+- (Client API) There is now a `partially-seekable` property that indicates
+  whether a file is only considered `seekable` because of the stream cache,
+  but would not be seekable otherwise (e.g. realtime stream, or HTTP with
+  no resume support). Small relative seeks may be fine, but larger seeks
+  will likely fail.
+- (Client API) There is now an MPV_EVENT_QUEUE_OVERFLOW event that is posted
+  whenever events have to be dropped because the queue is full. No further
+  events are posted until the MPV_EVENT_QUEUE_OVERFLOW is consumed to avoid
+  duplicated posting.
+- (Client API) There is now a helper `mpv_wait_async_requests()` function
+  that blocks until all known async requests have completed. (bug #1542)
+- (Client API) There is now a `detected-hwdec` property that returns the
+  detected hardware decoder when one is successfully opened. This probably
+  only returns a valid value after playback has started.
+- (Client API) There are now `audio_add`, `audio_remove` and `audio_reload`
+  counterparts to the equivalent `sub_` commands for handling external audio
+  files.
+
+This listing is not complete. A complete changelog can be seen by running
+`git log v0.7.0..v0.8.0` in the git repository.

TOOLS/dylib-unhell.py

@@ -19,6 +19,7 @@ def is_user_lib(objfile, libname):
            not "libSystem." in libname and \
            not "libc." in libname and \
            not "libgcc." in libname and \
+           not os.path.basename(libname) == 'Python' and \
            not os.path.basename(objfile) in libname
 
 def otool(objfile):

TOOLS/gen-x11-icon.sh

@@ -5,8 +5,8 @@
 
 conv() {
     echo
-    identify -format "icon: %w %h" $1
-    convert $1 -depth 8 rgba:-
+    identify -format "icon: %w %h" "$1"
+    convert "$1" -depth 8 rgba:-
 }
 
 (echo "# File generated by gen-x11-icon.sh" ;

TOOLS/idet.sh

@@ -1,23 +1,15 @@
 #!/bin/sh
 
-case "$0" in
-    */*)
-        MYDIR=${0%/*}
-        ;;
-    *)
-        MYDIR=.
-        ;;
-esac
+: "${MPV:=mpv}"
+: "${ILDETECT_MPV:=$MPV}"
+: "${ILDETECT_MPVFLAGS:=--start=35% --length=35}"
+: "${ILDETECT_DRY_RUN:=}"
+: "${ILDETECT_QUIET:=}"
+: "${ILDETECT_RUN_INTERLACED_ONLY:=}"
+: "${ILDETECT_FORCE_RUN:=}"
 
-: ${MPV:=mpv}
-: ${ILDETECT_MPV:=$MPV}
-: ${ILDETECT_MPV:=$MPV}
-: ${ILDETECT_MPVFLAGS:=--start=35% --length=35}
-: ${ILDETECT_DRY_RUN:=}
-: ${ILDETECT_QUIET:=}
-: ${ILDETECT_RUN_INTERLACED_ONLY:=}
-: ${ILDETECT_FORCE_RUN:=}
-: ${MAKE:=make}
+# This script uses ffmpeg's "idet" filter for interlace detection. In the
+# long run this should replace ildetect.sh+ildetect.so.
 
 # exit status:
 # 0 progressive
@@ -34,57 +26,62 @@ testfun()
         --o= --vo=null --no-audio --untimed \
         $ILDETECT_MPVFLAGS \
         | { if [ -n "$ILDETECT_QUIET" ]; then cat; else tee /dev/stderr; fi } \
-        | grep "Parsed_idet_0: Multi frame detection: " | tail -n 1
+        | grep "Parsed_idet_0: Multi frame detection: "
 }
 
 judge()
 {
-    out=`testfun "$@"`
-
-    tff=${out##* TFF:}; tff=${tff%% *}
-    bff=${out##* BFF:}; bff=${bff%% *}
-    progressive=${out##* Progressive:}; progressive=${progressive%% *}
-    undetermined=${out##* Undetermined:}; undetermined=${undetermined%% *}
-
-    case "$tff$bff$progressive$undetermined" in
-        *[!0-9]*)
-            echo >&2 "ERROR: Unrecognized idet output: $out"
-            exit 16
-            ;;
-    esac
+    tff=0
+    bff=0
+    progressive=0
+    undetermined=0
+    while read -r _ _ _ _ _ _ tff1 _ bff1 _ progressive1 _ undetermined1 _; do
+        case "$tff1$bff1$progressive1$undetermined1" in
+            *[!0-9]*)
+                printf >&2 'ERROR: Unrecognized idet output: %s\n' "$out"
+                exit 16
+                ;;
+        esac
+        tff=$((tff + tff1))
+        bff=$((bff + bff1))
+        progressive=$((progressive + progressive1))
+        undetermined=$((undetermined + undetermined1))
+    done <<EOF
+$(testfun "$@")
+EOF
 
     interlaced=$((bff + tff))
     determined=$((interlaced + progressive))
 
-    if [ $undetermined -gt $determined ] || [ $determined -lt 250 ]; then
+    if [ "$undetermined" -gt "$determined" ] || [ "$determined" -lt 250 ]; then
         echo >&2 "ERROR: Less than 50% or 250 frames are determined."
         [ -n "$ILDETECT_FORCE_RUN" ] || exit 8
         echo >&2 "Assuming interlacing."
-        if [ $tff -gt $((bff * 10)) ]; then
-            verdict=interlaced-tff
-        elif [ $bff -gt $((tff * 10)) ]; then
-            verdict=interlaced-bff
+        if [ "$tff" -gt $((bff * 10)) ]; then
+            verdict="interlaced-tff"
+        elif [ "$bff" -gt $((tff * 10)) ]; then
+            verdict="interlaced-bff"
         else
-            verdict=interlaced
+            verdict="interlaced"
         fi
-    elif [ $((interlaced * 20)) -gt $progressive ]; then
+    elif [ $((interlaced * 20)) -gt "$progressive" ]; then
         # At least 5% of the frames are interlaced!
-        if [ $tff -gt $((bff * 10)) ]; then
-            verdict=interlaced-tff
-        elif [ $bff -gt $((tff * 10)) ]; then
-            verdict=interlaced-bff
+        if [ "$tff" -gt $((bff * 10)) ]; then
+            verdict="interlaced-tff"
+        elif [ "$bff" -gt $((tff * 10)) ]; then
+            verdict="interlaced-bff"
         else
             echo >&2 "ERROR: Content is interlaced, but can't determine field order."
             [ -n "$ILDETECT_FORCE_RUN" ] || exit 8
             echo >&2 "Assuming interlacing with default field order."
-            verdict=interlaced
+            verdict="interlaced"
         fi
     else
-        # Likely progrssive.
-        verdict=progressive
+        # Likely progressive
+        verdict="progressive"
     fi
 
-    echo "$verdict"
+    printf '%s\n' "$verdict"
 }
 
 judge "$@" --vf-clr
@@ -94,7 +91,7 @@ case "$verdict" in
             [ -n "$ILDETECT_RUN_INTERLACED_ONLY" ] || \
             $ILDETECT_MPV "$@"
         r=$?
-        [ $r -eq 0 ] || exit $(($r | 16))
+        [ $r -eq 0 ] || exit $((r | 16))
         exit 0
         ;;
     interlaced-tff)
@@ -104,14 +101,14 @@ case "$verdict" in
                 [ -n "$ILDETECT_DRY_RUN" ] || \
                     $ILDETECT_MPV "$@" --vf-pre=pullup --field-dominance=top
                 r=$?
-                [ $r -eq 0 ] || exit $(($r | 16))
+                [ $r -eq 0 ] || exit $((r | 16))
                 exit 1
                 ;;
             *)
                 [ -n "$ILDETECT_DRY_RUN" ] || \
                     $ILDETECT_MPV "$@" --vf-pre=yadif --field-dominance=top
                 r=$?
-                [ $r -eq 0 ] || exit $(($r | 16))
+                [ $r -eq 0 ] || exit $((r | 16))
                 exit 2
                 ;;
         esac
@@ -123,14 +120,14 @@ case "$verdict" in
                 [ -n "$ILDETECT_DRY_RUN" ] || \
                     $ILDETECT_MPV "$@" --vf-pre=pullup --field-dominance=bottom
                 r=$?
-                [ $r -eq 0 ] || exit $(($r | 16))
+                [ $r -eq 0 ] || exit $((r | 16))
                 exit 1
                 ;;
             *)
                 [ -n "$ILDETECT_DRY_RUN" ] || \
                     $ILDETECT_MPV "$@" --vf-pre=yadif --field-dominance=bottom
                 r=$?
-                [ $r -eq 0 ] || exit $(($r | 16))
+                [ $r -eq 0 ] || exit $((r | 16))
                 exit 2
                 ;;
         esac
@@ -142,14 +139,14 @@ case "$verdict" in
                 [ -n "$ILDETECT_DRY_RUN" ] || \
                     $ILDETECT_MPV "$@" --vf-pre=pullup
                 r=$?
-                [ $r -eq 0 ] || exit $(($r | 16))
+                [ $r -eq 0 ] || exit $((r | 16))
                 exit 1
                 ;;
             *)
                 [ -n "$ILDETECT_DRY_RUN" ] || \
                     $ILDETECT_MPV "$@" --vf-pre=yadif
                 r=$?
-                [ $r -eq 0 ] || exit $(($r | 16))
+                [ $r -eq 0 ] || exit $((r | 16))
                 exit 2
                 ;;
         esac

TOOLS/lib/Parse/Matroska/Definitions.pm

@@ -232,6 +232,7 @@ sub define_matroska {
                     elem('Block',           'a1', 'binary'),
                     elem('BlockDuration',   '9b', 'uint'),
                     elem('ReferenceBlock*', 'fb', 'sint'),
+                    elem('DiscardPadding',  '75A2', 'sint'),
                 }),
                 elem('SimpleBlock*', 'a3', 'binary'),
             }),
@@ -256,6 +257,8 @@ sub define_matroska {
                     elem('CodecPrivate',         '63a2', 'binary'),
                     elem('CodecName',          '258688', 'str'),
                     elem('CodecDecodeAll',         'aa', 'uint'),
+                    elem('CodecDelay',           '56AA', 'uint'),
+                    elem('SeekPreRoll',          '56BB', 'uint'),
                     elem('Video', 'e0', {
                         elem('FlagInterlaced',  '9a', 'uint'),
                         elem('PixelWidth',      'b0', 'uint'),
@@ -265,6 +268,7 @@ sub define_matroska {
                         elem('DisplayUnit',   '54b2', 'uint'),
                         elem('FrameRate',   '2383e3', 'float'),
                         elem('ColourSpace', '2eb524', 'binary'),
+                        elem('StereoMode',    '53b8', 'uint'),
                     }),
                     elem('Audio', 'e1', {
                         elem('SamplingFrequency',         'b5', 'float'),
@@ -292,6 +296,8 @@ sub define_matroska {
                     elem('CueTrackPositions*', 'b7', {
                         elem('CueTrack',           'f7', 'uint'),
                         elem('CueClusterPosition', 'f1', 'uint'),
+                        elem('CueRelativePosition','f0', 'uint'),
+                        elem('CueDuration',        'b2', 'uint'),
                     }),
                 }),
             }),

TOOLS/lua/README.md

@@ -4,16 +4,9 @@ mpv lua scripts
 The lua scripts in this folder can be loaded on a one-time basis by
 adding the option
 
-    --lua=/path/to/script.lua
+    --script=/path/to/script.lua
 
 to mpv's command line.
 
-Unless otherwise specified, they are also suitable for inclusion in
-the `~/.mpv/lua` directory where they will be loaded every time mpv
-starts, obviating the need to load them with the above `--lua=...`
-argument. This is acceptable as they do only basic argument parsing
-and key-binding registration, until those bound keys are actually
-pressed.  They should therefore not interfere with normal playback
-(unless you have a conflicting user-defined key-binding, in which
-case, you may want to modify either the `mp.add_key_binding()` calls
-in the scripts, or your keybinding).
+Where appropriate, they may also be placed in ~/.config/mpv/scripts/ from
+where they will be automatically loaded when mpv starts.

TOOLS/lua/autocrop.lua

@@ -21,7 +21,7 @@
 -- The default delay between insertion of the cropdetect and
 -- crop filters may be overridden by adding
 --
--- --lua-opts=autocrop.detect_seconds=<number of seconds>
+-- --script-opts=autocrop.detect_seconds=<number of seconds>
 --
 -- to mpv's arguments. This may be desirable to allow cropdetect more
 -- time to collect data.
@@ -42,11 +42,11 @@ function del_filter_if_present(label)
     -- error if the filter doesn't exist
     local vfs = mp.get_property_native("vf")
     for i,vf in pairs(vfs) do
-	if vf["label"] == label then
-	    table.remove(vfs, i)
-	    mp.set_property_native("vf", vfs)
-	    return true
-	end
+        if vf["label"] == label then
+            table.remove(vfs, i)
+            mp.set_property_native("vf", vfs)
+            return true
+        end
     end
     return false
 end
@@ -65,10 +65,10 @@ function autocrop_start()
 
     -- insert the cropdetect filter
     ret=mp.command(
-	string.format(
-	    'vf add @%s:lavfi=graph="cropdetect=limit=24:round=2:reset=0"',
-	    cropdetect_label
-	)
+        string.format(
+            'vf add @%s:lavfi=graph="cropdetect=limit=24:round=2:reset=0"',
+            cropdetect_label
+        )
     )
     -- wait to gather data
     timer=mp.add_timeout(detect_seconds, do_crop)
@@ -77,15 +77,15 @@ end
 function do_crop()
     -- get the metadata
     local cropdetect_metadata = mp.get_property_native(
-	string.format("vf-metadata/%s", cropdetect_label)
+        string.format("vf-metadata/%s", cropdetect_label)
     )
     -- use it to crop if its valid
     if cropdetect_metadata then
-	if cropdetect_metadata["lavfi.cropdetect.w"]
-	    and cropdetect_metadata["lavfi.cropdetect.h"]
-	    and cropdetect_metadata["lavfi.cropdetect.x"]
-	    and cropdetect_metadata["lavfi.cropdetect.y"]
-	then
+        if cropdetect_metadata["lavfi.cropdetect.w"]
+            and cropdetect_metadata["lavfi.cropdetect.h"]
+            and cropdetect_metadata["lavfi.cropdetect.x"]
+            and cropdetect_metadata["lavfi.cropdetect.y"]
+        then
             mp.command(string.format("vf add @%s:crop=%s:%s:%s:%s",
                                      crop_label,
                                      cropdetect_metadata["lavfi.cropdetect.w"],
@@ -94,9 +94,9 @@ function do_crop()
                                      cropdetect_metadata["lavfi.cropdetect.y"]))
         else
             mp.msg.error(
-		"Got empty crop data. You might need to increase detect_seconds."
-	    )
-	end
+                "Got empty crop data. You might need to increase detect_seconds."
+            )
+        end
     else
         mp.msg.error(
             "No crop data. Was the cropdetect filter successfully inserted?"

TOOLS/lua/autodeint.lua

@@ -0,0 +1,164 @@
+-- This script uses the lavfi idet filter to automatically insert the
+-- appropriate deinterlacing filter based on a short section of the
+-- currently playing video.
+--
+-- It registers the key-binding ctrl+d, which when pressed, inserts
+-- the filter vf=lavfi=idet. After 4 second, it examines the results
+-- to determine whether the content progressive or interlaced and the
+-- interlacing field dominance. It immediately sets the latter within
+-- mpv.
+--
+-- If the content is judged not to be progressive, it may be either
+-- interlaced or telecined. To determine which one, the video is
+-- seeked back to the detection starting point with the "pullup"
+-- filter inserted. After another four seconds, if idet thinks that
+-- the pulled up viedo is "progressive", then pullup is the correct
+-- filter and this script leaves it in places while removing the idet
+-- filter. Otherwise, the content plain interlaced and mpv's deinterlace
+-- property is set. This will usually insert the yadif deinterlacing filter.
+--
+-- The default detection time may be overridden by adding
+--
+-- --script-opts=autodeint.detect_seconds=<number of seconds>
+--
+-- to mpv's arguments. This may be desirable to allow idet more
+-- time to collect data.
+--
+-- To see counts of the various types of frames for each detection phase,
+-- the verbosity can be increased with
+--
+-- --msg-level autodeint=v
+--
+-- This script requires a recent version of ffmpeg for which the idet
+-- filter adds the required metadata.
+
+require "mp.msg"
+
+script_name = mp.get_script_name()
+detect_label = string.format("%s-detect", script_name)
+pullup_label = string.format("%s", script_name)
+
+-- number of seconds to gather cropdetect data
+detect_seconds = tonumber(mp.get_opt(string.format("%s.detect_seconds", script_name)))
+if not detect_seconds then
+    detect_seconds = 4
+end
+
+function del_filter_if_present(label)
+    -- necessary because mp.command('vf del @label:filter') raises an
+    -- error if the filter doesn't exist
+    local vfs = mp.get_property_native("vf")
+
+    for i,vf in pairs(vfs) do
+        if vf["label"] == label then
+            table.remove(vfs, i)
+            mp.set_property_native("vf", vfs)
+            return true
+        end
+    end
+    return false
+end
+
+function start_detect()
+    -- exit if detection is already in progress
+    if timer then
+        mp.msg.warn("already detecting!")
+        return
+    end
+
+    mp.set_property("deinterlace","no")
+    del_filter_if_present(pullup_label)
+
+    percent_pos = mp.get_property("percent-pos")
+
+    -- insert the detection filter
+    local cmd = string.format('vf add @%s:lavfi=graph="idet"', detect_label)
+    if not mp.command(cmd) then
+        mp.msg.error("failed to insert detection filter")
+        return
+    end
+
+    -- wait to gather data
+    timer = mp.add_timeout(detect_seconds, judge_field_dominance)
+end
+
+function stop_detect()
+    del_filter_if_present(detect_label)
+    timer = nil
+    mp.set_property("playback-pos", percent_pos)
+end
+
+progressive, interlaced_tff, interlaced_bff, interlaced = 0, 1, 2, 3, 4
+
+function judge()
+    -- get the metadata
+    local result = mp.get_property_native(string.format("vf-metadata/%s", detect_label))
+    num_tff          = tonumber(result["lavfi.idet.multiple.tff"])
+    num_bff          = tonumber(result["lavfi.idet.multiple.bff"])
+    num_progressive  = tonumber(result["lavfi.idet.multiple.progressive"])
+    num_undetermined = tonumber(result["lavfi.idet.multiple.undetermined"])
+    num_interlaced   = num_tff + num_bff
+    num_determined   = num_interlaced + num_progressive
+
+    mp.msg.verbose("progressive    = "..num_progressive)
+    mp.msg.verbose("interlaced-tff = "..num_tff)
+    mp.msg.verbose("interlaced-bff = "..num_bff) 
+    mp.msg.verbose("undetermined   = "..num_undetermined)
+
+    if num_determined < num_undetermined then
+        mp.msg.warn("majority undetermined frames")
+    end
+    if num_progressive > 20*num_interlaced then
+        return progressive
+    elseif num_tff > 10*num_bff then
+        return interlaced_tff
+    elseif num_bff > 10*num_tff then
+        return interlaced_bff
+    else
+        return interlaced
+    end
+end
+
+function judge_field_dominance()
+    verdict = judge()
+    if verdict == progressive then
+        stop_detect()
+        mp.msg.info("progressive: doing nothing")
+        return
+    elseif verdict == interlaced_tff then
+        mp.set_property("field-dominance", "top")
+    elseif verdict == interlaced_bff then
+        mp.set_property("field-dominance", "bottom")
+    elseif verdict == interlaced then
+        mp.set_property("field-dominance", "auto")
+    end
+
+    local cmd = string.format("vf pre @%s:pullup", pullup_label)
+    if not mp.command(cmd) then
+        mp.msg.error("failed to insert pullup filter")
+        stop_detect()
+        return
+    end
+
+    -- redo the detection with the pullup filter to see if it's telecined
+    mp.set_property("percent-pos", percent_pos)
+    timer = mp.add_timeout(detect_seconds, judge_ivtc)
+end
+
+function judge_ivtc()
+    verdict = judge()
+
+    if verdict == progressive then
+        mp.msg.info(string.format("telecinied with %s field dominance: using pullup", mp.get_property("field-dominance")))
+        stop_detect()
+    else
+        mp.msg.info(string.format("interlaced with %s field dominance: setting deinterlace property", mp.get_property("field-dominance")))
+        del_filter_if_present(pullup_label)
+        mp.set_property("deinterlace","yes")
+        stop_detect()
+    end
+
+    return
+end
+
+mp.add_key_binding("ctrl+d", script_name, start_detect)

TOOLS/lua/autoload.lua

@@ -25,7 +25,13 @@ function find_and_add_entries()
         return
     end
     local files = mputils.readdir(dir, "files")
+    if files == nil then
+        return
+    end
     table.sort(files)
+    if dir == "." then
+        dir = ""
+    end
     local pl = mp.get_property_native("playlist", {})
     local pl_current = mp.get_property_number("playlist-pos", 0) + 1
     -- Find the current pl entry (dir+"/"+filename) in the sorted dir list
@@ -40,27 +46,28 @@ function find_and_add_entries()
         return
     end
     local append = {[-1] = {}, [1] = {}}
-    for dir = -1, 1, 2 do -- 2 iterations, with dir = -1 and +1
+    for direction = -1, 1, 2 do -- 2 iterations, with direction = -1 and +1
         for i = 1, MAXENTRIES do
-            local file = files[current + i * dir]
-            local pl_e = pl[pl_current + i * dir]
+            local file = files[current + i * direction]
+            local pl_e = pl[pl_current + i * direction]
             if file == nil or file[1] == "." then
                 break
             end
+            local filepath = dir .. file
             if pl_e then
                 -- If there's a playlist entry, and it's the same file, stop.
-                if pl_e.filename == file then
+                if pl_e.filename == filepath then
                     break
                 end
             end
-            if dir == -1 then
+            if direction == -1 then
                 if pl_current == 1 then -- never add additional entries in the middle
                     mp.msg.info("Prepending " .. file)
-                    table.insert(append[-1], 1, file)
+                    table.insert(append[-1], 1, filepath)
                 end
             else
                 mp.msg.info("Adding " .. file)
-                table.insert(append[1], file)
+                table.insert(append[1], filepath)
             end
         end
     end

TOOLS/lua/cycle-deinterlace-pullup.lua

@@ -20,9 +20,9 @@ pullup_label = string.format("%s-pullup", script_name)
 
 function pullup_on()
     for i,vf in pairs(mp.get_property_native('vf')) do
-	if vf['label'] == pullup_label then
-	    return "yes"
-	end
+        if vf['label'] == pullup_label then
+            return "yes"
+        end
     end
     return "no"
 end

TOOLS/lua/drc-control.lua

@@ -21,30 +21,30 @@ script_name = mp.get_script_name()
 
 function print_state(params)
     if params then
-	mp.osd_message(script_name..":\n"
-			   .."method = "..params["method"].."\n"
-			   .."target = "..params["target"])
+        mp.osd_message(script_name..":\n"
+                           .."method = "..params["method"].."\n"
+                           .."target = "..params["target"])
     else
-	mp.osd_message(script_name..":\noff")
+        mp.osd_message(script_name..":\noff")
     end
 end
 
 function get_index_of_drc(afs)
     for i,af in pairs(afs) do
-	if af["label"] == script_name then
-	    return i
-	end
+        if af["label"] == script_name then
+            return i
+        end
     end
 end
 
 function append_drc(afs)
     afs[#afs+1] = {
-	name   = "drc",
-	label  = script_name,
-	params = {
-	    method = "1",
-	    target = "0.25"
-	}
+        name   = "drc",
+        label  = script_name,
+        params = {
+            method = "1",
+            target = "0.25"
+        }
     }
     print_state(afs[#afs]["params"])
 end
@@ -53,34 +53,34 @@ function modify_or_create_af(fun)
     afs = mp.get_property_native("af")
     i = get_index_of_drc(afs)
     if not i then
-	append_drc(afs)
+        append_drc(afs)
     else
-	fun(afs, i)
+        fun(afs, i)
     end
     mp.set_property_native("af", afs)
 end
 
 function drc_toggle_method_handler()
     modify_or_create_af(
-	function (afs, i)
-	    new_method=(afs[i]["params"]["method"]+1)%3
-	    if new_method == 0 then
-		table.remove(afs, i)
-		print_state(nil)
-	    else
-		afs[i]["params"]["method"] = tostring((afs[i]["params"]["method"])%2+1)
-		print_state(afs[i]["params"])
-	    end
-	end
+        function (afs, i)
+            new_method=(afs[i]["params"]["method"]+1)%3
+            if new_method == 0 then
+                table.remove(afs, i)
+                print_state(nil)
+            else
+                afs[i]["params"]["method"] = tostring((afs[i]["params"]["method"])%2+1)
+                print_state(afs[i]["params"])
+            end
+        end
     )
 end
 
 function drc_scale_target(factor)
     modify_or_create_af(
-	function (afs)
-	    afs[i]["params"]["target"] = tostring(afs[i]["params"]["target"]*factor)
-	    print_state(afs[i]["params"])
-	end
+        function (afs)
+            afs[i]["params"]["target"] = tostring(afs[i]["params"]["target"]*factor)
+            print_state(afs[i]["params"])
+        end
     )
 end
 

TOOLS/lua/observe-all.lua

@@ -1,16 +1,14 @@
 -- Test script for property change notification mechanism.
+-- Note that watching/reading some properties can be very expensive, or
+-- require the player to synchronously wait on network (when playing
+-- remote files), so you should in general only watch properties you
+-- are interested in.
 
-function format_property_val(v)
-    if type(v) == "table" then
-        return mp.format_table(v) -- undocumented function; might be removed
-    else
-        return tostring(v)
-    end
-end
+local utils = require("mp.utils")
 
 for i,name in ipairs(mp.get_property_native("property-list")) do
     mp.observe_property(name, "native", function(name, val)
         print("property '" .. name .. "' changed to '" ..
-              format_property_val(val) .. "'")
+              utils.to_string(val) .. "'")
     end)
 end

TOOLS/lua/pause-when-minimize.lua

@@ -0,0 +1,22 @@
+-- This script pauses playback when minimizing the window, and resumes playback
+-- if it's brought back again. If the player was already paused when minimizing,
+-- then try not to mess with the pause state.
+
+-- Note: currently works with X11 only.
+
+local did_minimize = false
+
+mp.observe_property("window-minimized", "bool", function(name, value)
+    local pause = mp.get_property_native("pause")
+    if value == true then
+        if pause == false then
+            mp.set_property_native("pause", true)
+            did_minimize = true
+        end
+    elseif value == false then
+        if did_minimize and (pause == true) then
+            mp.set_property_native("pause", false)
+        end
+        did_minimize = false
+    end
+end)

TOOLS/matroska.pl

@@ -64,7 +64,7 @@ sub generate_c_header {
 
         # Output a counter variable for each element
         # (presence/absence for scalars, item count for arrays)
-        for my $subel (values %{$el->{subelements}}) {
+        for my $subel (sort values %{$el->{subelements}}) {
             print "    int n_$subel->{fieldname};\n"
         }
         print "};\n";

TOOLS/mpv_identify.sh

@@ -17,157 +17,134 @@
 # When multiple files were specified, their info will be put into FOO_* for the
 # first file, FOO_1_* for the second file, FOO_2_* for the third file, etc.
 
-case "$0" in
-    mpv_identify.sh|*/mpv_identify.sh)
-        # we are NOT being sourced
-        case "$1" in
-            '')
+__midentify__main() {
+
+    case "$0" in
+        mpv_identify.sh|*/mpv_identify.sh)
+            # we are NOT being sourced
+            [ -n "$1" ] && set -- '' "$@"
+            ;;
+    esac
+
+    if [ "$#" -lt 2 ]; then
+        cat >&2 <<EOF
+Usage 1 (for humans only): $0 filename.mkv
+will print all property values.
+Note that this output really shouldn't be parsed, as the
+format is subject to change.
+
+Usage 2 (for use by scripts): see top of this file
+
+NOTE: for mkv with ordered chapters, this may
+not always identify the specified file, but the
+file providing the first chapter. Specify
+--no-ordered-chapters to prevent this.
+EOF
+        return 2
+    fi
+
+    local LF="
+"
+
+    local nextprefix="$1"
+    shift
+
+    if [ -n "$nextprefix" ]; then
+        # in case of error, we always want this unset
+        unset "${nextprefix}path"
+    fi
+
+    local allprops="
+        filename
+        path
+        stream-start
+        stream-end
+        stream-length
+
+        demuxer
+
+        length
+        chapters
+        editions
+        titles
+
+        audio
+        audio-bitrate
+        audio-codec
+        audio-format
+        channels
+        samplerate
+
+        video
+        angle
+        video-bitrate
+        video-codec
+        video-format
+        video-aspect
+        fps
+        width
+        height
+        dwidth
+        dheight
+
+        sub
+    "
+    # TODO add metadata support once mpv can do it
+
+    local propstr="X-MIDENTIFY-START:$LF"
+    local key
+    for key in $allprops; do
+        propstr="${propstr}X-MIDENTIFY: $key \${=$key}$LF"
+        key="$(printf '%s\n' "$key" | tr - _)"
+        unset "$nextprefix$key"
+    done
+
+    local fileindex=0
+    local prefix=
+    local line
+    while IFS= read -r line; do
+        case "$line" in
+            X-MIDENTIFY-START:)
+                if [ -n "$nextprefix" ]; then
+                    prefix="$nextprefix"
+                    if [ "$fileindex" -gt 0 ]; then
+                        nextprefix="${prefix%${fileindex}_}"
+                    fi
+                    fileindex="$((fileindex+1))"
+                    nextprefix="${nextprefix}${fileindex}_"
+                    for key in $allprops; do
+                        key="$(printf '%s\n' "$key" | tr - _)"
+                        unset "$nextprefix$key"
+                    done
+                else
+                    if [ "$fileindex" -gt 0 ]; then
+                        printf '\n'
+                    fi
+                    fileindex="$((fileindex+1))"
+                fi
                 ;;
-            *)
-                set -- '' "$@"
+            X-MIDENTIFY:\ *)
+                local key="${line#X-MIDENTIFY: }"
+                local value="${key#* }"
+                key="${key%% *}"
+                key="$(printf '%s\n' "$key" | tr - _)"
+                if [ -n "$nextprefix" ]; then
+                    if [ -z "$prefix" ]; then
+                        echo >&2 "Got X-MIDENTIFY: without X-MIDENTIFY-START:"
+                    elif [ -n "$value" ]; then
+                        eval "$prefix$key"='"$value"'
+                    fi
+                else
+                    if [ -n "$value" ]; then
+                        printf '%s=%s\n' "$key" "$value"
+                    fi
+                fi
                 ;;
         esac
-        ;;
-esac
+    done <<EOF
+$(${MPV:-mpv} --term-playing-msg="$propstr" --vo=null --ao=null \
+              --frames=1 --quiet --no-cache --no-config -- "$@")
+EOF
+}
 
-if [ $# -lt 2 ]; then
-    echo >&2 "Usage 1 (for humans only): $0 filename.mkv"
-    echo >&2 "will print all property values."
-    echo >&2 "Note that this output really shouldn't be parsed, as the"
-    echo >&2 "format is subject to change."
-    echo >&2
-    echo >&2 "Usage 2 (for use by scripts): see top of this file"
-    echo >&2
-    echo >&2 "NOTE: for mkv with ordered chapters, this may"
-    echo >&2 "not always identify the specified file, but the"
-    echo >&2 "file providing the first chapter. Specify"
-    echo >&2 "--no-ordered-chapters to prevent this."
-    exit 1
-fi
-
-if [ -z "$MPV" ]; then
-    MPV="mpv"
-fi
-
-__midentify__LF="
-"
-
-__midentify__nextprefix=$1
-shift
-
-if [ -n "$__midentify__nextprefix" ]; then
-    # in case of error, we always want this unset
-    eval unset $__midentify__nextprefix'path'
-fi
-
-__midentify__allprops="
-    filename
-    path
-    stream-start
-    stream-end
-    stream-length
-
-    demuxer
-
-    length
-    chapters
-    editions
-    titles
-
-    audio
-    audio-bitrate
-    audio-codec
-    audio-format
-    channels
-    samplerate
-
-    video
-    angle
-    video-bitrate
-    video-codec
-    video-format
-    video-aspect
-    fps
-    width
-    height
-    dwidth
-    dheight
-
-    sub
-"
-# TODO add metadata support once mpv can do it
-
-__midentify__propstr="X-MIDENTIFY-START:$__midentify__LF"
-for __midentify__key in $__midentify__allprops; do
-    __midentify__propstr=$__midentify__propstr"X-MIDENTIFY: $__midentify__key \${=$__midentify__key}$__midentify__LF"
-    __midentify__key=`echo "$__midentify__key" | tr - _`
-    eval unset $__midentify__nextprefix$__midentify__key
-done
-
-__midentify__output=`$MPV --term-playing-msg="$__midentify__propstr" --vo=null --ao=null --frames=1 --quiet --no-cache --no-config "$@"`
-__midentify__fileindex=0
-__midentify__prefix=
-while :; do
-    case "$__midentify__output" in
-        '')
-            break
-            ;;
-        *$__midentify__LF*)
-            __midentify__line=${__midentify__output%%$__midentify__LF*}
-            __midentify__output=${__midentify__output#*$__midentify__LF}
-            ;;
-        *)
-            __midentify__line=$__midentify__output
-            __midentify__output=
-            ;;
-    esac
-    case "$__midentify__line" in
-        X-MIDENTIFY-START:)
-            if [ -n "$__midentify__nextprefix" ]; then
-                __midentify__prefix=$__midentify__nextprefix
-                if [ $__midentify__fileindex -gt 0 ]; then
-                    __midentify__nextprefix=${__midentify__prefix%$__midentify__fileindex\_}
-                fi
-                __midentify__fileindex=$(($__midentify__fileindex+1))
-                __midentify__nextprefix=$__midentify__nextprefix$__midentify__fileindex\_
-                for __midentify__key in $__midentify__allprops; do
-                    __midentify__key=`echo "$__midentify__key" | tr - _`
-                    eval unset $__midentify__nextprefix$__midentify__key
-                done
-            else
-                if [ $__midentify__fileindex -gt 0 ]; then
-                    echo
-                fi
-                __midentify__fileindex=$(($__midentify__fileindex+1))
-            fi
-            ;;
-        X-MIDENTIFY:\ *)
-            __midentify__key=${__midentify__line#X-MIDENTIFY:\ }
-            __midentify__value=${__midentify__key#* }
-            __midentify__key=${__midentify__key%% *}
-            __midentify__key=`echo "$__midentify__key" | tr - _`
-            if [ -n "$__midentify__nextprefix" ]; then
-                if [ -z "$__midentify__prefix" ]; then
-                    echo >&2 "Got X-MIDENTIFY: without X-MIDENTIFY-START:"
-                elif [ -n "$__midentify__value" ]; then
-                    eval $__midentify__prefix$__midentify__key=\$__midentify__value
-                fi
-            else
-                if [ -n "$__midentify__value" ]; then
-                    echo "$__midentify__key=$__midentify__value"
-                fi
-            fi
-            ;;
-    esac
-done
-
-unset __midentify__fileindex
-unset __midentify__allprops
-unset __midentify__key
-unset __midentify__LF
-unset __midentify__line
-unset __midentify__output
-unset __midentify__nextprefix
-unset __midentify__prefix
-unset __midentify__propstr
-unset __midentify__value
+__midentify__main "$@"

TOOLS/osxbundle.py

@@ -3,6 +3,7 @@
 import os
 import shutil
 import sys
+import fileinput
 from optparse import OptionParser
 
 def sh(command):
@@ -35,7 +36,8 @@ def copy_binary(binary_name):
     shutil.copy(binary_name, target_binary(binary_name))
 
 def apply_plist_template(plist_file, version):
-    sh("sed -i -e 's/${VERSION}/%s/g' %s" % (version, plist_file))
+    for line in fileinput.input(plist_file, inplace=1):
+        print (line.rstrip().replace('${VERSION}', version))
 
 def main():
     version = sh("./version.sh --print").strip()

TOOLS/osxbundle/mpv.app/Contents/Info.plist

@@ -88,6 +88,7 @@
           <string>VOB</string>
           <string>WEBM</string>
           <string>WMV</string>
+          <string>MK3D</string>
           <string>asf</string>
           <string>avi</string>
           <string>cpk</string>
@@ -122,6 +123,7 @@
           <string>vob</string>
           <string>webm</string>
           <string>wmv</string>
+          <string>mk3d</string>
         </array>
         <key>CFBundleTypeIconFile</key>
         <string>document.icns</string>
@@ -208,6 +210,7 @@
           <string>mms</string>
           <string>mmst</string>
           <string>http</string>
+          <string>https</string>
           <string>httpproxy</string>
           <string>rtp</string>
           <string>rtsp</string>
@@ -513,6 +516,47 @@
           <key>public.filename-extension</key>
           <array>
             <string>mkv</string>
+          </array>
+        </dict>
+      </dict>
+      <dict>
+        <key>UTTypeConformsTo</key>
+        <array>
+          <string>public.movie</string>
+        </array>
+        <key>UTTypeDescription</key>
+        <string>Matroska stereoscopic/3D video</string>
+        <key>UTTypeIconFile</key>
+        <string>document.icns</string>
+        <key>UTTypeIdentifier</key>
+        <string>io.mpv.mk3d</string>
+        <key>UTTypeReferenceURL</key>
+        <string>http://www.matroska.org</string>
+        <key>UTTypeTagSpecification</key>
+        <dict>
+          <key>public.filename-extension</key>
+          <array>
+            <string>mk3d</string>
+          </array>
+        </dict>
+      </dict>
+      <dict>
+        <key>UTTypeConformsTo</key>
+        <array>
+          <string>public.movie</string>
+        </array>
+        <key>UTTypeDescription</key>
+        <string>WebM Video</string>
+        <key>UTTypeIconFile</key>
+        <string>document.icns</string>
+        <key>UTTypeIdentifier</key>
+        <string>io.mpv.webm</string>
+        <key>UTTypeReferenceURL</key>
+        <string>http://www.webmproject.org</string>
+        <key>UTTypeTagSpecification</key>
+        <dict>
+          <key>public.filename-extension</key>
+          <array>
             <string>webm</string>
           </array>
         </dict>

TOOLS/osxbundle/mpv.app/Contents/Resources/mpv.conf

@@ -0,0 +1,3 @@
+screenshot-template=~/Desktop/shot%n
+quiet
+idle=once

TOOLS/stats-conv.py

@@ -1,9 +1,12 @@
 #!/usr/bin/env python3
 import matplotlib.pyplot as plot
 import sys
+import re
 
 filename = sys.argv[1]
 
+event_regex = re.compile(".*")
+
 """
 This script is meant to display stats written by mpv --dump-stats=filename.
 In general, each line in that file is an event of the form:
@@ -18,79 +21,115 @@ e.g.:
 
 Currently, the following event types are supported:
 
-    'start' <name>          start of the named event
-    'end' <name>            end of the named event
-    'value' <float> <name>  a normal value (as opposed to event)
-    <event>                 singular event
+    'signal' <name>             singular event
+    'start' <name>              start of the named event
+    'end' <name>                end of the named event
+    'value' <float> <name>      a normal value (as opposed to event)
+    'event-timed' <ts> <name>   singular event at the given timestamp
+    'value-timed' <ts> <float> <name>
+                                a value for an event at the given timestamp
+    <name>                      singular event (same as 'signal')
 
 """
 
 class G:
     events = {}
-    sevents = []  # events, deterministically sorted
     start = None
+    # http://matplotlib.org/api/markers_api.html#module-matplotlib.markers
+    markers = ["o", "8", "s", "p", "*", "h", "+", "x", "D"]
+
+def find_marker():
+    if len(G.markers) == 0:
+        return "o"
+    m = G.markers[0]
+    G.markers = G.markers[1:]
+    return m
 
 class Event:
     pass
 
-def get_event(event):
+def get_event(event, evtype):
     if event not in G.events:
         e = Event()
-        G.events[event] = e
         e.name = event
         e.vals = []
-        e.type = "unknown"
-        G.sevents = list(G.events.values())
-        G.sevents.sort(key=lambda x: x.name)
+        e.type = evtype
+        e.marker = "o"
+        if e.type == "event-signal":
+            e.marker = find_marker()
+        if not event_regex.match(e.name):
+            return e
+        G.events[event] = e
     return G.events[event]
 
+SCALE = 1e6 # microseconds to seconds
+
 for line in [line.split("#")[0].strip() for line in open(filename, "r")]:
     line = line.strip()
     if not line:
         continue
     ts, event = line.split(" ", 1)
-    ts = int(ts) / 1000 # milliseconds
+    ts = int(ts) / SCALE
     if G.start is None:
         G.start = ts
     ts = ts - G.start
     if event.startswith("start "):
-        e = get_event(event[6:])
-        e.type = "event"
+        e = get_event(event[6:], "event")
         e.vals.append((ts, 0))
         e.vals.append((ts, 1))
     elif event.startswith("end "):
-        e = get_event(event[4:])
-        e.type = "event"
+        e = get_event(event[4:], "event")
         e.vals.append((ts, 1))
         e.vals.append((ts, 0))
     elif event.startswith("value "):
         _, val, name = event.split(" ", 2)
         val = float(val)
-        e = get_event(name)
-        e.type = "value"
+        e = get_event(name, "value")
         e.vals.append((ts, val))
+    elif event.startswith("event-timed "):
+        _, val, name = event.split(" ", 2)
+        val = int(val) / SCALE - G.start
+        e = get_event(name, "event-signal")
+        e.vals.append((val, 1))
+    elif event.startswith("value-timed "):
+        _, tsval, val, name = event.split(" ", 3)
+        tsval = int(tsval) / SCALE - G.start
+        val = float(val)
+        e = get_event(name, "value")
+        e.vals.append((tsval, val))
+    elif event.startswith("signal "):
+        name = event.split(" ", 2)[1]
+        e = get_event(name, "event-signal")
+        e.vals.append((ts, 1))
     else:
-        e = get_event(event)
-        e.type = "event-signal"
+        e = get_event(event, "event-signal")
         e.vals.append((ts, 1))
 
-ao_events = ["ao fill", "audio wait"]
-for e in G.sevents:
-    if e.name in ao_events:
-        e.vals = [(x, y * 0.5) for (x, y) in e.vals]
-
-plot.hold(True)
-mainpl = plot.subplot(2, 1, 1)
-legend = []
-for e in G.sevents:
+# deterministically sort them; make sure the legend is sorted too
+G.sevents = list(G.events.values())
+G.sevents.sort(key=lambda x: x.name)
+hasval = False
+for e, index in zip(G.sevents, range(len(G.sevents))):
+    m = len(G.sevents)
     if e.type == "value":
-        plot.subplot(2, 1, 2, sharex=mainpl)
+        hasval = True
     else:
-        plot.subplot(2, 1, 1)
-    pl, = plot.plot([x for x,y in e.vals], [y for x,y in e.vals], label=e.name)
+        e.vals = [(x, y * (m - index) / m) for (x, y) in e.vals]
+
+fig = plot.figure()
+fig.hold(True)
+ax = [None, None]
+plots = 2 if hasval else 1
+ax[0] = fig.add_subplot(plots, 1, 1)
+if hasval:
+    ax[1] = fig.add_subplot(plots, 1, 2, sharex=ax[0])
+legends = [[], []]
+for e in G.sevents:
+    cur = ax[1 if e.type == "value" else 0]
+    pl, = cur.plot([x for x,y in e.vals], [y for x,y in e.vals], label=e.name)
     if e.type == "event-signal":
-        plot.setp(pl, marker = "o", linestyle = "None")
-    legend.append(pl)
-plot.subplot(2, 1, 1)
-plot.legend(legend, [pl.get_label() for pl in legend])
+        plot.setp(pl, marker = e.marker, linestyle = "None")
+for cur in ax:
+    if cur is not None:
+        cur.legend()
 plot.show()

TOOLS/umpv

@@ -21,20 +21,13 @@ script after that will start a new mpv instance.
 
 Note that you can control the mpv instance by writing to the command fifo:
 
-    echo "cycle fullscreen" > /tmp/umpv-fifo-*
+    echo "cycle fullscreen" > ~/.umpv-fifo
 
-Note: you can supply custom options with the UMPV_OPTIONS environment variable.
-      The environment variable will be split on whitespace, and each item is
-      passed as option to mpv _if_ the script starts mpv. If mpv is not started
-      by the script (i.e. mpv is already running), the options will be ignored.
-
-Warning:
-
-The script attempts to make sure the FIFO is safely created (i.e. not world-
-writable), and checks that it's really a FIFO. This is important for security,
-because the FIFO allows anyone with write access to run arbitrary commands
-in mpv's context using the "run" input command. If you are worried about
-security, you should verify that the code handles these concerns correctly.
+Note: you can supply custom mpv path and options with the MPV environment
+      variable. The environment variable will be split on whitespace, and the
+      first item is used as path to mpv binary and the rest is passed as options
+      _if_ the script starts mpv. If mpv is not started by the script (i.e. mpv
+      is already running), this will be ignored.
 """
 
 import sys
@@ -45,21 +38,17 @@ import fcntl
 import stat
 import string
 
-if len(sys.argv) < 1:
-    sys.exit(1)
 files = sys.argv[1:]
 
-# this is about the same method mpv uses to decide this
+# this is the same method mpv uses to decide this
 def is_url(filename):
-    parts = filename.split(":", 1)
+    parts = filename.split("://", 1)
     if len(parts) < 2:
         return False
     # protocol prefix has no special characters => it's an URL
+    allowed_symbols = string.ascii_letters + string.digits + '_'
     prefix = parts[0]
-    for c in prefix:
-        if string.ascii_letters.find(c) < 0:
-            return False
-    return True
+    return all(map(lambda c: c in allowed_symbols, prefix))
 
 # make them absolute; also makes them safe against interpretation as options
 def make_abs(filename):
@@ -68,10 +57,7 @@ def make_abs(filename):
     return filename
 files = [make_abs(f) for f in files]
 
-opts_env = os.getenv("UMPV_OPTIONS")
-opts_env = opts_env.split() if opts_env else []
-
-FIFO = "/tmp/umpv-fifo-" + os.getenv("USER")
+FIFO = os.path.join(os.getenv("HOME"), ".umpv_fifo")
 
 fifo_fd = -1
 try:
@@ -84,14 +70,6 @@ except OSError as e:
     else:
         raise e
 
-if fifo_fd >= 0:
-    st = os.fstat(fifo_fd)
-    if (((st.st_mode & (stat.S_IRWXG | stat.S_IRWXO)) != 0) or
-        (not stat.S_ISFIFO(st.st_mode)) or
-        (st.st_uid != os.getuid())):
-        print("error: command FIFO is not a FIFO or has bogus permissions")
-        sys.exit(1)
-
 if fifo_fd >= 0:
     # Unhandled race condition: what if mpv is terminating right now?
     fcntl.fcntl(fifo_fd, fcntl.F_SETFL, 0) # set blocking mode
@@ -108,15 +86,12 @@ else:
     try:
         os.unlink(FIFO)
     except OSError as e:
-        if e.errno == errno.ENOENT:
-            pass
-        else:
-            raise e
-    os.mkfifo(FIFO, int("0600", 8))
+        pass
+    os.mkfifo(FIFO, 0o600)
 
-    opts = ["mpv", "--no-terminal", "--force-window", "--input-file=" + FIFO]
-    opts.extend(opts_env)
-    opts.append("--")
+    opts = (os.getenv("MPV") or "mpv").split()
+    opts.extend(["--no-terminal", "--force-window", "--input-file=" + FIFO,
+                 "--"])
     opts.extend(files)
 
     subprocess.check_call(opts)

TOOLS/vf_dlopen/Makefile

@@ -19,7 +19,7 @@
 # 02110-1301 USA
 #
 
-FILTERS = showqscale telecine tile rectangle framestep ildetect
+FILTERS = telecine tile rectangle framestep ildetect
 COMMON = filterutils.o
 
 OBJECTS = $(patsubst %,%.o,$(FILTERS)) $(COMMON)

TOOLS/vf_dlopen/framestep.c

@@ -90,8 +90,7 @@ int vf_dlopen_getcontext(struct vf_dlopen_context *ctx, int argc, const char **a
     if (argc != 1 && argc != 2)
         return -1;
 
-    framestep_data_t *framestep = malloc(sizeof(framestep_data_t));
-    memset(framestep, 0, sizeof(*framestep));
+    framestep_data_t *framestep = calloc(1,sizeof(framestep_data_t));
 
     framestep->step = atoi(argv[0]);
     framestep->pos = (argc >= 2) ? atoi(argv[1]) : 0;

TOOLS/vf_dlopen/ildetect.c

@@ -267,8 +267,7 @@ int vf_dlopen_getcontext(struct vf_dlopen_context *ctx, int argc, const char **a
     (void) argc;
     (void) argv;
 
-    ildetect_data_t *il = malloc(sizeof(ildetect_data_t));
-    memset(il, 0, sizeof(*il));
+    ildetect_data_t *il = calloc(1,sizeof(ildetect_data_t));
 
 #define A(i,d) ((argc>(i) && *argv[i]) ? atof(argv[i]) : (d))
     il->method = A(0, 0);

TOOLS/vf_dlopen/ildetect.sh

@@ -11,7 +11,6 @@ esac
 
 : ${MPV:=mpv}
 : ${ILDETECT_MPV:=$MPV}
-: ${ILDETECT_MPV:=$MPV}
 : ${ILDETECT_MPVFLAGS:=--start=35% --length=35}
 : ${ILDETECT_DRY_RUN:=}
 : ${ILDETECT_QUIET:=}

TOOLS/vf_dlopen/rectangle.c

@@ -348,8 +348,7 @@ int vf_dlopen_getcontext(struct vf_dlopen_context *ctx, int argc, const char **a
         { "yuv420p", "yuv420p" },
         { NULL, NULL }
     };
-    privdata *priv = malloc(sizeof(privdata));
-    memset(priv, 0, sizeof(*priv));
+    privdata *priv = calloc(1,sizeof(privdata));
     priv->step = 8;
     if(argc >= 1)
         priv->w = atoi(argv[0]);

TOOLS/vf_dlopen/showqscale.c

@@ -1,120 +0,0 @@
-/*
- * Copyright (c) 2012 Rudolf Polzer <divVerent@xonotic.org>
- *
- * This file is part of mpv's vf_dlopen examples.
- *
- * mpv's vf_dlopen examples are free software; you can redistribute them and/or
- * modify them under the terms of the GNU Lesser General Public License as
- * published by the Free Software Foundation; either version 2.1 of the
- * License, or (at your option) any later version.
- *
- * mpv's vf_dlopen examples are distributed in the hope that they will be
- * useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser
- * General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with mpv's vf_dlopen examples; if not, write to the Free
- * Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
- * 02110-1301 USA
- */
-
-#include <assert.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include "vf_dlopen.h"
-
-/*
- * qscale visualizer
- *
- * usage: --vf=dlopen=/path/to/showqscale.so
- *
- * uses reddish colors for high QPs, and greenish colors for low QPs
- */
-
-#define PLANE_Y 0
-#define PLANE_U 1
-#define PLANE_V 2
-
-static int qs_put_image(struct vf_dlopen_context *ctx)
-{
-    unsigned int x, y, p;
-
-    assert(ctx->inpic.planes == ctx->outpic[0].planes);
-
-    for (p = 0; p < ctx->outpic[0].planes; ++p) {
-        assert(ctx->inpic.planewidth[p] == ctx->outpic[0].planewidth[p]);
-        assert(ctx->inpic.planeheight[p] == ctx->outpic[0].planeheight[p]);
-        if ((p == PLANE_U || p == PLANE_V) && ctx->inpic_qscale)
-            continue;
-#if 0
-        // copy as is
-        for (y = 0; y < ctx->outpic[0].planeheight[p]; ++y)
-            memcpy(
-                &ctx->outpic[0].plane[p][ctx->outpic[0].planestride[p] * y],
-                &inpic[ctx->outpic[0].planeofs[p] + ctx->inpic.planestride[p] * y],
-                ctx->outpic[0].planewidth[p]
-                );
-#else
-        // reduce contrast
-        for (y = 0; y < ctx->outpic[0].planeheight[p]; ++y)
-            for (x = 0; x < ctx->outpic[0].planewidth[p]; ++x)
-                ctx->outpic[0].plane[p][ctx->outpic[0].planestride[p] * y + x] =
-                    0x20 + ((ctx->inpic.plane[p][ctx->inpic.planestride[p] * y + x] * 3) >> 2);
-#endif
-    }
-
-    if (ctx->inpic_qscale) {
-        int qmin = 255;
-        int qmax = -255;
-
-        // clear U plane
-        p = PLANE_U;
-        for (y = 0; y < ctx->outpic[0].planeheight[p]; ++y)
-            memset(
-                &ctx->outpic[0].plane[p][ctx->outpic[0].planestride[p] * y],
-                0x80,
-                ctx->outpic[0].planewidth[p]
-                );
-
-        // replace V by the qp (0 = green, 12 = red)
-        p = PLANE_V;
-        for (y = 0; y < ctx->outpic[0].planeheight[p]; ++y)
-            for (x = 0; x < ctx->outpic[0].planewidth[p]; ++x) {
-                int q = ctx->inpic_qscale[
-                    (x >> (ctx->inpic_qscaleshift - ctx->inpic.planexshift[p])) +
-                    (y >> (ctx->inpic_qscaleshift - ctx->inpic.planeyshift[p])) * ctx->inpic_qscalestride];
-                if (q < qmin)
-                    qmin = q;
-                if (q > qmax)
-                    qmax = q;
-                int v = 128 + 21 * (q - 6); // range: 0 = green, 12 = red
-                if (v < 0)
-                    v = 0;
-                if (v > 255)
-                    v = 255;
-                ctx->outpic[0].plane[p][ctx->outpic[0].planestride[p] * y + x] = v;
-            }
-
-        // printf("qscale range: %d .. %d\n", qmin, qmax);
-    }
-
-    ctx->outpic[0].pts = ctx->inpic.pts;
-    return 1;
-}
-
-int vf_dlopen_getcontext(struct vf_dlopen_context *ctx, int argc, const char **argv)
-{
-    VF_DLOPEN_CHECK_VERSION(ctx);
-    (void) argc;
-    (void) argv;
-    static struct vf_dlopen_formatpair map[] = {
-        { "yuv420p", "yuv420p" },
-        { NULL, NULL }
-    };
-    ctx->format_mapping = map;
-    ctx->put_image = qs_put_image;
-    return 1;
-}

TOOLS/vf_dlopen/telecine.c

@@ -237,8 +237,7 @@ int vf_dlopen_getcontext(struct vf_dlopen_context *ctx, int argc, const char **a
     if (!a0[0] || a0[1] || !a1[0] || argc > 2)
         return -1;
 
-    tc_data_t *tc = malloc(sizeof(tc_data_t));
-    memset(tc, 0, sizeof(*tc));
+    tc_data_t *tc = calloc(1,sizeof(tc_data_t));
 
     if (a0[0] == 't')
         tc->firstfield = 0;

TOOLS/vf_dlopen/tile.c

@@ -150,8 +150,7 @@ int vf_dlopen_getcontext(struct vf_dlopen_context *ctx, int argc, const char **a
     if (argc != 2)
         return -1;
 
-    tile_data_t *tile = malloc(sizeof(tile_data_t));
-    memset(tile, 0, sizeof(*tile));
+    tile_data_t *tile = calloc(1,sizeof(tile_data_t));
 
     tile->cols = atoi(argv[0]);
     tile->rows = atoi(argv[1]);

TOOLS/youtube-dl_mpv.sh

@@ -6,18 +6,17 @@ cookies_dir="$(mktemp -d /tmp/youtube-dl_mpv.XXXX)"
 cookies_file="${cookies_dir}/cookies"
 user_agent="$(youtube-dl --dump-user-agent)" # or set whatever you want
 
-video_url="$(youtube-dl \
-    --user-agent="$user_agent" \
-    --cookies="$cookies_file" \
+video_url=$(youtube-dl \
+    --user-agent="${user_agent}" \
+    --cookies="${cookies_file}" \
     --get-url \
-    "$1")"
+    "$@")
 
-shift
-
-mpv \
+set -f
+${MPV:-mpv} \
     --cookies \
-    --cookies-file="$cookies_file" \
-    --user-agent="$user_agent" \
-    "$@" -- $video_url
+    --cookies-file="${cookies_file}" \
+    --user-agent="${user_agent}" \
+    -- ${video_url}
 
-rm -rf "$cookies_dir"
+rm -rf "${cookies_dir}"

TOOLS/zsh.pl

@@ -7,7 +7,7 @@ use warnings;
 
 my $mpv = $ARGV[0] || 'mpv';
 
-my @opts = parse_opts("$mpv --list-options", '^ (\-\-[^\s\*]*)\*?\s*(.*)', 1);
+my @opts = parse_main_opts("$mpv --list-options", '^ (\-\-[^\s\*]*)\*?\s*(.*)');
 
 my @ao = parse_opts("$mpv --ao=help", '^  ([^\s\:]*)\s*: (.*)');
 my @vo = parse_opts("$mpv --vo=help", '^  ([^\s\:]*)\s*: (.*)');
@@ -37,6 +37,36 @@ chomp $vf_str;
 $protos_str .= qq{$_ } foreach (@protos);
 chomp $protos_str;
 
+my $profile_comp = <<'EOS';
+      local -a profiles
+      local current
+      for current in "${(@f)$($words[1] --profile=help)}"; do
+        current=${current//\*/\\\*}
+        current=${current//\:/\\\:}
+        current=${current//\[/\\\[}
+        current=${current//\]/\\\]}
+        if [[ $current =~ $'\t'([^$'\t']*)$'\t'(.*) ]]; then
+          if [[ -n $match[2] ]]; then
+            current="$match[1][$match[2]]"
+          else
+            current="$match[1]"
+          fi
+          profiles=($profiles $current)
+        fi
+      done
+      if [[ $state == show-profile ]]; then
+        # For --show-profile, only one allowed
+        if (( ${#profiles} > 0 )); then
+          _values 'profile' $profiles && rc=0
+        fi
+      else
+        # For --profile, multiple allowed
+        profiles=($profiles 'help[list profiles]')
+        _values -s , 'profile(s)' $profiles && rc=0
+      fi
+EOS
+chomp $profile_comp;
+
 my $tmpl = <<"EOS";
 #compdef mpv
 
@@ -88,12 +118,22 @@ $vf_str
     _describe -t values 'video filters' values && rc=0
   ;;
 
+  profile|show-profile)
+$profile_comp
+  ;;
+
+  files)
+    compset -P '*,'
+    compset -S ',*'
+    _files -r ',/ \\t\\n\\-' && rc=0
+  ;;
+
   mfiles)
     local expl
     _tags files urls
     while _tags; do
       _requested files expl 'media file' _files -g \\
-         "*.(#i)(asf|asx|avi|flac|flv|m1v|m2p|m2v|m4v|mjpg|mka|mkv|mov|mp3|mp4|mpe|mpeg|mpg|ogg|ogm|ogv|qt|rm|ts|vob|wav|webm|wma|wmv)(-.)" && rc=0
+        "*.(#i)(asf|asx|avi|flac|flv|m1v|m2p|m2v|m4v|mjpg|mka|mkv|mov|mp3|mp4|mpe|mpeg|mpg|ogg|ogm|ogv|qt|rm|ts|vob|wav|webm|wma|wmv)(-.)" && rc=0
       if _requested urls; then
         while _next_label urls expl URL; do
           _urls "\$expl[@]" && rc=0
@@ -110,8 +150,73 @@ EOS
 
 print $tmpl;
 
+sub parse_main_opts {
+    my ($cmd, $regex) = @_;
+
+    my @list;
+    my @lines = split /\n/, `$cmd`;
+
+    foreach my $line (@lines) {
+        my ($name, $desc) = ($line =~ /^$regex/) or next;
+
+        next if ($desc eq 'removed' || $desc eq 'alias');
+
+        if ($desc =~ /^Flag/) {
+
+            push @list, $name;
+
+            $name =~ /^--(.*)/;
+            if ($1 !~ /^(\{|\}|v|list-options|really-quiet|no-.*)$/) {
+                push @list, "--no-$1";
+            }
+
+        } elsif ($desc =~ /^Print/) {
+
+            push @list, $name;
+
+        } else {
+
+            # Option takes argument
+
+            my $entry = $name;
+
+            $desc =~ s/\:/\\:/g;
+            $entry .= "=-:$desc:";
+
+            if ($desc =~ /^Choices\\: ([^(]*)/) {
+                my $choices = $1;
+                $choices =~ s/ +$//; # strip trailing space
+                $entry .= "($choices)";
+
+                # If "no" is one of the choices, it can also be
+                # negated like a flag (--no-whatever).
+                if ($choices =~ /\bno\b/) {
+                    $name =~ s/^--/--no-/;
+                    push @list, $name;
+                }
+            } elsif ($line =~ /\[file\]/) {
+                $entry .= '->files';
+            } elsif ($name =~ /^--(ao|vo|af|vf|profile|show-profile)$/) {
+                $entry .= "->$1";
+            }
+            push @list, $entry;
+        }
+    }
+
+    # Sort longest first, because zsh won't complete an option listed
+    # after one that's a prefix of it.
+    @list = sort {
+        $a =~ /([^=]*)/; my $ma = $1;
+        $b =~ /([^=]*)/; my $mb = $1;
+
+        length($mb) <=> length($ma)
+    } @list;
+
+    return @list;
+}
+
 sub parse_opts {
-    my ($cmd, $regex, $parsing_main_options) = @_;
+    my ($cmd, $regex) = @_;
 
     my @list;
     my @lines = split /\n/, `$cmd`;
@@ -123,37 +228,14 @@ sub parse_opts {
 
         my $entry = $1;
 
-        if ($parsing_main_options) {
-            $entry .= '=-';
-        }
-
         if (defined $2) {
             my $desc = $2;
             $desc =~ s/\:/\\:/g;
-
             $entry .= ':' . $desc;
         }
 
-        if ($parsing_main_options) {
-            $entry .= ':';
-
-            $entry .= '->ao' if ($1 eq '--ao');
-            $entry .= '->vo' if ($1 eq '--vo');
-            $entry .= '->af' if ($1 eq '--af');
-            $entry .= '->vf' if ($1 eq '--vf');
-        }
-
         push @list, $entry
     }
 
-    if ($parsing_main_options) {
-        @list = sort {
-            $a =~ /(.*?)\:/; my $ma = $1;
-            $b =~ /(.*?)\:/; my $mb = $1;
-
-            length($mb) <=> length($ma)
-        } @list;
-    }
-
     return @list;
 }

VERSION

@@ -1 +1 @@
-0.5.3
+0.8.3

audio/audio.c

@@ -20,10 +20,13 @@
 #include <stdlib.h>
 #include <assert.h>
 
-#include <libavutil/mem.h>
+#include <libavutil/buffer.h>
+#include <libavutil/frame.h>
+#include <libavutil/version.h>
 
 #include "talloc.h"
 #include "common/common.h"
+#include "fmt-conversion.h"
 #include "audio.h"
 
 static void update_redundant_info(struct mp_audio *mpa)
@@ -88,18 +91,12 @@ bool mp_audio_config_valid(const struct mp_audio *mpa)
         && mpa->rate >= 1 && mpa->rate < 10000000;
 }
 
-char *mp_audio_fmt_to_str(int srate, const struct mp_chmap *chmap, int format)
+char *mp_audio_config_to_str_buf(char *buf, size_t buf_sz, struct mp_audio *mpa)
 {
-    char *chstr = mp_chmap_to_str(chmap);
-    char *res = talloc_asprintf(NULL, "%dHz %s %dch %s", srate, chstr,
-                                chmap->num, af_fmt_to_str(format));
-    talloc_free(chstr);
-    return res;
-}
-
-char *mp_audio_config_to_str(struct mp_audio *mpa)
-{
-    return mp_audio_fmt_to_str(mpa->rate, &mpa->channels, mpa->format);
+    snprintf(buf, buf_sz, "%dHz %s %dch %s", mpa->rate,
+             mp_chmap_to_str(&mpa->channels), mpa->channels.num,
+             af_fmt_to_str(mpa->format));
+    return buf;
 }
 
 void mp_audio_force_interleaved_format(struct mp_audio *mpa)
@@ -116,19 +113,27 @@ int mp_audio_psize(struct mp_audio *mpa)
 
 void mp_audio_set_null_data(struct mp_audio *mpa)
 {
-    for (int n = 0; n < MP_NUM_CHANNELS; n++)
+    for (int n = 0; n < MP_NUM_CHANNELS; n++) {
         mpa->planes[n] = NULL;
+        mpa->allocated[n] = NULL;
+    }
     mpa->samples = 0;
 }
 
+static int get_plane_size(const struct mp_audio *mpa, int samples)
+{
+    if (samples < 0 || !mp_audio_config_valid(mpa))
+        return -1;
+    if (samples >= INT_MAX / mpa->sstride)
+        return -1;
+    return MPMAX(samples * mpa->sstride, 1);
+}
+
 static void mp_audio_destructor(void *ptr)
 {
     struct mp_audio *mpa = ptr;
-    for (int n = 0; n < MP_NUM_CHANNELS; n++) {
-        // Note: don't free if not allocated by mp_audio_realloc
-        if (mpa->allocated[n])
-            av_free(mpa->planes[n]);
-    }
+    for (int n = 0; n < MP_NUM_CHANNELS; n++)
+        av_buffer_unref(&mpa->allocated[n]);
 }
 
 /* Reallocate the data stored in mpa->planes[n] so that enough samples are
@@ -147,27 +152,19 @@ static void mp_audio_destructor(void *ptr)
  */
 void mp_audio_realloc(struct mp_audio *mpa, int samples)
 {
-    assert(samples >= 0);
-    if (samples >= INT_MAX / mpa->sstride)
-        abort(); // oom
-    int size = MPMAX(samples * mpa->sstride, 1);
+    int size = get_plane_size(mpa, samples);
+    if (size < 0)
+        abort(); // oom or invalid parameters
     for (int n = 0; n < mpa->num_planes; n++) {
-        if (size != mpa->allocated[n]) {
-            // Note: av_realloc() can't be used (see libavutil doxygen)
-            void *new = av_malloc(size);
-            if (!new)
-                abort();
-            if (mpa->allocated[n])
-                memcpy(new, mpa->planes[n], MPMIN(mpa->allocated[n], size));
-            av_free(mpa->planes[n]);
-            mpa->planes[n] = new;
-            mpa->allocated[n] = size;
+        if (!mpa->allocated[n] || size != mpa->allocated[n]->size) {
+            if (av_buffer_realloc(&mpa->allocated[n], size) < 0)
+                abort(); // OOM
+            mpa->planes[n] = mpa->allocated[n]->data;
         }
     }
     for (int n = mpa->num_planes; n < MP_NUM_CHANNELS; n++) {
-        av_free(mpa->planes[n]);
+        av_buffer_unref(&mpa->allocated[n]);
         mpa->planes[n] = NULL;
-        mpa->allocated[n] = 0;
     }
     talloc_set_destructor(mpa, mp_audio_destructor);
 }
@@ -194,7 +191,7 @@ int mp_audio_get_allocated_size(struct mp_audio *mpa)
 {
     int size = 0;
     for (int n = 0; n < mpa->num_planes; n++) {
-        int s = mpa->allocated[n] / mpa->sstride;
+        int s = mpa->allocated[n] ? mpa->allocated[n]->size / mpa->sstride : 0;
         size = n == 0 ? s : MPMIN(size, s);
     }
     return size;
@@ -230,6 +227,14 @@ void mp_audio_copy(struct mp_audio *dst, int dst_offset,
     }
 }
 
+// Copy fields that describe characteristics of the audio frame, but which are
+// not part of the core format (format/channels/rate), and not part of the
+// data (samples).
+void mp_audio_copy_attributes(struct mp_audio *dst, struct mp_audio *src)
+{
+    // nothing yet
+}
+
 // Set data to the audio after the given number of samples (i.e. slice it).
 void mp_audio_skip_samples(struct mp_audio *data, int samples)
 {
@@ -240,3 +245,177 @@ void mp_audio_skip_samples(struct mp_audio *data, int samples)
 
     data->samples -= samples;
 }
+
+// Return false if the frame data is shared, true otherwise.
+// Will return true for non-refcounted frames.
+bool mp_audio_is_writeable(struct mp_audio *data)
+{
+    bool ok = true;
+    for (int n = 0; n < MP_NUM_CHANNELS; n++) {
+        if (data->allocated[n])
+            ok &= av_buffer_is_writable(data->allocated[n]);
+    }
+    return ok;
+}
+
+static void mp_audio_steal_data(struct mp_audio *dst, struct mp_audio *src)
+{
+    talloc_set_destructor(dst, mp_audio_destructor);
+    mp_audio_destructor(dst);
+    *dst = *src;
+    talloc_set_destructor(src, NULL);
+    talloc_free(src);
+}
+
+// Make sure the frame owns the audio data, and if not, copy the data.
+// Return negative value on failure (which means it can't be made writeable).
+// Non-refcounted frames are always considered writeable.
+int mp_audio_make_writeable(struct mp_audio *data)
+{
+    if (!mp_audio_is_writeable(data)) {
+        struct mp_audio *new = talloc(NULL, struct mp_audio);
+        *new = *data;
+        mp_audio_set_null_data(new); // use format only
+        mp_audio_realloc(new, data->samples);
+        new->samples = data->samples;
+        mp_audio_copy(new, 0, data, 0, data->samples);
+        mp_audio_steal_data(data, new);
+    }
+    return 0;
+}
+
+struct mp_audio *mp_audio_from_avframe(struct AVFrame *avframe)
+{
+    AVFrame *tmp = NULL;
+    struct mp_audio *new = talloc_zero(NULL, struct mp_audio);
+    talloc_set_destructor(new, mp_audio_destructor);
+
+    mp_audio_set_format(new, af_from_avformat(avframe->format));
+
+    struct mp_chmap lavc_chmap;
+    mp_chmap_from_lavc(&lavc_chmap, avframe->channel_layout);
+
+#if LIBAVUTIL_VERSION_MICRO >= 100
+    // FFmpeg being special again
+    if (lavc_chmap.num != avframe->channels)
+        mp_chmap_from_channels(&lavc_chmap, avframe->channels);
+#endif
+
+    new->rate = avframe->sample_rate;
+
+    mp_audio_set_channels(new, &lavc_chmap);
+
+    // Force refcounted frame.
+    if (!avframe->buf[0]) {
+        tmp = av_frame_alloc();
+        if (!tmp)
+            goto fail;
+        if (av_frame_ref(tmp, avframe) < 0)
+            goto fail;
+        avframe = tmp;
+    }
+
+    // If we can't handle the format (e.g. too many channels), bail out.
+    if (!mp_audio_config_valid(new) || avframe->nb_extended_buf)
+        goto fail;
+
+    for (int n = 0; n < AV_NUM_DATA_POINTERS; n++) {
+        if (!avframe->buf[n])
+            break;
+        if (n >= MP_NUM_CHANNELS)
+            goto fail;
+        new->allocated[n] = av_buffer_ref(avframe->buf[n]);
+        if (!new->allocated[n])
+            goto fail;
+    }
+
+    for (int n = 0; n < new->num_planes; n++)
+        new->planes[n] = avframe->data[n];
+    new->samples = avframe->nb_samples;
+
+    return new;
+
+fail:
+    talloc_free(new);
+    av_frame_free(&tmp);
+    return NULL;
+}
+
+struct mp_audio_pool {
+    AVBufferPool *avpool;
+    int element_size;
+};
+
+struct mp_audio_pool *mp_audio_pool_create(void *ta_parent)
+{
+    return talloc_zero(ta_parent, struct mp_audio_pool);
+}
+
+static void mp_audio_pool_destructor(void *p)
+{
+    struct mp_audio_pool *pool = p;
+    av_buffer_pool_uninit(&pool->avpool);
+}
+
+// Allocate data using the given format and number of samples.
+// Returns NULL on error.
+struct mp_audio *mp_audio_pool_get(struct mp_audio_pool *pool,
+                                   const struct mp_audio *fmt, int samples)
+{
+    int size = get_plane_size(fmt, samples);
+    if (size < 0)
+        return NULL;
+    if (!pool->avpool || size > pool->element_size) {
+        size_t alloc = ta_calc_prealloc_elems(size);
+        if (alloc >= INT_MAX)
+            return NULL;
+        av_buffer_pool_uninit(&pool->avpool);
+        pool->element_size = alloc;
+        pool->avpool = av_buffer_pool_init(pool->element_size, NULL);
+        if (!pool->avpool)
+            return NULL;
+        talloc_set_destructor(pool, mp_audio_pool_destructor);
+    }
+    struct mp_audio *new = talloc_ptrtype(NULL, new);
+    talloc_set_destructor(new, mp_audio_destructor);
+    *new = *fmt;
+    mp_audio_set_null_data(new);
+    new->samples = samples;
+    for (int n = 0; n < new->num_planes; n++) {
+        new->allocated[n] = av_buffer_pool_get(pool->avpool);
+        if (!new->allocated[n]) {
+            talloc_free(new);
+            return NULL;
+        }
+        new->planes[n] = new->allocated[n]->data;
+    }
+    return new;
+}
+
+// Return a copy of the given frame.
+// Returns NULL on error.
+struct mp_audio *mp_audio_pool_new_copy(struct mp_audio_pool *pool,
+                                        struct mp_audio *frame)
+{
+    struct mp_audio *new = mp_audio_pool_get(pool, frame, frame->samples);
+    if (new) {
+        mp_audio_copy(new, 0, frame, 0, new->samples);
+        mp_audio_copy_attributes(new, frame);
+    }
+    return new;
+}
+
+// Exactly like mp_audio_make_writeable(), but get the data from the pool.
+int mp_audio_pool_make_writeable(struct mp_audio_pool *pool,
+                                 struct mp_audio *data)
+{
+    if (mp_audio_is_writeable(data))
+        return 0;
+    struct mp_audio *new = mp_audio_pool_get(pool, data, data->samples);
+    if (!new)
+        return -1;
+    mp_audio_copy(new, 0, data, 0, data->samples);
+    mp_audio_copy_attributes(new, data);
+    mp_audio_steal_data(data, new);
+    return 0;
+}

audio/audio.h

@@ -38,7 +38,7 @@ struct mp_audio {
     int bps;            // size of sub-samples (af_fmt2bps(format))
 
     // private
-    int allocated[MP_NUM_CHANNELS]; // use mp_audio_get_allocated_size()
+    struct AVBufferRef *allocated[MP_NUM_CHANNELS];
 };
 
 void mp_audio_set_format(struct mp_audio *mpa, int format);
@@ -49,8 +49,8 @@ void mp_audio_copy_config(struct mp_audio *dst, const struct mp_audio *src);
 bool mp_audio_config_equals(const struct mp_audio *a, const struct mp_audio *b);
 bool mp_audio_config_valid(const struct mp_audio *mpa);
 
-char *mp_audio_fmt_to_str(int srate, const struct mp_chmap *chmap, int format);
-char *mp_audio_config_to_str(struct mp_audio *mpa);
+char *mp_audio_config_to_str_buf(char *buf, size_t buf_sz, struct mp_audio *mpa);
+#define mp_audio_config_to_str(m) mp_audio_config_to_str_buf((char[64]){0}, 64, (m))
 
 void mp_audio_force_interleaved_format(struct mp_audio *mpa);
 
@@ -66,6 +66,22 @@ void mp_audio_fill_silence(struct mp_audio *mpa, int start, int length);
 
 void mp_audio_copy(struct mp_audio *dst, int dst_offset,
                    struct mp_audio *src, int src_offset, int length);
+void mp_audio_copy_attributes(struct mp_audio *dst, struct mp_audio *src);
 void mp_audio_skip_samples(struct mp_audio *data, int samples);
 
+bool mp_audio_is_writeable(struct mp_audio *data);
+int mp_audio_make_writeable(struct mp_audio *data);
+
+struct AVFrame;
+struct mp_audio *mp_audio_from_avframe(struct AVFrame *avframe);
+
+struct mp_audio_pool;
+struct mp_audio_pool *mp_audio_pool_create(void *ta_parent);
+struct mp_audio *mp_audio_pool_get(struct mp_audio_pool *pool,
+                                   const struct mp_audio *fmt, int samples);
+struct mp_audio *mp_audio_pool_new_copy(struct mp_audio_pool *pool,
+                                        struct mp_audio *frame);
+int mp_audio_pool_make_writeable(struct mp_audio_pool *pool,
+                                 struct mp_audio *frame);
+
 #endif

audio/chmap.c

@@ -18,6 +18,7 @@
 #include <stdlib.h>
 #include <assert.h>
 
+#include "common/common.h"
 #include "common/msg.h"
 #include "chmap.h"
 
@@ -84,8 +85,10 @@ static const char *const std_layout_names[][2] = {
     {"7.1(alsa)",       "fl-fr-bl-br-fc-lfe-sl-sr"}, // not in lavc
     {"7.1(wide)",       "fl-fr-fc-lfe-bl-br-flc-frc"},
     {"7.1(wide-side)",  "fl-fr-fc-lfe-flc-frc-sl-sr"},
+    {"7.1(rear)",       "fl-fr-fc-lfe-bl-br-sdl-sdr"},
     {"octagonal",       "fl-fr-fc-bl-br-bc-sl-sr"},
     {"downmix",         "dl-dr"},
+    {"auto",            ""}, // not in lavc
     {0}
 };
 
@@ -372,37 +375,61 @@ void mp_chmap_get_reorder(int dst[MP_NUM_CHANNELS], const struct mp_chmap *from,
         assert(to->speaker[dst[n]] == from->speaker[n]);
 }
 
+// Performs the difference between a and b, and store it in diff. If b has
+// channels that do not appear in a, those will not appear in the difference.
+// To get to those the argument ordering in the function call has to be
+// inverted. For the same reason, the diff with a superset will return no
+// speakers.
+void mp_chmap_diff(const struct mp_chmap *a, const struct mp_chmap *b,
+                   struct mp_chmap *diff)
+{
+    uint64_t a_mask = mp_chmap_to_lavc_unchecked(a);
+    uint64_t b_mask = mp_chmap_to_lavc_unchecked(b);
+    mp_chmap_from_lavc(diff, (a_mask ^ b_mask) & a_mask);
+}
+
+// Checks whether a contains all the speakers in b
+bool mp_chmap_contains(const struct mp_chmap *a, const struct mp_chmap *b)
+{
+    struct mp_chmap d1;
+    struct mp_chmap d2;
+    mp_chmap_diff(a, b, &d1);
+    mp_chmap_diff(b, a, &d2);
+    return a->num >= b->num && d1.num >= 0 && d2.num == 0;
+}
+
 // Returns something like "fl-fr-fc". If there's a standard layout in lavc
 // order, return that, e.g. "3.0" instead of "fl-fr-fc".
 // Unassigned but valid speakers get names like "sp28".
-char *mp_chmap_to_str(const struct mp_chmap *src)
+char *mp_chmap_to_str_buf(char *buf, size_t buf_size, const struct mp_chmap *src)
 {
-    char *res = talloc_strdup(NULL, "");
+    buf[0] = '\0';
 
-    if (mp_chmap_is_unknown(src))
-        return talloc_asprintf_append_buffer(res, "unknown%d", src->num);
+    if (mp_chmap_is_unknown(src)) {
+        snprintf(buf, buf_size, "unknown%d", src->num);
+        return buf;
+    }
 
     for (int n = 0; n < src->num; n++) {
         int sp = src->speaker[n];
         const char *s = sp < MP_SPEAKER_ID_COUNT ? speaker_names[sp][0] : NULL;
-        char buf[10];
+        char sp_buf[10];
         if (!s) {
-            snprintf(buf, sizeof(buf), "sp%d", sp);
-            s = buf;
+            snprintf(sp_buf, sizeof(sp_buf), "sp%d", sp);
+            s = sp_buf;
         }
-        res = talloc_asprintf_append_buffer(res, "%s%s", n > 0 ? "-" : "", s);
+        mp_snprintf_cat(buf, buf_size, "%s%s", n > 0 ? "-" : "", s);
     }
 
     // To standard layout name
     for (int n = 0; std_layout_names[n][0]; n++) {
-        if (res && strcmp(res, std_layout_names[n][1]) == 0) {
-            talloc_free(res);
-            res = talloc_strdup(NULL, std_layout_names[n][0]);
+        if (strcmp(buf, std_layout_names[n][1]) == 0) {
+            snprintf(buf, buf_size, "%s", std_layout_names[n][0]);
             break;
         }
     }
 
-    return res;
+    return buf;
 }
 
 // If src can be parsed as channel map (as produced by mp_chmap_to_str()),

audio/chmap.h

@@ -20,7 +20,7 @@
 
 #include <inttypes.h>
 #include <stdbool.h>
-#include "bstr/bstr.h"
+#include "misc/bstr.h"
 
 #define MP_NUM_CHANNELS 8
 
@@ -61,7 +61,8 @@ enum mp_speaker_id {
     MP_SPEAKER_ID_UNKNOWN0 = 64,
     MP_SPEAKER_ID_UNKNOWN_LAST = MP_SPEAKER_ID_UNKNOWN0 + MP_NUM_CHANNELS - 1,
 
-    // Including the unassigned IDs in between. This is not a valid ID anymore.
+    // Including the unassigned IDs in between. This is not a valid ID anymore,
+    // but is still within uint8_t.
     MP_SPEAKER_ID_COUNT,
 };
 
@@ -119,7 +120,14 @@ void mp_chmap_reorder_to_lavc(struct mp_chmap *map);
 void mp_chmap_get_reorder(int dst[MP_NUM_CHANNELS], const struct mp_chmap *from,
                           const struct mp_chmap *to);
 
-char *mp_chmap_to_str(const struct mp_chmap *src);
+void mp_chmap_diff(const struct mp_chmap *a, const struct mp_chmap *b,
+                   struct mp_chmap *diff);
+
+bool mp_chmap_contains(const struct mp_chmap *a, const struct mp_chmap *b);
+
+char *mp_chmap_to_str_buf(char *buf, size_t buf_size, const struct mp_chmap *src);
+#define mp_chmap_to_str(m) mp_chmap_to_str_buf((char[64]){0}, 64, (m))
+
 bool mp_chmap_from_str(struct mp_chmap *dst, bstr src);
 
 struct mp_log;

audio/chmap_sel.c

@@ -17,6 +17,7 @@
 
 #include <stdlib.h>
 #include <assert.h>
+#include <limits.h>
 
 #include "common/common.h"
 #include "chmap_sel.h"
@@ -73,7 +74,7 @@ void mp_chmap_sel_add_waveext(struct mp_chmap_sel *s)
 // Classic ALSA-based MPlayer layouts.
 void mp_chmap_sel_add_alsa_def(struct mp_chmap_sel *s)
 {
-    for (int n = 0; n < MP_NUM_CHANNELS; n++) {
+    for (int n = 1; n <= MP_NUM_CHANNELS; n++) {
         struct mp_chmap t;
         mp_chmap_from_channels_alsa(&t, n);
         if (t.num)
@@ -81,20 +82,27 @@ void mp_chmap_sel_add_alsa_def(struct mp_chmap_sel *s)
     }
 }
 
-#define ARRAY_LEN(x) (sizeof(x) / sizeof((x)[0]))
-
 // Add a channel map that should be allowed.
 void mp_chmap_sel_add_map(struct mp_chmap_sel *s, const struct mp_chmap *map)
 {
-    assert(s->num_chmaps < ARRAY_LEN(s->chmaps));
-    if (mp_chmap_is_valid(map))
-        s->chmaps[s->num_chmaps++] = *map;
+    if (!mp_chmap_is_valid(map))
+        return;
+    if (!s->chmaps)
+        s->chmaps = s->chmaps_storage;
+    if (s->num_chmaps == MP_ARRAY_SIZE(s->chmaps_storage)) {
+        if (!s->tmp)
+            return;
+        s->chmaps = talloc_memdup(s->tmp, s->chmaps, sizeof(s->chmaps_storage));
+    }
+    if (s->chmaps != s->chmaps_storage)
+        MP_TARRAY_GROW(s->tmp, s->chmaps, s->num_chmaps);
+    s->chmaps[s->num_chmaps++] = *map;
 }
 
 // Allow all waveext formats in default order.
 void mp_chmap_sel_add_waveext_def(struct mp_chmap_sel *s)
 {
-    for (int n = 1; n < MP_NUM_CHANNELS; n++) {
+    for (int n = 1; n <= MP_NUM_CHANNELS; n++) {
         struct mp_chmap map;
         mp_chmap_from_channels(&map, n);
         mp_chmap_sel_add_map(s, &map);
@@ -176,18 +184,110 @@ bool mp_chmap_sel_adjust(const struct mp_chmap_sel *s, struct mp_chmap *map)
             return true;
         }
     }
+
+    if (mp_chmap_sel_fallback(s, map))
+        return true;
+
     // Fallback to mono/stereo as last resort
-    if (map->num == 1) {
-        *map = (struct mp_chmap) MP_CHMAP_INIT_MONO;
-    } else if (map->num >= 2) {
-        *map = (struct mp_chmap) MP_CHMAP_INIT_STEREO;
-    }
+    *map = (struct mp_chmap) MP_CHMAP_INIT_STEREO;
+    if (test_layout(s, map))
+        return true;
+    *map = (struct mp_chmap) MP_CHMAP_INIT_MONO;
     if (test_layout(s, map))
         return true;
     *map = (struct mp_chmap) {0};
     return false;
 }
 
+#define UPMIX_IDX 0
+#define DOWNMIX_IDX 1
+#define FALLBACK_IDX 2
+
+static bool test_fallbacks(struct mp_chmap *a, struct mp_chmap *b,
+                           int best_diffs[2], struct mp_chmap best[2])
+{
+    struct mp_chmap diff1, diff2;
+
+    mp_chmap_diff(a, b, &diff1);
+    if (mp_chmap_contains(a, b) && best_diffs[UPMIX_IDX] > diff1.num) {
+        best[UPMIX_IDX] = *a;
+        best_diffs[UPMIX_IDX] = diff1.num;
+        return true;
+    }
+
+    mp_chmap_diff(b, a, &diff2);
+    if (mp_chmap_contains(b, a) && best_diffs[DOWNMIX_IDX] > diff2.num) {
+        best[DOWNMIX_IDX] = *a;
+        best_diffs[DOWNMIX_IDX] = diff2.num;
+        return true;
+    }
+
+    if (diff1.num > 0 && best_diffs[FALLBACK_IDX] > diff1.num) {
+        best[FALLBACK_IDX] = *a;
+        best_diffs[FALLBACK_IDX] = diff1.num;
+        return true;
+    }
+
+    if (diff2.num > 0 && best_diffs[FALLBACK_IDX] > diff2.num) {
+        best[FALLBACK_IDX] = *a;
+        best_diffs[FALLBACK_IDX] = diff2.num;
+        return true;
+    }
+
+    return false;
+}
+
+// Determine which channel map to fallback to given a source channel map. It
+// uses the following heuristic:
+// 1) If mono is required always prefer stereo to a multichannel upmix.
+// 2) Search for an upmix that is an exact superset of the required chmap.
+// 3) Search for a downmix that is the exact subset of the required chmap.
+// 4) Search for either an upmix or downmix that is the closest (minimum
+//    difference of speakers) to the required chmap.
+bool mp_chmap_sel_fallback(const struct mp_chmap_sel *s, struct mp_chmap *map)
+{
+    // special case: if possible always fallback mono to stereo (instead of
+    // looking for a multichannel upmix)
+    struct mp_chmap mono   = MP_CHMAP_INIT_MONO;
+    struct mp_chmap stereo = MP_CHMAP_INIT_STEREO;
+    if (mp_chmap_equals(&mono, map) && test_layout(s, &stereo)) {
+        *map = stereo;
+        return true;
+    }
+
+    int best_diffs[] = { INT_MAX, INT_MAX, INT_MAX };
+    struct mp_chmap best[] = { {0}, {0}, {0} };
+
+    for (int n = 0; n < s->num_chmaps; n++) {
+        struct mp_chmap e = s->chmaps[n];
+
+        if (mp_chmap_is_unknown(&e))
+            continue;
+
+        if (test_fallbacks(&e, map, best_diffs, best))
+            continue;
+
+        // in case we didn't match any fallback retry after replacing speakers
+        for (int i = 0; i < MP_ARRAY_SIZE(speaker_replacements); i++) {
+            struct mp_chmap  t = e;
+            struct mp_chmap *r = (struct mp_chmap *)speaker_replacements[i];
+            if (replace_speakers(&t, r)) {
+                if (test_fallbacks(&t, map, best_diffs, best))
+                    continue;
+            }
+        }
+    }
+
+    for (int i = UPMIX_IDX; i < MP_ARRAY_SIZE(best); i++) {
+        if (best_diffs[i] < INT_MAX) {
+            *map = best[i];
+            return true;
+        }
+    }
+
+    return false;
+}
+
 // Set map to a default layout with num channels. Used for audio APIs that
 // return a channel count as part of format negotiation, but give no
 // information about the channel layout.

audio/chmap_sel.h

@@ -26,8 +26,12 @@ struct mp_chmap_sel {
     // should be considered opaque
     bool allow_any, allow_waveext;
     bool speakers[MP_SPEAKER_ID_COUNT];
-    struct mp_chmap chmaps[20];
+    struct mp_chmap *chmaps;
     int num_chmaps;
+
+    struct mp_chmap chmaps_storage[20];
+
+    void *tmp; // set to any talloc context to allow more chmaps entries
 };
 
 void mp_chmap_sel_add_any(struct mp_chmap_sel *s);
@@ -37,6 +41,7 @@ void mp_chmap_sel_add_alsa_def(struct mp_chmap_sel *s);
 void mp_chmap_sel_add_map(struct mp_chmap_sel *s, const struct mp_chmap *map);
 void mp_chmap_sel_add_speaker(struct mp_chmap_sel *s, int id);
 bool mp_chmap_sel_adjust(const struct mp_chmap_sel *s, struct mp_chmap *map);
+bool mp_chmap_sel_fallback(const struct mp_chmap_sel *s, struct mp_chmap *map);
 bool mp_chmap_sel_get_def(const struct mp_chmap_sel *s, struct mp_chmap *map,
                           int num);
 

audio/decode/ad.h

@@ -36,7 +36,7 @@ struct ad_functions {
     int (*init)(struct dec_audio *da, const char *decoder);
     void (*uninit)(struct dec_audio *da);
     int (*control)(struct dec_audio *da, int cmd, void *arg);
-    int (*decode_packet)(struct dec_audio *da);
+    int (*decode_packet)(struct dec_audio *da, struct mp_audio **out);
 };
 
 enum ad_ctrl {

audio/decode/ad_lavc.c

@@ -25,6 +25,7 @@
 #include <libavcodec/avcodec.h>
 #include <libavutil/opt.h>
 #include <libavutil/common.h>
+#include <libavutil/intreadwrite.h>
 
 #include "talloc.h"
 
@@ -37,14 +38,13 @@
 #include "ad.h"
 #include "audio/fmt-conversion.h"
 
-#include "compat/libav.h"
-
 struct priv {
     AVCodecContext *avctx;
     AVFrame *avframe;
     struct mp_audio frame;
     bool force_channel_map;
     struct demux_packet *packet;
+    uint32_t skip_samples;
 };
 
 static void uninit(struct dec_audio *da);
@@ -73,117 +73,6 @@ const struct m_sub_options ad_lavc_conf = {
     },
 };
 
-struct pcm_map
-{
-    int tag;
-    const char *codecs[6]; // {any, 1byte, 2bytes, 3bytes, 4bytes, 8bytes}
-};
-
-// NOTE: these are needed to make rawaudio with demux_mkv work.
-static const struct pcm_map tag_map[] = {
-    // Microsoft PCM
-    {0x0,           {NULL, "pcm_u8", "pcm_s16le", "pcm_s24le", "pcm_s32le"}},
-    {0x1,           {NULL, "pcm_u8", "pcm_s16le", "pcm_s24le", "pcm_s32le"}},
-    // MS PCM, Extended
-    {0xfffe,        {NULL, "pcm_u8", "pcm_s16le", "pcm_s24le", "pcm_s32le"}},
-    // IEEE float
-    {0x3,           {"pcm_f32le", [5] = "pcm_f64le"}},
-    // 'raw '
-    {0x20776172,    {"pcm_s16be", [1] = "pcm_u8"}},
-    // 'twos', used by demux_mkv.c internally
-    {MKTAG('t', 'w', 'o', 's'),
-                    {NULL, "pcm_s8", "pcm_s16be", "pcm_s24be", "pcm_s32be"}},
-    {-1},
-};
-
-// For demux_rawaudio.c; needed because ffmpeg doesn't have these sample
-// formats natively.
-static const struct pcm_map af_map[] = {
-    {AF_FORMAT_U8,              {"pcm_u8"}},
-    {AF_FORMAT_S8,              {"pcm_u8"}},
-    {AF_FORMAT_U16_LE,          {"pcm_u16le"}},
-    {AF_FORMAT_U16_BE,          {"pcm_u16be"}},
-    {AF_FORMAT_S16_LE,          {"pcm_s16le"}},
-    {AF_FORMAT_S16_BE,          {"pcm_s16be"}},
-    {AF_FORMAT_U24_LE,          {"pcm_u24le"}},
-    {AF_FORMAT_U24_BE,          {"pcm_u24be"}},
-    {AF_FORMAT_S24_LE,          {"pcm_s24le"}},
-    {AF_FORMAT_S24_BE,          {"pcm_s24be"}},
-    {AF_FORMAT_U32_LE,          {"pcm_u32le"}},
-    {AF_FORMAT_U32_BE,          {"pcm_u32be"}},
-    {AF_FORMAT_S32_LE,          {"pcm_s32le"}},
-    {AF_FORMAT_S32_BE,          {"pcm_s32be"}},
-    {AF_FORMAT_FLOAT_LE,        {"pcm_f32le"}},
-    {AF_FORMAT_FLOAT_BE,        {"pcm_f32be"}},
-    {AF_FORMAT_DOUBLE_LE,       {"pcm_f64le"}},
-    {AF_FORMAT_DOUBLE_BE,       {"pcm_f64be"}},
-    {-1},
-};
-
-static const char *find_pcm_decoder(const struct pcm_map *map, int format,
-                                    int bits_per_sample)
-{
-    int bytes = (bits_per_sample + 7) / 8;
-    if (bytes == 8)
-        bytes = 5; // 64 bit entry
-    for (int n = 0; map[n].tag != -1; n++) {
-        const struct pcm_map *entry = &map[n];
-        if (entry->tag == format) {
-            const char *dec = NULL;
-            if (bytes >= 1 && bytes <= 5)
-                dec = entry->codecs[bytes];
-            if (!dec)
-                dec = entry->codecs[0];
-            if (dec)
-                return dec;
-        }
-    }
-    return NULL;
-}
-
-static void set_data_from_avframe(struct dec_audio *da)
-{
-    struct priv *priv = da->priv;
-    AVCodecContext *lavc_context = priv->avctx;
-
-    // Note: invalid parameters are rejected by dec_audio.c
-
-    int fmt = lavc_context->sample_fmt;
-    mp_audio_set_format(&da->decoded, af_from_avformat(fmt));
-    if (!da->decoded.format)
-        MP_FATAL(da, "unsupported lavc format %s", av_get_sample_fmt_name(fmt));
-
-    da->decoded.rate = lavc_context->sample_rate;
-
-    struct mp_chmap lavc_chmap;
-    mp_chmap_from_lavc(&lavc_chmap, lavc_context->channel_layout);
-    // No channel layout or layout disagrees with channel count
-    if (lavc_chmap.num != lavc_context->channels)
-        mp_chmap_from_channels(&lavc_chmap, lavc_context->channels);
-    if (priv->force_channel_map) {
-        struct sh_audio *sh_audio = da->header->audio;
-        if (lavc_chmap.num == sh_audio->channels.num)
-            lavc_chmap = sh_audio->channels;
-    }
-    mp_audio_set_channels(&da->decoded, &lavc_chmap);
-
-    da->decoded.samples = priv->avframe->nb_samples;
-    for (int n = 0; n < da->decoded.num_planes; n++)
-        da->decoded.planes[n] = priv->avframe->data[n];
-}
-
-static void set_from_wf(AVCodecContext *avctx, MP_WAVEFORMATEX *wf)
-{
-    avctx->channels = wf->nChannels;
-    avctx->sample_rate = wf->nSamplesPerSec;
-    avctx->bit_rate = wf->nAvgBytesPerSec * 8;
-    avctx->block_align = wf->nBlockAlign;
-    avctx->bits_per_coded_sample = wf->wBitsPerSample;
-
-    if (wf->cbSize > 0)
-        mp_lavc_set_extradata(avctx, wf + 1, wf->cbSize);
-}
-
 static int init(struct dec_audio *da, const char *decoder)
 {
     struct MPOpts *mpopts = da->opts;
@@ -196,13 +85,7 @@ static int init(struct dec_audio *da, const char *decoder)
     struct priv *ctx = talloc_zero(NULL, struct priv);
     da->priv = ctx;
 
-    if (sh_audio->wf && strcmp(decoder, "pcm") == 0) {
-        decoder = find_pcm_decoder(tag_map, sh->format,
-                                   sh_audio->wf->wBitsPerSample);
-    } else if (sh_audio->wf && strcmp(decoder, "mp-pcm") == 0) {
-        decoder = find_pcm_decoder(af_map, sh->format, 0);
-        ctx->force_channel_map = true;
-    }
+    ctx->force_channel_map = sh_audio->force_channels;
 
     lavc_codec = avcodec_find_decoder_by_name(decoder);
     if (!lavc_codec) {
@@ -227,17 +110,23 @@ static int init(struct dec_audio *da, const char *decoder)
     av_opt_set_double(lavc_context, "drc_scale", opts->ac3drc,
                       AV_OPT_SEARCH_CHILDREN);
 
+#if HAVE_AVFRAME_SKIP_SAMPLES
+    // Let decoder add AV_FRAME_DATA_SKIP_SAMPLES.
+    av_opt_set(lavc_context, "flags2", "+skip_manual", AV_OPT_SEARCH_CHILDREN);
+#endif
+
     mp_set_avopts(da->log, lavc_context, opts->avopts);
 
     lavc_context->codec_tag = sh->format;
     lavc_context->sample_rate = sh_audio->samplerate;
     lavc_context->bit_rate = sh_audio->bitrate;
-    lavc_context->channel_layout = mp_chmap_to_lavc(&sh_audio->channels);
+    lavc_context->block_align = sh_audio->block_align;
+    lavc_context->bits_per_coded_sample = sh_audio->bits_per_coded_sample;
+    lavc_context->channels = sh_audio->channels.num;
+    if (!mp_chmap_is_unknown(&sh_audio->channels))
+        lavc_context->channel_layout = mp_chmap_to_lavc(&sh_audio->channels);
 
-    if (sh_audio->wf)
-        set_from_wf(lavc_context, sh_audio->wf);
-
-    // demux_mkv, demux_mpg
+    // demux_mkv
     if (sh_audio->codecdata_len && sh_audio->codecdata &&
             !lavc_context->extradata) {
         mp_lavc_set_extradata(lavc_context, sh_audio->codecdata,
@@ -247,7 +136,7 @@ static int init(struct dec_audio *da, const char *decoder)
     if (sh->lav_headers)
         mp_copy_lav_codec_headers(lavc_context, sh->lav_headers);
 
-    mp_set_avcodec_threads(lavc_context, opts->threads);
+    mp_set_avcodec_threads(da->log, lavc_context, opts->threads);
 
     /* open it */
     if (avcodec_open2(lavc_context, lavc_codec, NULL) < 0) {
@@ -258,8 +147,6 @@ static int init(struct dec_audio *da, const char *decoder)
 
     if (lavc_context->bit_rate != 0)
         da->bitrate = lavc_context->bit_rate;
-    else if (sh_audio->wf && sh_audio->wf->nAvgBytesPerSec)
-        da->bitrate = sh_audio->wf->nAvgBytesPerSec * 8;
 
     return 1;
 }
@@ -286,21 +173,19 @@ static int control(struct dec_audio *da, int cmd, void *arg)
     switch (cmd) {
     case ADCTRL_RESET:
         avcodec_flush_buffers(ctx->avctx);
-        mp_audio_set_null_data(&da->decoded);
         talloc_free(ctx->packet);
         ctx->packet = NULL;
+        ctx->skip_samples = 0;
         return CONTROL_TRUE;
     }
     return CONTROL_UNKNOWN;
 }
 
-static int decode_packet(struct dec_audio *da)
+static int decode_packet(struct dec_audio *da, struct mp_audio **out)
 {
     struct priv *priv = da->priv;
     AVCodecContext *avctx = priv->avctx;
 
-    mp_audio_set_null_data(&da->decoded);
-
     struct demux_packet *mpkt = priv->packet;
     if (!mpkt) {
         if (demux_read_packet_async(da->header, &mpkt) == 0)
@@ -347,23 +232,55 @@ static int decode_packet(struct dec_audio *da)
     if (!got_frame)
         return mpkt ? AD_OK : AD_EOF;
 
-    set_data_from_avframe(da);
-
     double out_pts = mp_pts_from_av(priv->avframe->pkt_pts, NULL);
     if (out_pts != MP_NOPTS_VALUE) {
         da->pts = out_pts;
         da->pts_offset = 0;
     }
 
-    MP_DBG(da, "Decoded %d -> %d samples\n", in_len, da->decoded.samples);
+    struct mp_audio *mpframe = mp_audio_from_avframe(priv->avframe);
+    if (!mpframe)
+        return AD_ERR;
+
+    struct mp_chmap lavc_chmap = mpframe->channels;
+    if (lavc_chmap.num != avctx->channels)
+        mp_chmap_from_channels(&lavc_chmap, avctx->channels);
+    if (priv->force_channel_map) {
+        struct sh_audio *sh_audio = da->header->audio;
+        if (lavc_chmap.num == sh_audio->channels.num)
+            lavc_chmap = sh_audio->channels;
+    }
+    mp_audio_set_channels(mpframe, &lavc_chmap);
+
+#if HAVE_AVFRAME_SKIP_SAMPLES
+    AVFrameSideData *sd =
+        av_frame_get_side_data(priv->avframe, AV_FRAME_DATA_SKIP_SAMPLES);
+    if (sd && sd->size >= 10) {
+        char *d = sd->data;
+        priv->skip_samples += AV_RL32(d + 0);
+        uint32_t pad = AV_RL32(d + 4);
+        uint32_t skip = MPMIN(priv->skip_samples, mpframe->samples);
+        if (skip) {
+            mp_audio_skip_samples(mpframe, skip);
+            da->pts_offset += skip;
+            priv->skip_samples -= skip;
+        }
+        if (pad <= mpframe->samples)
+            mpframe->samples -= pad;
+    }
+#endif
+
+    *out = mpframe;
+
+    av_frame_unref(priv->avframe);
+
+    MP_DBG(da, "Decoded %d -> %d samples\n", in_len, mpframe->samples);
     return 0;
 }
 
 static void add_decoders(struct mp_decoder_list *list)
 {
     mp_add_lavc_decoders(list, AVMEDIA_TYPE_AUDIO);
-    mp_add_decoder(list, "lavc", "pcm", "pcm", "Raw PCM");
-    mp_add_decoder(list, "lavc", "mp-pcm", "mp-pcm", "Raw PCM");
 }
 
 const struct ad_functions ad_lavc = {

audio/decode/ad_mpg123.c

@@ -43,6 +43,7 @@ struct ad_mpg123_context {
     short delay;
     /* If the stream is actually VBR. */
     char vbr;
+    struct mp_audio frame;
 };
 
 static void uninit(struct dec_audio *da)
@@ -197,27 +198,25 @@ static int set_format(struct dec_audio *da)
     int encoding;
     ret = mpg123_getformat(con->handle, &rate, &channels, &encoding);
     if (ret == MPG123_OK) {
-        mp_audio_set_num_channels(&da->decoded, channels);
-        da->decoded.rate = rate;
+        mp_audio_set_num_channels(&con->frame, channels);
+        con->frame.rate = rate;
         int af = mpg123_format_to_af(encoding);
         if (!af) {
             /* This means we got a funny custom build of libmpg123 that only supports an unknown format. */
             MP_ERR(da, "Bad encoding from mpg123: %i.\n", encoding);
             return MPG123_ERR;
         }
-        mp_audio_set_format(&da->decoded, af);
+        mp_audio_set_format(&con->frame, af);
         con->sample_size = channels * af_fmt2bps(af);
     }
     return ret;
 }
 
-static int decode_packet(struct dec_audio *da)
+static int decode_packet(struct dec_audio *da, struct mp_audio **out)
 {
     struct ad_mpg123_context *con = da->priv;
     int ret;
 
-    mp_audio_set_null_data(&da->decoded);
-
     struct demux_packet *pkt;
     if (demux_read_packet_async(da->header, &pkt) == 0)
         return AD_WAIT;
@@ -257,8 +256,11 @@ static int decode_packet(struct dec_audio *da)
     }
 
     int got_samples = bytes / con->sample_size;
-    da->decoded.planes[0] = audio;
-    da->decoded.samples = got_samples;
+    *out = mp_audio_pool_get(da->pool, &con->frame, got_samples);
+    if (!*out)
+        return AD_ERR;
+
+    memcpy((*out)->planes[0], audio, bytes);
 
     update_info(da);
     return 0;
@@ -274,7 +276,6 @@ static int control(struct dec_audio *da, int cmd, void *arg)
 
     switch (cmd) {
     case ADCTRL_RESET:
-        mp_audio_set_null_data(&da->decoded);
         mpg123_close(con->handle);
 
         if (mpg123_open_feed(con->handle) != MPG123_OK) {

audio/decode/ad_spdif.c

@@ -40,6 +40,7 @@ struct spdifContext {
     int              out_buffer_len;
     uint8_t          out_buffer[OUTBUF_SIZE];
     bool             need_close;
+    struct mp_audio  fmt;
 };
 
 static int write_packet(void *p, uint8_t *buf, int buf_size)
@@ -117,13 +118,13 @@ static int init(struct dec_audio *da, const char *decoder)
     switch (stream->codec->codec_id) {
     case AV_CODEC_ID_AAC:
         spdif_ctx->iec61937_packet_size = 16384;
-        sample_format                   = AF_FORMAT_IEC61937_LE;
+        sample_format                   = AF_FORMAT_S_AAC;
         samplerate                      = 48000;
         num_channels                    = 2;
         break;
     case AV_CODEC_ID_AC3:
         spdif_ctx->iec61937_packet_size = 6144;
-        sample_format                   = AF_FORMAT_AC3_LE;
+        sample_format                   = AF_FORMAT_S_AC3;
         samplerate                      = 48000;
         num_channels                    = 2;
         break;
@@ -131,40 +132,40 @@ static int init(struct dec_audio *da, const char *decoder)
         if (da->opts->dtshd) {
             av_dict_set(&format_opts, "dtshd_rate", "768000", 0); // 4*192000
             spdif_ctx->iec61937_packet_size = 32768;
-            sample_format                   = AF_FORMAT_IEC61937_LE;
+            sample_format                   = AF_FORMAT_S_DTSHD;
             samplerate                      = 192000;
             num_channels                    = 2*4;
         } else {
             spdif_ctx->iec61937_packet_size = 32768;
-            sample_format                   = AF_FORMAT_AC3_LE;
+            sample_format                   = AF_FORMAT_S_DTS;
             samplerate                      = 48000;
             num_channels                    = 2;
         }
         break;
     case AV_CODEC_ID_EAC3:
         spdif_ctx->iec61937_packet_size = 24576;
-        sample_format                   = AF_FORMAT_IEC61937_LE;
+        sample_format                   = AF_FORMAT_S_EAC3;
         samplerate                      = 192000;
         num_channels                    = 2;
         break;
     case AV_CODEC_ID_MP3:
         spdif_ctx->iec61937_packet_size = 4608;
-        sample_format                   = AF_FORMAT_MPEG2;
+        sample_format                   = AF_FORMAT_S_MP3;
         samplerate                      = 48000;
         num_channels                    = 2;
         break;
     case AV_CODEC_ID_TRUEHD:
         spdif_ctx->iec61937_packet_size = 61440;
-        sample_format                   = AF_FORMAT_IEC61937_LE;
+        sample_format                   = AF_FORMAT_S_TRUEHD;
         samplerate                      = 192000;
         num_channels                    = 8;
         break;
     default:
         abort();
     }
-    mp_audio_set_num_channels(&da->decoded, num_channels);
-    mp_audio_set_format(&da->decoded, sample_format);
-    da->decoded.rate = samplerate;
+    mp_audio_set_num_channels(&spdif_ctx->fmt, num_channels);
+    mp_audio_set_format(&spdif_ctx->fmt, sample_format);
+    spdif_ctx->fmt.rate = samplerate;
 
     if (avformat_write_header(lavf_ctx, &format_opts) < 0) {
         MP_FATAL(da, "libavformat spdif initialization failed.\n");
@@ -182,13 +183,11 @@ fail:
     return 0;
 }
 
-static int decode_packet(struct dec_audio *da)
+static int decode_packet(struct dec_audio *da, struct mp_audio **out)
 {
     struct spdifContext *spdif_ctx = da->priv;
     AVFormatContext     *lavf_ctx  = spdif_ctx->lavf_ctx;
 
-    mp_audio_set_null_data(&da->decoded);
-
     spdif_ctx->out_buffer_len  = 0;
 
     struct demux_packet *mpkt;
@@ -201,7 +200,6 @@ static int decode_packet(struct dec_audio *da)
     AVPacket pkt;
     mp_set_av_packet(&pkt, mpkt, NULL);
     pkt.pts = pkt.dts = 0;
-    MP_VERBOSE(da, "spdif packet, size=%d\n", pkt.size);
     if (mpkt->pts != MP_NOPTS_VALUE) {
         da->pts        = mpkt->pts;
         da->pts_offset = 0;
@@ -212,8 +210,12 @@ static int decode_packet(struct dec_audio *da)
     if (ret < 0)
         return AD_ERR;
 
-    da->decoded.planes[0] = spdif_ctx->out_buffer;
-    da->decoded.samples = spdif_ctx->out_buffer_len / da->decoded.sstride;
+    int samples = spdif_ctx->out_buffer_len / spdif_ctx->fmt.sstride;
+    *out = mp_audio_pool_get(da->pool, &spdif_ctx->fmt, samples);
+    if (!*out)
+        return AD_ERR;
+
+    memcpy((*out)->planes[0], spdif_ctx->out_buffer, spdif_ctx->out_buffer_len);
 
     return 0;
 }

audio/decode/dec_audio.c

@@ -28,7 +28,7 @@
 #include "config.h"
 #include "common/codecs.h"
 #include "common/msg.h"
-#include "bstr/bstr.h"
+#include "misc/bstr.h"
 
 #include "stream/stream.h"
 #include "demux/demux.h"
@@ -48,27 +48,14 @@ extern const struct ad_functions ad_lavc;
 extern const struct ad_functions ad_spdif;
 
 static const struct ad_functions * const ad_drivers[] = {
+    &ad_lavc,
 #if HAVE_MPG123
     &ad_mpg123,
 #endif
-    &ad_lavc,
     &ad_spdif,
     NULL
 };
 
-// Drop audio buffer and reinit it (after format change)
-// Returns whether the format was valid at all.
-static bool reinit_audio_buffer(struct dec_audio *da)
-{
-    if (!mp_audio_config_valid(&da->decoded)) {
-        MP_ERR(da, "Audio decoder did not specify audio "
-               "format, or requested an unsupported configuration!\n");
-        return false;
-    }
-    mp_audio_buffer_reinit(da->decode_buffer, &da->decoded);
-    return true;
-}
-
 static void uninit_decoder(struct dec_audio *d_audio)
 {
     if (d_audio->ad_driver) {
@@ -89,7 +76,6 @@ static int init_audio_codec(struct dec_audio *d_audio, const char *decoder)
         return 0;
     }
 
-    d_audio->decode_buffer = mp_audio_buffer_create(NULL);
     return 1;
 }
 
@@ -164,55 +150,27 @@ void audio_uninit(struct dec_audio *d_audio)
 {
     if (!d_audio)
         return;
-    if (d_audio->afilter) {
-        MP_VERBOSE(d_audio, "Uninit audio filters...\n");
-        af_destroy(d_audio->afilter);
-        d_audio->afilter = NULL;
-    }
+    MP_VERBOSE(d_audio, "Uninit audio filters...\n");
+    af_destroy(d_audio->afilter);
     uninit_decoder(d_audio);
-    talloc_free(d_audio->decode_buffer);
+    talloc_free(d_audio->waiting);
     talloc_free(d_audio);
 }
 
-
-int audio_init_filters(struct dec_audio *d_audio, int in_samplerate,
-                       int *out_samplerate, struct mp_chmap *out_channels,
-                       int *out_format)
+static int decode_new_frame(struct dec_audio *da)
 {
-    if (!d_audio->afilter)
-        d_audio->afilter = af_new(d_audio->global);
-    struct af_stream *afs = d_audio->afilter;
+    while (!da->waiting) {
+        int ret = da->ad_driver->decode_packet(da, &da->waiting);
+        if (ret < 0)
+            return ret;
 
-    // input format: same as codec's output format:
-    mp_audio_buffer_get_format(d_audio->decode_buffer, &afs->input);
-    // Sample rate can be different when adjusting playback speed
-    afs->input.rate = in_samplerate;
-
-    // output format: same as ao driver's input format (if missing, fallback to input)
-    afs->output.rate = *out_samplerate;
-    mp_audio_set_channels(&afs->output, out_channels);
-    mp_audio_set_format(&afs->output, *out_format);
-
-    afs->replaygain_data = d_audio->replaygain_data;
-
-    char *s_from = mp_audio_config_to_str(&afs->input);
-    char *s_to = mp_audio_config_to_str(&afs->output);
-    MP_VERBOSE(d_audio, "Building audio filter chain for %s -> %s...\n", s_from, s_to);
-    talloc_free(s_from);
-    talloc_free(s_to);
-
-    // let's autoprobe it!
-    if (af_init(afs) != 0) {
-        af_destroy(afs);
-        d_audio->afilter = NULL;
-        return 0;   // failed :(
+        if (da->waiting) {
+            da->pts_offset += da->waiting->samples;
+            da->decode_format = *da->waiting;
+            mp_audio_set_null_data(&da->decode_format);
+        }
     }
-
-    *out_samplerate = afs->output.rate;
-    *out_channels = afs->output.channels;
-    *out_format = afs->output.format;
-
-    return 1;
+    return mp_audio_config_valid(da->waiting) ? AD_OK : AD_ERR;
 }
 
 /* Decode packets until we know the audio format. Then reinit the buffer.
@@ -221,79 +179,22 @@ int audio_init_filters(struct dec_audio *d_audio, int in_samplerate,
  */
 int initial_audio_decode(struct dec_audio *da)
 {
-    while (!mp_audio_config_valid(&da->decoded)) {
-        if (da->decoded.samples > 0)
-            return AD_ERR; // invalid format, rather than uninitialized
-        int ret = da->ad_driver->decode_packet(da);
-        if (ret < 0)
-            return ret;
-    }
-    if (mp_audio_buffer_samples(da->decode_buffer) > 0) // avoid accidental flush
-        return AD_OK;
-    return reinit_audio_buffer(da) ? AD_OK : AD_ERR;
+    return decode_new_frame(da);
 }
 
-// Filter len bytes of input, put result into outbuf.
-static int filter_n_bytes(struct dec_audio *da, struct mp_audio_buffer *outbuf,
-                          int len)
+static bool copy_output(struct af_stream *afs, struct mp_audio_buffer *outbuf,
+                        int minsamples, bool eof)
 {
-    bool format_change = false;
-    int error = 0;
-
-    assert(len > 0); // would break EOF logic below
-
-    while (mp_audio_buffer_samples(da->decode_buffer) < len) {
-        // Check for a format change
-        struct mp_audio config;
-        mp_audio_buffer_get_format(da->decode_buffer, &config);
-        format_change = !mp_audio_config_equals(&da->decoded, &config);
-        if (format_change) {
-            error = AD_EOF; // drain remaining data left in the current buffer
-            break;
-        }
-        if (da->decoded.samples > 0) {
-            int copy = MPMIN(da->decoded.samples, len);
-            struct mp_audio append = da->decoded;
-            append.samples = copy;
-            mp_audio_buffer_append(da->decode_buffer, &append);
-            mp_audio_skip_samples(&da->decoded, copy);
-            da->pts_offset += copy;
-            continue;
-        }
-        error = da->ad_driver->decode_packet(da);
-        if (error < 0)
-            break;
+    while (mp_audio_buffer_samples(outbuf) < minsamples) {
+        if (af_output_frame(afs, eof) < 0)
+            return true; // error, stop doing stuff
+        struct mp_audio *mpa = af_read_output_frame(afs);
+        if (!mpa)
+            return false; // out of data
+        mp_audio_buffer_append(outbuf, mpa);
+        talloc_free(mpa);
     }
-
-    if (error == AD_WAIT)
-        return error;
-
-    // Filter
-    struct mp_audio filter_data;
-    mp_audio_buffer_peek(da->decode_buffer, &filter_data);
-    filter_data.rate = da->afilter->input.rate; // due to playback speed change
-    len = MPMIN(filter_data.samples, len);
-    filter_data.samples = len;
-    bool eof = error == AD_EOF && filter_data.samples == 0;
-
-    if (af_filter(da->afilter, &filter_data, eof ? AF_FILTER_FLAG_EOF : 0) < 0)
-        return AD_ERR;
-
-    mp_audio_buffer_append(outbuf, &filter_data);
-    if (error == AD_EOF && filter_data.samples > 0)
-        error = 0; // don't end playback yet
-
-    // remove processed data from decoder buffer:
-    mp_audio_buffer_skip(da->decode_buffer, len);
-
-    // if format was changed, and all data was drained, execute the format change
-    if (format_change && eof) {
-        error = AD_NEW_FMT;
-        if (!reinit_audio_buffer(da))
-            error = AD_ERR; // switch to invalid format
-    }
-
-    return error;
+    return true;
 }
 
 /* Try to get at least minsamples decoded+filtered samples in outbuf
@@ -301,52 +202,44 @@ static int filter_n_bytes(struct dec_audio *da, struct mp_audio_buffer *outbuf,
  * Return 0 on success, or negative AD_* error code.
  * In the former case outbuf has at least minsamples buffered on return.
  * In case of EOF/error it might or might not be. */
-int audio_decode(struct dec_audio *d_audio, struct mp_audio_buffer *outbuf,
+int audio_decode(struct dec_audio *da, struct mp_audio_buffer *outbuf,
                  int minsamples)
 {
-    if (!d_audio->afilter)
+    struct af_stream *afs = da->afilter;
+    if (afs->initialized < 1)
         return AD_ERR;
 
-    // Indicates that a filter seems to be buffering large amounts of data
-    int huge_filter_buffer = 0;
+    MP_STATS(da, "start audio");
 
-    /* Filter output size will be about filter_multiplier times input size.
-     * If some filter buffers audio in big blocks this might only hold
-     * as average over time. */
-    double filter_multiplier = af_calc_filter_multiplier(d_audio->afilter);
+    int res;
+    while (1) {
+        res = 0;
 
-    int prev_buffered = -1;
-    int res = 0;
-    MP_STATS(d_audio, "start audio");
-    while (res >= 0 && minsamples >= 0) {
-        int buffered = mp_audio_buffer_samples(outbuf);
-        if (minsamples < buffered || buffered == prev_buffered)
+        if (copy_output(afs, outbuf, minsamples, false))
             break;
-        prev_buffered = buffered;
 
-        int decsamples = (minsamples - buffered) / filter_multiplier;
-        // + some extra for possible filter buffering, and avoid 0
-        decsamples += 512;
-
-        if (huge_filter_buffer) {
-            /* Some filter must be doing significant buffering if the estimated
-             * input length didn't produce enough output from filters.
-             * Feed the filters 250 samples at a time until we have enough
-             * output. Very small amounts could make filtering inefficient while
-             * large amounts can make mpv demux the file unnecessarily far ahead
-             * to get audio data and buffer video frames in memory while doing
-             * so. However the performance impact of either is probably not too
-             * significant as long as the value is not completely insane. */
-            decsamples = 250;
+        res = decode_new_frame(da);
+        if (res < 0) {
+            // drain filters first (especially for true EOF case)
+            copy_output(afs, outbuf, minsamples, true);
+            break;
         }
 
-        /* if this iteration does not fill buffer, we must have lots
-         * of buffering in filters */
-        huge_filter_buffer = 1;
+        // On format change, make sure to drain the filter chain.
+        if (!mp_audio_config_equals(&afs->input, da->waiting)) {
+            copy_output(afs, outbuf, minsamples, true);
+            res = AD_NEW_FMT;
+            break;
+        }
 
-        res = filter_n_bytes(d_audio, outbuf, decsamples);
+        struct mp_audio *mpa = da->waiting;
+        da->waiting = NULL;
+        if (af_filter_frame(afs, mpa) < 0)
+            return AD_ERR;
     }
-    MP_STATS(d_audio, "end audio");
+
+    MP_STATS(da, "end audio");
+
     return res;
 }
 
@@ -354,10 +247,11 @@ void audio_reset_decoding(struct dec_audio *d_audio)
 {
     if (d_audio->ad_driver)
         d_audio->ad_driver->control(d_audio, ADCTRL_RESET, NULL);
-    if (d_audio->afilter)
-        af_control_all(d_audio->afilter, AF_CONTROL_RESET, NULL);
+    af_seek_reset(d_audio->afilter);
     d_audio->pts = MP_NOPTS_VALUE;
     d_audio->pts_offset = 0;
-    if (d_audio->decode_buffer)
-        mp_audio_buffer_clear(d_audio->decode_buffer);
+    if (d_audio->waiting) {
+        talloc_free(d_audio->waiting);
+        d_audio->waiting = NULL;
+    }
 }

audio/decode/dec_audio.h

@@ -33,13 +33,13 @@ struct dec_audio {
     struct mpv_global *global;
     const struct ad_functions *ad_driver;
     struct sh_stream *header;
-    struct mp_audio_buffer *decode_buffer;
     struct af_stream *afilter;
     char *decoder_desc;
-    struct replaygain_data *replaygain_data;
     int init_retries;
+    struct mp_audio_pool *pool;
+    struct mp_audio decode_format;
+    struct mp_audio *waiting;   // used on format-change
     // set by decoder
-    struct mp_audio decoded;    // decoded audio set by last decode_packet() call
     int bitrate;                // input bitrate, can change with VBR sources
     // last known pts value in output from decoder
     double pts;
@@ -65,8 +65,4 @@ int initial_audio_decode(struct dec_audio *d_audio);
 void audio_reset_decoding(struct dec_audio *d_audio);
 void audio_uninit(struct dec_audio *d_audio);
 
-int audio_init_filters(struct dec_audio *d_audio, int in_samplerate,
-                       int *out_samplerate, struct mp_chmap *out_channels,
-                       int *out_format);
-
 #endif /* MPLAYER_DEC_AUDIO_H */

audio/filter/af.c

@@ -28,6 +28,7 @@
 #include "options/m_option.h"
 #include "options/m_config.h"
 
+#include "audio/audio_buffer.h"
 #include "af.h"
 
 // Static list of filters
@@ -53,6 +54,7 @@ extern const struct af_info af_info_center;
 extern const struct af_info af_info_sinesuppress;
 extern const struct af_info af_info_karaoke;
 extern const struct af_info af_info_scaletempo;
+extern const struct af_info af_info_forcespeed;
 extern const struct af_info af_info_bs2b;
 extern const struct af_info af_info_lavfi;
 extern const struct af_info af_info_convert24;
@@ -68,9 +70,7 @@ static const struct af_info *const filter_list[] = {
     &af_info_pan,
     &af_info_surround,
     &af_info_sub,
-#if HAVE_SYS_MMAN_H
     &af_info_export,
-#endif
     &af_info_drc,
     &af_info_extrastereo,
     &af_info_lavcac3enc,
@@ -83,6 +83,7 @@ static const struct af_info *const filter_list[] = {
     &af_info_center,
     &af_info_sinesuppress,
     &af_info_karaoke,
+    &af_info_forcespeed,
     &af_info_scaletempo,
 #if HAVE_LIBBS2B
     &af_info_bs2b,
@@ -121,11 +122,17 @@ const struct m_obj_list af_obj_list = {
     },
 };
 
-static bool af_config_equals(struct mp_audio *a, struct mp_audio *b)
+static void af_forget_frames(struct af_instance *af)
 {
-    return a->format == b->format
-        && mp_chmap_equals(&a->channels, &b->channels)
-        && a->rate   == b->rate;
+    for (int n = 0; n < af->num_out_queued; n++)
+        talloc_free(af->out_queued[n]);
+    af->num_out_queued = 0;
+}
+
+static void af_chain_forget_frames(struct af_stream *s)
+{
+    for (struct af_instance *cur = s->first; cur; cur = cur->next)
+        af_forget_frames(cur);
 }
 
 static void af_copy_unset_fields(struct mp_audio *dst, struct mp_audio *src)
@@ -162,14 +169,15 @@ static int output_control(struct af_instance* af, int cmd, void* arg)
         *filter_output = *output;
         af_copy_unset_fields(filter_output, in);
         *in = *filter_output;
-        return af_config_equals(in, &orig_in) ? AF_OK : AF_FALSE;
+        return mp_audio_config_equals(in, &orig_in) ? AF_OK : AF_FALSE;
     }
     }
     return AF_UNKNOWN;
 }
 
-static int dummy_filter(struct af_instance* af, struct mp_audio* data, int f)
+static int dummy_filter(struct af_instance *af, struct mp_audio *frame)
 {
+    af_add_output_frame(af, frame);
     return 0;
 }
 
@@ -201,10 +209,10 @@ static struct af_instance *af_create(struct af_stream *s, char *name,
     struct af_instance *af = talloc_zero(NULL, struct af_instance);
     *af = (struct af_instance) {
         .info = info,
-        .mul = 1,
         .data = talloc_zero(af, struct mp_audio),
         .log = mp_log_new(af, s->log, name),
         .replaygain_data = s->replaygain_data,
+        .out_pool = mp_audio_pool_create(af),
     };
     struct m_config *config = m_config_from_obj_desc(af, s->log, &desc);
     if (m_config_apply_defaults(config, name, s->opts->af_defs) < 0)
@@ -289,6 +297,7 @@ static void af_remove(struct af_stream *s, struct af_instance *af)
 
     if (af->uninit)
         af->uninit(af);
+    af_forget_frames(af);
     talloc_free(af);
 }
 
@@ -312,11 +321,8 @@ static void af_print_filter_chain(struct af_stream *s, struct af_instance *at,
     while (af) {
         char b[128] = {0};
         mp_snprintf_cat(b, sizeof(b), "  [%s] ", af->info->name);
-        if (af->data) {
-            char *info = mp_audio_config_to_str(af->data);
-            mp_snprintf_cat(b, sizeof(b), "%s", info);
-            talloc_free(info);
-        }
+        if (af->data)
+            mp_snprintf_cat(b, sizeof(b), "%s", mp_audio_config_to_str(af->data));
         if (af == at)
             mp_snprintf_cat(b, sizeof(b), " <-");
         MP_MSG(s, msg_level, "%s\n", b);
@@ -324,9 +330,7 @@ static void af_print_filter_chain(struct af_stream *s, struct af_instance *at,
         af = af->next;
     }
 
-    char *info = mp_audio_config_to_str(&s->output);
-    MP_MSG(s, msg_level, "  [ao] %s\n", info);
-    talloc_free(info);
+    MP_MSG(s, msg_level, "  [ao] %s\n", mp_audio_config_to_str(&s->output));
 }
 
 static int af_count_filters(struct af_stream *s)
@@ -508,6 +512,8 @@ static int af_fix_rate(struct af_stream *s, struct af_instance **p_af,
 static int af_reinit(struct af_stream *s)
 {
     remove_auto_inserted_filters(s);
+    af_chain_forget_frames(s);
+    s->first->fmt_in = s->first->fmt_out = s->input;
     // Start with the second filter, as the first filter is the special input
     // filter which needs no initialization.
     struct af_instance *af = s->first->next;
@@ -523,11 +529,18 @@ static int af_reinit(struct af_stream *s)
         // Reset just in case...
         mp_audio_set_null_data(&in);
 
+        if (!mp_audio_config_valid(&in))
+            goto error;
+
+        af->fmt_in = in;
         int rv = af->control(af, AF_CONTROL_REINIT, &in);
         if (rv == AF_OK && !mp_audio_config_equals(&in, af->prev->data))
             rv = AF_FALSE; // conversion filter needed
         switch (rv) {
         case AF_OK:
+            if (!mp_audio_config_valid(af->data))
+                goto error;
+            af->fmt_out = *af->data;
             af = af->next;
             break;
         case AF_FALSE: { // Configuration filter is needed
@@ -558,22 +571,27 @@ static int af_reinit(struct af_stream *s)
             MP_ERR(s, "Reinitialization did not work, "
                    "audio filter '%s' returned error code %i\n",
                    af->info->name, rv);
-            af_print_filter_chain(s, af, MSGL_ERR);
-            return AF_ERROR;
+            goto error;
         }
     }
 
-    af_print_filter_chain(s, NULL, MSGL_V);
-
     /* Set previously unset fields in s->output to those of the filter chain
      * output. This is used to make the output format fixed, and even if you
      * insert new filters or change the input format, the output format won't
      * change. (Audio outputs generally can't change format at runtime.) */
     af_copy_unset_fields(&s->output, &s->filter_output);
-    return af_config_equals(&s->output, &s->filter_output) ? AF_OK : AF_ERROR;
+    if (mp_audio_config_equals(&s->output, &s->filter_output)) {
+        s->initialized = 1;
+        af_print_filter_chain(s, NULL, MSGL_V);
+        return AF_OK;
+    }
+
+    goto error;
 
 negotiate_error:
     MP_ERR(s, "Unable to convert audio input format to output format.\n");
+error:
+    s->initialized = -1;
     af_print_filter_chain(s, af, MSGL_ERR);
     return AF_ERROR;
 }
@@ -583,35 +601,40 @@ void af_uninit(struct af_stream *s)
 {
     while (s->first->next && s->first->next != s->last)
         af_remove(s, s->first->next);
+    af_chain_forget_frames(s);
+    s->initialized = 0;
 }
 
 struct af_stream *af_new(struct mpv_global *global)
 {
     struct af_stream *s = talloc_zero(NULL, struct af_stream);
+    s->log = mp_log_new(s, global->log, "!af");
+
     static const struct af_info in = { .name = "in" };
     s->first = talloc(s, struct af_instance);
     *s->first = (struct af_instance) {
         .info = &in,
+        .log = s->log,
         .control = input_control,
-        .filter = dummy_filter,
+        .filter_frame = dummy_filter,
         .priv = s,
         .data = &s->input,
-        .mul = 1.0,
     };
+
     static const struct af_info out = { .name = "out" };
     s->last = talloc(s, struct af_instance);
     *s->last = (struct af_instance) {
         .info = &out,
+        .log = s->log,
         .control = output_control,
-        .filter = dummy_filter,
+        .filter_frame = dummy_filter,
         .priv = s,
         .data = &s->filter_output,
-        .mul = 1.0,
     };
+
     s->first->next = s->last;
     s->last->prev = s->first;
     s->opts = global->opts;
-    s->log = mp_log_new(s, global->log, "!af");
     return s;
 }
 
@@ -632,10 +655,6 @@ void af_destroy(struct af_stream *s)
    The return value is 0 if success and -1 if failure */
 int af_init(struct af_stream *s)
 {
-    // Sanity check
-    if (!s)
-        return -1;
-
     // Precaution in case caller is misbehaving
     mp_audio_set_null_data(&s->input);
     mp_audio_set_null_data(&s->output);
@@ -645,17 +664,20 @@ int af_init(struct af_stream *s)
         // Add all filters in the list (if there are any)
         struct m_obj_settings *list = s->opts->af_settings;
         for (int i = 0; list && list[i].name; i++) {
-            if (!af_prepend(s, s->last, list[i].name, list[i].attribs)) {
+            struct af_instance *af =
+                af_prepend(s, s->last, list[i].name, list[i].attribs);
+            if (!af) {
                 af_uninit(s);
+                s->initialized = -1;
                 return -1;
             }
+            af->label = talloc_strdup(af, list[i].label);
         }
     }
 
     if (af_reinit(s) != AF_OK) {
         // Something is stuffed audio out will not work
         MP_ERR(s, "Could not create audio filter chain.\n");
-        af_uninit(s);
         return -1;
     }
     return 0;
@@ -668,9 +690,6 @@ int af_init(struct af_stream *s)
 struct af_instance *af_add(struct af_stream *s, char *name, char **args)
 {
     struct af_instance *new;
-    // Sanity check
-    if (!s || !s->first || !name)
-        return NULL;
     // Insert the filter somewhere nice
     if (af_is_conversion_filter(s->first->next))
         new = af_append(s, s->first->next, name, args);
@@ -681,44 +700,40 @@ struct af_instance *af_add(struct af_stream *s, char *name, char **args)
 
     // Reinitalize the filter list
     if (af_reinit(s) != AF_OK) {
-        af_uninit(s);
-        af_init(s);
+        af_remove(s, new);
+        if (af_reinit(s) != AF_OK) {
+            af_uninit(s);
+            af_init(s);
+        }
         return NULL;
     }
     return new;
 }
 
-/* Filter data chunk through the filters in the list.
- * On success, *data is set to the filtered data/format.
- * Warning: input audio data will be overwritten.
- */
-int af_filter(struct af_stream *s, struct mp_audio *data, int flags)
+struct af_instance *af_find_by_label(struct af_stream *s, char *label)
 {
-    struct af_instance *af = s->first;
-    assert(mp_audio_config_equals(af->data, data));
-    // Iterate through all filters
-    while (af) {
-        int r = af->filter(af, data, flags);
-        if (r < 0)
-            return r;
-        assert(mp_audio_config_equals(af->data, data));
-        af = af->next;
+    for (struct af_instance *af = s->first; af; af = af->next) {
+        if (af->label && strcmp(af->label, label) == 0)
+            return af;
     }
-    return 0;
+    return NULL;
 }
 
-// Calculate average ratio of filter output samples to input samples.
-// e.g: num_output_samples = mul * num_input_samples
-double af_calc_filter_multiplier(struct af_stream *s)
+/* Remove the first filter that matches this name. Return number of filters
+ * removed (0, 1), or a negative error code if reinit after removing failed.
+ */
+int af_remove_by_label(struct af_stream *s, char *label)
 {
-    struct af_instance *af = s->first;
-    double mul = 1;
-    do {
-        mul *= af->mul;
-        af = af->next;
-    } while (af);
-
-    return mul;
+    struct af_instance *af = af_find_by_label(s, label);
+    if (!af)
+        return 0;
+    af_remove(s, af);
+    if (af_reinit(s) != AF_OK) {
+        af_uninit(s);
+        af_init(s);
+        return -1;
+    }
+    return 1;
 }
 
 /* Calculate the total delay [seconds of output] caused by the filters */
@@ -728,6 +743,8 @@ double af_calc_delay(struct af_stream *s)
     double delay = 0.0;
     while (af) {
         delay += af->delay;
+        for (int n = 0; n < af->num_out_queued; n++)
+            delay += af->out_queued[n]->samples / (double)af->data->rate;
         af = af->next;
     }
     return delay;
@@ -754,3 +771,108 @@ void af_control_all(struct af_stream *s, int cmd, void *arg)
     for (struct af_instance *af = s->first; af; af = af->next)
         af->control(af, cmd, arg);
 }
+
+// Used by filters to add a filtered frame to the output queue.
+// Ownership of frame is transferred from caller to the filter chain.
+void af_add_output_frame(struct af_instance *af, struct mp_audio *frame)
+{
+    if (frame) {
+        assert(mp_audio_config_equals(&af->fmt_out, frame));
+        MP_TARRAY_APPEND(af, af->out_queued, af->num_out_queued, frame);
+    }
+}
+
+static bool af_has_output_frame(struct af_instance *af)
+{
+    if (!af->num_out_queued && af->filter_out) {
+        if (af->filter_out(af) < 0)
+            MP_ERR(af, "Error filtering frame.\n");
+    }
+    return af->num_out_queued > 0;
+}
+
+static struct mp_audio *af_dequeue_output_frame(struct af_instance *af)
+{
+    struct mp_audio *res = NULL;
+    if (af_has_output_frame(af)) {
+        res = af->out_queued[0];
+        MP_TARRAY_REMOVE_AT(af->out_queued, af->num_out_queued, 0);
+    }
+    return res;
+}
+
+static int af_do_filter(struct af_instance *af, struct mp_audio *frame)
+{
+    if (frame)
+        assert(mp_audio_config_equals(&af->fmt_in, frame));
+    int r = af->filter_frame(af, frame);
+    if (r < 0)
+        MP_ERR(af, "Error filtering frame.\n");
+    return r;
+}
+
+// Input a frame into the filter chain. Ownership of frame is transferred.
+// Return >= 0 on success, < 0 on failure (even if output frames were produced)
+int af_filter_frame(struct af_stream *s, struct mp_audio *frame)
+{
+    assert(frame);
+    if (s->initialized < 1) {
+        talloc_free(frame);
+        return -1;
+    }
+    return af_do_filter(s->first, frame);
+}
+
+// Output the next queued frame (if any) from the full filter chain.
+// The frame can be retrieved with af_read_output_frame().
+//  eof: if set, assume there's no more input i.e. af_filter_frame() will
+//       not be called (until reset) - flush all internally delayed frames
+//  returns: -1: error, 0: no output, 1: output available
+int af_output_frame(struct af_stream *s, bool eof)
+{
+    if (s->last->num_out_queued)
+        return 1;
+    if (s->initialized < 1)
+        return -1;
+    while (1) {
+        struct af_instance *last = NULL;
+        for (struct af_instance * cur = s->first; cur; cur = cur->next) {
+            // Flush remaining frames on EOF, but do that only if the previous
+            // filters have been flushed (i.e. they have no more output).
+            if (eof && !last) {
+                int r = af_do_filter(cur, NULL);
+                if (r < 0)
+                    return r;
+            }
+            if (af_has_output_frame(cur))
+                last = cur;
+        }
+        if (!last)
+            return 0;
+        if (!last->next)
+            return 1;
+        int r = af_do_filter(last->next, af_dequeue_output_frame(last));
+        if (r < 0)
+            return r;
+    }
+}
+
+struct mp_audio *af_read_output_frame(struct af_stream *s)
+{
+    if (!s->last->num_out_queued)
+        af_output_frame(s, false);
+    return af_dequeue_output_frame(s->last);
+}
+
+// Make sure the caller can change data referenced by the frame.
+// Return negative error code on failure (i.e. you can't write).
+int af_make_writeable(struct af_instance *af, struct mp_audio *frame)
+{
+    return mp_audio_pool_make_writeable(af->out_pool, frame);
+}
+
+void af_seek_reset(struct af_stream *s)
+{
+    af_control_all(s, AF_CONTROL_RESET, NULL);
+    af_chain_forget_frames(s);
+}

audio/filter/af.h

@@ -62,24 +62,35 @@ struct af_instance {
     struct replaygain_data *replaygain_data;
     int (*control)(struct af_instance *af, int cmd, void *arg);
     void (*uninit)(struct af_instance *af);
-    /* flags is a bit mask of AF_FILTER_FLAG_* values
-     * returns 0 on success, negative value on error
+    /* Feed a frame. The frame is NULL if EOF was reached, and the filter
+     * should drain all remaining buffered data.
+     * Use af_add_output_frame() to output data. The optional filter_out
+     * callback can be set to produce output frames gradually.
      */
-    int (*filter)(struct af_instance *af, struct mp_audio *data, int flags);
+    int (*filter_frame)(struct af_instance *af, struct mp_audio *frame);
+    int (*filter_out)(struct af_instance *af);
     void *priv;
     struct mp_audio *data; // configuration and buffer for outgoing data stream
+
     struct af_instance *next;
     struct af_instance *prev;
     double delay; /* Delay caused by the filter, in seconds of audio consumed
                    * without corresponding output */
-    double mul; /* length multiplier: how much does this instance change
-                 * the number of samples passed though. (Ratio of input
-                 * and output, e.g. mul=4 => 1 sample becomes 4 samples) .*/
     bool auto_inserted; // inserted by af.c, such as conversion filters
+    char *label;
+
+    struct mp_audio fmt_in, fmt_out;
+
+    struct mp_audio **out_queued;
+    int num_out_queued;
+
+    struct mp_audio_pool *out_pool;
 };
 
 // Current audio stream
 struct af_stream {
+    int initialized; // 0: no, 1: yes, -1: attempted to, but failed
+
     // The first and last filter in the list
     struct af_instance *first;
     struct af_instance *last;
@@ -117,6 +128,7 @@ enum af_control {
     AF_CONTROL_SET_PAN_BALANCE,
     AF_CONTROL_GET_PAN_BALANCE,
     AF_CONTROL_SET_PLAYBACK_SPEED,
+    AF_CONTROL_SET_PLAYBACK_SPEED_RESAMPLE,
 };
 
 // Argument for AF_CONTROL_SET_PAN_LEVEL
@@ -130,11 +142,18 @@ void af_destroy(struct af_stream *s);
 int af_init(struct af_stream *s);
 void af_uninit(struct af_stream *s);
 struct af_instance *af_add(struct af_stream *s, char *name, char **args);
-int af_filter(struct af_stream *s, struct mp_audio *data, int flags);
+int af_remove_by_label(struct af_stream *s, char *label);
+struct af_instance *af_find_by_label(struct af_stream *s, char *label);
 struct af_instance *af_control_any_rev(struct af_stream *s, int cmd, void *arg);
 void af_control_all(struct af_stream *s, int cmd, void *arg);
+void af_seek_reset(struct af_stream *s);
+
+void af_add_output_frame(struct af_instance *af, struct mp_audio *frame);
+int af_filter_frame(struct af_stream *s, struct mp_audio *frame);
+int af_output_frame(struct af_stream *s, bool eof);
+struct mp_audio *af_read_output_frame(struct af_stream *s);
+int af_make_writeable(struct af_instance *af, struct mp_audio *frame);
 
-double af_calc_filter_multiplier(struct af_stream *s);
 double af_calc_delay(struct af_stream *s);
 
 int af_test_output(struct af_instance *af, struct mp_audio *out);

audio/filter/af_bs2b.c

@@ -37,34 +37,49 @@ struct af_bs2b {
     t_bs2bdp filter;    ///< instance of a library filter
 };
 
-#define FILTER(name, type) \
-static int filter_##name(struct af_instance *af, struct mp_audio *data, int f) \
+#define DEF_FILTER(fmt, name) \
+static int filter_##name(struct af_instance *af, struct mp_audio *data) \
 { \
-    /* filter is called for all pairs of samples available in the buffer */ \
+    if (!data) \
+        return 0; \
+    if (af_make_writeable(af, data) < 0) { \
+        talloc_free(data); \
+        return -1; \
+    } \
     bs2b_cross_feed_##name(((struct af_bs2b*)(af->priv))->filter, \
-        (type*)(data->planes[0]), data->samples); \
-\
+        (data->planes[0]), data->samples); \
+    af_add_output_frame(af, data); \
     return 0; \
 }
 
-FILTER(f, float)
-FILTER(fbe, float)
-FILTER(fle, float)
-FILTER(s32be, int32_t)
-FILTER(u32be, uint32_t)
-FILTER(s32le, int32_t)
-FILTER(u32le, uint32_t)
-FILTER(s24be, bs2b_int24_t)
-FILTER(u24be, bs2b_uint24_t)
-FILTER(s24le, bs2b_int24_t)
-FILTER(u24le, bs2b_uint24_t)
-FILTER(s16be, int16_t)
-FILTER(u16be, uint16_t)
-FILTER(s16le, int16_t)
-FILTER(u16le, uint16_t)
-FILTER(s8, int8_t)
-FILTER(u8, uint8_t)
+#define GET_FILTER(fmt, name) \
+    case AF_FORMAT_##fmt: return filter_##name;
 
+#define FILTERS \
+    FILTER(FLOAT,   f)      \
+    FILTER(S32,     s32)    \
+    FILTER(U32,     u32)    \
+    FILTER(S24,     s24)    \
+    FILTER(U24,     u24)    \
+    FILTER(S16,     s16)    \
+    FILTER(U16,     u16)    \
+    FILTER(S8,      s8)     \
+    FILTER(U8,      u8)
+
+#define FILTER DEF_FILTER
+FILTERS
+#undef FILTER
+
+typedef int (*filter)(struct af_instance *af, struct mp_audio *d);
+static filter get_filter(int fmt)
+{
+    switch (fmt) {
+#define FILTER GET_FILTER
+FILTERS
+#undef FILTER
+    default: return NULL;
+    }
+}
 
 /// Initialization and runtime control
 static int control(struct af_instance *af, int cmd, void *arg)
@@ -84,59 +99,10 @@ static int control(struct af_instance *af, int cmd, void *arg)
 
         /* check for formats supported by libbs2b
            and assign corresponding handlers */
-        switch (format) {
-            case AF_FORMAT_FLOAT_BE:
-                af->filter = filter_fbe;
-                break;
-            case AF_FORMAT_FLOAT_LE:
-                af->filter = filter_fle;
-                break;
-            case AF_FORMAT_S32_BE:
-                af->filter = filter_s32be;
-                break;
-            case AF_FORMAT_U32_BE:
-                af->filter = filter_u32be;
-                break;
-            case AF_FORMAT_S32_LE:
-                af->filter = filter_s32le;
-                break;
-            case AF_FORMAT_U32_LE:
-                af->filter = filter_u32le;
-                break;
-            case AF_FORMAT_S24_BE:
-                af->filter = filter_s24be;
-                break;
-            case AF_FORMAT_U24_BE:
-                af->filter = filter_u24be;
-                break;
-            case AF_FORMAT_S24_LE:
-                af->filter = filter_s24le;
-                break;
-            case AF_FORMAT_U24_LE:
-                af->filter = filter_u24le;
-                break;
-            case AF_FORMAT_S16_BE:
-                af->filter = filter_s16be;
-                break;
-            case AF_FORMAT_U16_BE:
-                af->filter = filter_u16be;
-                break;
-            case AF_FORMAT_S16_LE:
-                af->filter = filter_s16le;
-                break;
-            case AF_FORMAT_U16_LE:
-                af->filter = filter_u16le;
-                break;
-            case AF_FORMAT_S8:
-                af->filter = filter_s8;
-                break;
-            case AF_FORMAT_U8:
-                af->filter = filter_u8;
-                break;
-            default:
-                af->filter = filter_f;
-                mp_audio_set_format(af->data, AF_FORMAT_FLOAT);
-                break;
+        af->filter_frame = get_filter(format);
+        if (!af->filter_frame) {
+            af->filter_frame = filter_f;
+            mp_audio_set_format(af->data, AF_FORMAT_FLOAT);
         }
 
         // bs2b have srate limits, try to resample if needed

audio/filter/af_center.c

@@ -58,9 +58,14 @@ static int control(struct af_instance* af, int cmd, void* arg)
   return AF_UNKNOWN;
 }
 
-// Filter data through filter
-static int filter(struct af_instance* af, struct mp_audio* data, int flags)
+static int filter_frame(struct af_instance* af, struct mp_audio* data)
 {
+  if (!data)
+    return 0;
+  if (af_make_writeable(af, data) < 0) {
+    talloc_free(data);
+    return -1;
+  }
   struct mp_audio*    c   = data;        // Current working data
   af_center_t*  s   = af->priv; // Setup for this instance
   float*        a   = c->planes[0];      // Audio data
@@ -75,13 +80,14 @@ static int filter(struct af_instance* af, struct mp_audio* data, int flags)
     a[i+ch] = (a[i]/2) + (a[i+1]/2);
   }
 
+  af_add_output_frame(af, data);
   return 0;
 }
 
 // Allocate memory and set function pointers
 static int af_open(struct af_instance* af){
   af->control=control;
-  af->filter=filter;
+  af->filter_frame = filter_frame;
   return AF_OK;
 }
 

audio/filter/af_channels.c

@@ -181,15 +181,20 @@ static int control(struct af_instance* af, int cmd, void* arg)
   return AF_UNKNOWN;
 }
 
-// Filter data through filter
-static int filter(struct af_instance* af, struct mp_audio* data, int flags)
+static int filter_frame(struct af_instance *af, struct mp_audio *c)
 {
-  struct mp_audio*       c = data;                      // Current working data
-  struct mp_audio*       l = af->data;                  // Local data
   af_channels_t* s = af->priv;
   int            i;
 
-  mp_audio_realloc_min(af->data, data->samples);
+  if (!c)
+    return 0;
+
+  struct mp_audio *l = mp_audio_pool_get(af->out_pool, &af->fmt_out, c->samples);
+  if (!l) {
+    talloc_free(c);
+    return -1;
+  }
+  mp_audio_copy_attributes(l, c);
 
   // Reset unused channels
   memset(l->planes[0],0,mp_audio_psize(c) / c->nch * l->nch);
@@ -199,17 +204,15 @@ static int filter(struct af_instance* af, struct mp_audio* data, int flags)
       copy(af, c->planes[0],l->planes[0],c->nch,s->route[i][FR],
            l->nch,s->route[i][TO],mp_audio_psize(c),c->bps);
 
-  // Set output data
-  c->planes[0] = l->planes[0];
-  mp_audio_set_channels(c, &l->channels);
-
+  talloc_free(c);
+  af_add_output_frame(af, l);
   return 0;
 }
 
 // Allocate memory and set function pointers
 static int af_open(struct af_instance* af){
     af->control=control;
-    af->filter=filter;
+    af->filter_frame = filter_frame;
     af_channels_t *s = af->priv;
 
     // If router scan commandline for routing pairs

audio/filter/af_convert24.c

@@ -20,6 +20,7 @@
 
 #include "audio/format.h"
 #include "af.h"
+#include "osdep/endian.h"
 
 static bool test_conversion(int src_format, int dst_format)
 {
@@ -70,13 +71,19 @@ static int control(struct af_instance *af, int cmd, void *arg)
 #define SHIFT(x) (((x)+1)*8)
 #endif
 
-static int filter(struct af_instance *af, struct mp_audio *data, int flags)
+static int filter(struct af_instance *af, struct mp_audio *data)
 {
-    mp_audio_realloc_min(af->data, data->samples);
+    if (!data)
+        return 0;
+    struct mp_audio *out =
+        mp_audio_pool_get(af->out_pool, af->data, data->samples);
+    if (!out) {
+        talloc_free(data);
+        return -1;
+    }
+    mp_audio_copy_attributes(out, data);
 
-    struct mp_audio *out = af->data;
     size_t len = mp_audio_psize(data) / data->bps;
-
     if (data->bps == 4) {
         for (int s = 0; s < len; s++) {
             uint32_t val = *((uint32_t *)data->planes[0] + s);
@@ -85,7 +92,6 @@ static int filter(struct af_instance *af, struct mp_audio *data, int flags)
             ptr[1] = val >> SHIFT(1);
             ptr[2] = val >> SHIFT(2);
         }
-        mp_audio_set_format(data, af_fmt_change_bits(data->format, 24));
     } else {
         for (int s = 0; s < len; s++) {
             uint8_t *ptr = (uint8_t *)data->planes[0] + s * 3;
@@ -94,17 +100,17 @@ static int filter(struct af_instance *af, struct mp_audio *data, int flags)
                          | ptr[2] << SHIFT(2);
             *((uint32_t *)out->planes[0] + s) = val;
         }
-        mp_audio_set_format(data, af_fmt_change_bits(data->format, 32));
     }
 
-    data->planes[0] = out->planes[0];
+    talloc_free(data);
+    af_add_output_frame(af, out);
     return 0;
 }
 
 static int af_open(struct af_instance *af)
 {
     af->control = control;
-    af->filter = filter;
+    af->filter_frame = filter;
     return AF_OK;
 }
 

audio/filter/af_convertsignendian.c

@@ -20,21 +20,16 @@
 
 #include "af.h"
 #include "audio/format.h"
-#include "compat/mpbswap.h"
+#include "osdep/endian.h"
 
 static bool test_conversion(int src_format, int dst_format)
 {
     if ((src_format & AF_FORMAT_PLANAR) ||
         (dst_format & AF_FORMAT_PLANAR))
         return false;
-    int src_noend = src_format & ~AF_FORMAT_END_MASK;
-    int dst_noend = dst_format & ~AF_FORMAT_END_MASK;
-    // We can swap endian for all formats, but sign only for integer formats.
-    if (src_noend == dst_noend)
-        return true;
-    if (((src_noend & ~AF_FORMAT_SIGN_MASK) ==
-         (dst_noend & ~AF_FORMAT_SIGN_MASK)) &&
-        ((src_noend & AF_FORMAT_POINT_MASK) == AF_FORMAT_I))
+    if (((src_format & ~AF_FORMAT_SIGN_MASK) ==
+         (dst_format & ~AF_FORMAT_SIGN_MASK)) &&
+        ((src_format & AF_FORMAT_TYPE_MASK) == AF_FORMAT_I))
         return true;
     return false;
 }
@@ -63,34 +58,11 @@ static int control(struct af_instance *af, int cmd, void *arg)
     return AF_UNKNOWN;
 }
 
-static void endian(void *data, int len, int bps)
-{
-    switch (bps) {
-    case 2:
-        for (int i = 0; i < len; i++) {
-            ((uint16_t*)data)[i] = bswap_16(((uint16_t *)data)[i]);
-        }
-        break;
-    case 3:
-        for(int i = 0; i < len; i++) {
-            uint8_t s = ((uint8_t *)data)[3 * i];
-            ((uint8_t *)data)[3 * i] = ((uint8_t *)data)[3 * i + 2];
-            ((uint8_t *)data)[3 * i + 2] = s;
-        }
-        break;
-    case 4:
-        for(int i = 0; i < len; i++) {
-            ((uint32_t*)data)[i] = bswap_32(((uint32_t *)data)[i]);
-        }
-        break;
-    }
-}
-
-static void si2us(void *data, int len, int bps, bool le)
+static void si2us(void *data, int len, int bps)
 {
     ptrdiff_t i = -(len * bps);
     uint8_t *p = &((uint8_t *)data)[len * bps];
-    if (le && bps > 1)
+    if (BYTE_ORDER == LITTLE_ENDIAN && bps > 1)
         p += bps - 1;
     if (len <= 0)
         return;
@@ -99,33 +71,37 @@ static void si2us(void *data, int len, int bps, bool le)
     } while (i += bps);
 }
 
-static int filter(struct af_instance *af, struct mp_audio *data, int flags)
+static int filter(struct af_instance *af, struct mp_audio *data)
 {
+    if (!data)
+        return 0;
+    if (af_make_writeable(af, data) < 0) {
+        talloc_free(data);
+        return -1;
+    }
+
     int infmt = data->format;
     int outfmt = af->data->format;
     size_t len = data->samples * data->nch;
 
-    if ((infmt & AF_FORMAT_END_MASK) != (outfmt & AF_FORMAT_END_MASK))
-        endian(data->planes[0], len, data->bps);
-
     if ((infmt & AF_FORMAT_SIGN_MASK) != (outfmt & AF_FORMAT_SIGN_MASK))
-        si2us(data->planes[0], len, data->bps,
-              (outfmt & AF_FORMAT_END_MASK) == AF_FORMAT_LE);
+        si2us(data->planes[0], len, data->bps);
 
     mp_audio_set_format(data, outfmt);
+    af_add_output_frame(af, data);
     return 0;
 }
 
 static int af_open(struct af_instance *af)
 {
     af->control = control;
-    af->filter = filter;
+    af->filter_frame = filter;
     return AF_OK;
 }
 
 const struct af_info af_info_convertsignendian = {
-    .info = "Convert between sample format sign/endian",
-    .name = "convertsignendian",
+    .info = "Convert between sample format sign",
+    .name = "convertsign",
     .open = af_open,
     .test_conversion = test_conversion,
 };

audio/filter/af_delay.c

@@ -96,15 +96,19 @@ static void uninit(struct af_instance* af)
       free(((af_delay_t*)(af->priv))->q[i]);
 }
 
-// Filter data through filter
-static int filter(struct af_instance* af, struct mp_audio* data, int flags)
+static int filter_frame(struct af_instance *af, struct mp_audio *c)
 {
-  struct mp_audio*      c   = data;      // Current working data
+  if (!c)
+    return 0;
   af_delay_t*   s   = af->priv; // Setup for this instance
   int           nch = c->nch;    // Number of channels
   int           len = mp_audio_psize(c)/c->bps; // Number of sample in data chunk
   int           ri  = 0;
   int           ch,i;
+  if (af_make_writeable(af, c) < 0) {
+    talloc_free(c);
+    return -1;
+  }
   for(ch=0;ch<nch;ch++){
     switch(c->bps){
     case 1:{
@@ -152,6 +156,7 @@ static int filter(struct af_instance* af, struct mp_audio* data, int flags)
     }
   }
   s->ri = ri;
+  af_add_output_frame(af, c);
   return 0;
 }
 
@@ -159,7 +164,7 @@ static int filter(struct af_instance* af, struct mp_audio* data, int flags)
 static int af_open(struct af_instance* af){
     af->control=control;
     af->uninit=uninit;
-    af->filter=filter;
+    af->filter_frame = filter_frame;
     af_delay_t *s = af->priv;
     int n = 1;
     int i = 0;

audio/filter/af_drc.c

@@ -272,10 +272,18 @@ static void method2_float(af_drc_t *s, struct mp_audio *c)
   s->idx = (s->idx + 1) % NSAMPLES;
 }
 
-static int filter(struct af_instance* af, struct mp_audio* data, int flags)
+static int filter(struct af_instance *af, struct mp_audio *data)
 {
   af_drc_t *s = af->priv;
 
+  if (!data)
+    return 0;
+
+  if (af_make_writeable(af, data) < 0) {
+    talloc_free(data);
+    return -1;
+  }
+
   if(af->data->format == (AF_FORMAT_S16))
   {
     if (s->method == 2)
@@ -290,6 +298,7 @@ static int filter(struct af_instance* af, struct mp_audio* data, int flags)
     else
         method1_float(s, data);
   }
+  af_add_output_frame(af, data);
   return 0;
 }
 
@@ -297,7 +306,7 @@ static int filter(struct af_instance* af, struct mp_audio* data, int flags)
 static int af_open(struct af_instance* af){
   int i = 0;
   af->control=control;
-  af->filter=filter;
+  af->filter_frame = filter;
   af_drc_t *priv = af->priv;
 
   priv->mul = MUL_INIT;

audio/filter/af_dummy.c

@@ -41,15 +41,16 @@ static int control(struct af_instance* af, int cmd, void* arg)
 }
 
 // Filter data through filter
-static int filter(struct af_instance* af, struct mp_audio* data, int flags)
+static int filter(struct af_instance* af, struct mp_audio* data)
 {
+    af_add_output_frame(af, data);
     return 0;
 }
 
 // Allocate memory and set function pointers
 static int af_open(struct af_instance* af){
   af->control=control;
-  af->filter=filter;
+  af->filter_frame=filter;
   return AF_OK;
 }
 

audio/filter/af_equalizer.c

@@ -141,14 +141,20 @@ static int control(struct af_instance* af, int cmd, void* arg)
   return AF_UNKNOWN;
 }
 
-// Filter data through filter
-static int filter(struct af_instance* af, struct mp_audio* data, int flags)
+static int filter(struct af_instance* af, struct mp_audio* data)
 {
   struct mp_audio*       c      = data;                         // Current working data
+  if (!c)
+    return 0;
   af_equalizer_t*  s    = (af_equalizer_t*)af->priv;    // Setup
   uint32_t         ci   = af->data->nch;                // Index for channels
   uint32_t         nch  = af->data->nch;                // Number of channels
 
+  if (af_make_writeable(af, data) < 0) {
+    talloc_free(data);
+    return -1;
+  }
+
   while(ci--){
     float*      g   = s->g[ci];      // Gain factor
     float*      in  = ((float*)c->planes[0])+ci;
@@ -177,13 +183,14 @@ static int filter(struct af_instance* af, struct mp_audio* data, int flags)
       out+=nch;
     }
   }
+  af_add_output_frame(af, data);
   return 0;
 }
 
 // Allocate memory and set function pointers
 static int af_open(struct af_instance* af){
   af->control=control;
-  af->filter=filter;
+  af->filter_frame = filter;
   af_equalizer_t *priv = af->priv;
   for(int i=0;i<AF_NCH;i++){
       for(int j=0;j<KM;j++){

audio/filter/af_export.c

@@ -34,7 +34,6 @@
 #include "config.h"
 
 #include <sys/types.h>
-#include <sys/mman.h>
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <fcntl.h>
@@ -78,8 +77,7 @@ static int control(struct af_instance* af, int cmd, void* arg)
     int mapsize;
 
     // Free previous buffers
-    if (s->buf)
-      free(s->buf[0]);
+    free(s->buf[0]);
 
     // unmap previous area
     if(s->mmap_area)
@@ -94,8 +92,10 @@ static int control(struct af_instance* af, int cmd, void* arg)
 
     // Allocate new buffers (as one continuous block)
     s->buf[0] = calloc(s->sz*af->data->nch, af->data->bps);
-    if(NULL == s->buf[0])
+    if(NULL == s->buf[0]) {
       MP_FATAL(af, "Out of memory\n");
+      return AF_ERROR;
+    }
     for(i = 1; i < af->data->nch; i++)
       s->buf[i] = (uint8_t *)s->buf[0] + i*s->sz*af->data->bps;
 
@@ -147,8 +147,8 @@ static int control(struct af_instance* af, int cmd, void* arg)
 static void uninit( struct af_instance* af )
 {
     af_export_t* s = af->priv;
-    if (s->buf)
-      free(s->buf[0]);
+
+    free(s->buf[0]);
 
     // Free mmaped area
     if(s->mmap_area)
@@ -162,8 +162,10 @@ static void uninit( struct af_instance* af )
    af audio filter instance
    data audio data
 */
-static int filter( struct af_instance* af, struct mp_audio* data, int flags)
+static int filter(struct af_instance *af, struct mp_audio *data)
 {
+  if (!data)
+    return 0;
   struct mp_audio*      c   = data;          // Current working data
   af_export_t*  s   = af->priv;     // Setup for this instance
   int16_t*      a   = c->planes[0];          // Incomming sound
@@ -199,6 +201,7 @@ static int filter( struct af_instance* af, struct mp_audio* data, int flags)
            &(s->count), sizeof(s->count));
   }
 
+  af_add_output_frame(af, data);
   return 0;
 }
 
@@ -210,7 +213,7 @@ static int af_open( struct af_instance* af )
 {
   af->control = control;
   af->uninit  = uninit;
-  af->filter  = filter;
+  af->filter_frame = filter;
   af_export_t *priv = af->priv;
 
   if (!priv->filename || !priv->filename[0]) {

audio/filter/af_extrastereo.c

@@ -35,9 +35,6 @@ typedef struct af_extrastereo_s
     float mul;
 }af_extrastereo_t;
 
-static int play_s16(struct af_instance* af, struct mp_audio* data, int f);
-static int play_float(struct af_instance* af, struct mp_audio* data, int f);
-
 // Initialization and runtime control
 static int control(struct af_instance* af, int cmd, void* arg)
 {
@@ -49,14 +46,8 @@ static int control(struct af_instance* af, int cmd, void* arg)
     mp_audio_copy_config(af->data, (struct mp_audio*)arg);
     mp_audio_force_interleaved_format(af->data);
     mp_audio_set_num_channels(af->data, 2);
-    if (af->data->format == AF_FORMAT_FLOAT)
-    {
-        af->filter = play_float;
-    }// else
-    {
+    if (af->data->format != AF_FORMAT_FLOAT)
         mp_audio_set_format(af->data, AF_FORMAT_S16);
-        af->filter = play_s16;
-    }
 
     return af_test_output(af,(struct mp_audio*)arg);
   }
@@ -65,9 +56,8 @@ static int control(struct af_instance* af, int cmd, void* arg)
 }
 
 // Filter data through filter
-static int play_s16(struct af_instance* af, struct mp_audio* data, int f)
+static void play_s16(af_extrastereo_t *s, struct mp_audio* data)
 {
-  af_extrastereo_t *s = af->priv;
   register int i = 0;
   int16_t *a = (int16_t*)data->planes[0];       // Audio data
   int len = data->samples*data->nch;            // Number of samples
@@ -83,13 +73,10 @@ static int play_s16(struct af_instance* af, struct mp_audio* data, int f)
     a[i] = MPCLAMP(l, SHRT_MIN, SHRT_MAX);
     a[i + 1] = MPCLAMP(r, SHRT_MIN, SHRT_MAX);
   }
-
-  return 0;
 }
 
-static int play_float(struct af_instance* af, struct mp_audio* data, int f)
+static void play_float(af_extrastereo_t *s, struct mp_audio* data)
 {
-  af_extrastereo_t *s = af->priv;
   register int i = 0;
   float *a = (float*)data->planes[0];   // Audio data
   int len = data->samples * data->nch;  // Number of samples
@@ -105,14 +92,29 @@ static int play_float(struct af_instance* af, struct mp_audio* data, int f)
     a[i] = af_softclip(l);
     a[i + 1] = af_softclip(r);
   }
+}
 
-  return 0;
+static int filter_frame(struct af_instance *af, struct mp_audio *data)
+{
+    if (!data)
+        return 0;
+    if (af_make_writeable(af, data) < 0) {
+        talloc_free(data);
+        return -1;
+    }
+    if (data->format == AF_FORMAT_FLOAT) {
+        play_float(af->priv, data);
+    } else {
+        play_s16(af->priv, data);
+    }
+    af_add_output_frame(af, data);
+    return 0;
 }
 
 // Allocate memory and set function pointers
 static int af_open(struct af_instance* af){
   af->control=control;
-  af->filter=play_s16;
+  af->filter_frame = filter_frame;
 
   return AF_OK;
 }

audio/filter/af_forcespeed.c

@@ -0,0 +1,71 @@
+/*
+ * This file is part of mpv.
+ *
+ * mpv is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * mpv is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with mpv.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "af.h"
+
+struct priv {
+    double speed;
+};
+
+static int control(struct af_instance *af, int cmd, void *arg)
+{
+    struct priv *priv = af->priv;
+
+    switch (cmd) {
+    case AF_CONTROL_REINIT: {
+        struct mp_audio *in = arg;
+        struct mp_audio orig_in = *in;
+        struct mp_audio *out = af->data;
+
+        mp_audio_copy_config(out, in);
+        out->rate = in->rate * priv->speed;
+
+        return mp_audio_config_equals(in, &orig_in) ? AF_OK : AF_FALSE;
+    }
+    case AF_CONTROL_SET_PLAYBACK_SPEED_RESAMPLE: {
+        priv->speed = *(double *)arg;
+        return AF_OK;
+    }
+    }
+    return AF_UNKNOWN;
+}
+
+static int filter(struct af_instance *af, struct mp_audio *data)
+{
+    if (data)
+        mp_audio_copy_config(data, af->data);
+    af_add_output_frame(af, data);
+    return 0;
+}
+
+static int af_open(struct af_instance *af)
+{
+    struct priv *priv = af->priv;
+    af->control = control;
+    af->filter_frame = filter;
+    priv->speed = 1.0;
+    return AF_OK;
+}
+
+#define OPT_BASE_STRUCT struct priv
+
+const struct af_info af_info_forcespeed = {
+    .info = "Force audio speed",
+    .name = "forcespeed",
+    .open = af_open,
+    .priv_size = sizeof(struct priv),
+};

audio/filter/af_format.c

@@ -80,12 +80,12 @@ static int control(struct af_instance *af, int cmd, void *arg)
         force_out_params(af, out);
 
         if (in->nch != out->nch || in->bps != out->bps) {
-            MP_ERR(af, "[af_format] Forced input/output formats are incompatible.\n");
+            MP_ERR(af, "Forced input/output formats are incompatible.\n");
             return AF_ERROR;
         }
 
         if (priv->fail) {
-            MP_ERR(af, "[af_format] Failing on purpose.\n");
+            MP_ERR(af, "Failing on purpose.\n");
             return AF_ERROR;
         }
 
@@ -95,16 +95,18 @@ static int control(struct af_instance *af, int cmd, void *arg)
     return AF_UNKNOWN;
 }
 
-static int filter(struct af_instance *af, struct mp_audio *data, int flags)
+static int filter(struct af_instance *af, struct mp_audio *data)
 {
-    mp_audio_copy_config(data, af->data);
+    if (data)
+        mp_audio_copy_config(data, af->data);
+    af_add_output_frame(af, data);
     return 0;
 }
 
 static int af_open(struct af_instance *af)
 {
     af->control = control;
-    af->filter = filter;
+    af->filter_frame = filter;
 
     force_in_params(af, af->data);
     force_out_params(af, af->data);

audio/filter/af_hrtf.c

@@ -280,8 +280,34 @@ static inline void update_ch(af_hrtf_t *s, short *in, const int k)
     }
 
     /* We need to update the bass compensation delay line, too. */
-    s->ba_l[k] = in[0] + in[4] + in[2];
-    s->ba_r[k] = in[4] + in[1] + in[3];
+    // TODO: should this use lf/cf/rf etc. instead?
+    s->ba_l[k] = in[0];
+    s->ba_r[k] = in[1];
+    if (s->decode_mode == HRTF_MIX_51) {
+        s->ba_l[k] += in[4] + in[2];
+        s->ba_r[k] += in[4] + in[3];
+    }
+}
+
+static void clear_coeff(af_hrtf_t *s, float *c)
+{
+    memset(c, 0, s->dlbuflen * sizeof(float));
+}
+
+static void reset(af_hrtf_t *s)
+{
+    clear_coeff(s, s->lf);
+    clear_coeff(s, s->rf);
+    clear_coeff(s, s->lr);
+    clear_coeff(s, s->rr);
+    clear_coeff(s, s->cf);
+    clear_coeff(s, s->cr);
+    clear_coeff(s, s->ba_l);
+    clear_coeff(s, s->ba_r);
+    clear_coeff(s, s->fwrbuf_l);
+    clear_coeff(s, s->fwrbuf_r);
+    clear_coeff(s, s->fwrbuf_lr);
+    clear_coeff(s, s->fwrbuf_rr);
 }
 
 /* Initialization and runtime control */
@@ -292,30 +318,27 @@ static int control(struct af_instance *af, int cmd, void* arg)
 
     switch(cmd) {
     case AF_CONTROL_REINIT:
-        af->data->rate   = ((struct mp_audio*)arg)->rate;
-        if(af->data->rate != 48000) {
-            // automatic samplerate adjustment in the filter chain
-            // is not yet supported.
-            MP_ERR(af, "ERROR: Sampling rate is not 48000 Hz (%d)!\n",
-                   af->data->rate);
-            return AF_ERROR;
-        }
+        reset(s);
+        af->data->rate = 48000;
         mp_audio_set_channels_old(af->data, ((struct mp_audio*)arg)->nch);
-            if(af->data->nch == 2) {
-               /* 2 channel input */
-               if(s->decode_mode != HRTF_MIX_MATRIX2CH) {
-                  /* Default behavior is stereo mixing. */
-                  s->decode_mode = HRTF_MIX_STEREO;
-               }
+        if(af->data->nch == 2) {
+            /* 2 channel input */
+            if(s->decode_mode != HRTF_MIX_MATRIX2CH) {
+                /* Default behavior is stereo mixing. */
+                s->decode_mode = HRTF_MIX_STEREO;
             }
-            else if (af->data->nch < 5)
-              mp_audio_set_channels_old(af->data, 5);
+        } else if (af->data->nch < 5) {
+            mp_audio_set_channels_old(af->data, 5);
+        }
         mp_audio_set_format(af->data, AF_FORMAT_S16);
         test_output_res = af_test_output(af, (struct mp_audio*)arg);
         // after testing input set the real output format
         mp_audio_set_num_channels(af->data, 2);
         s->print_flag = 1;
         return test_output_res;
+    case AF_CONTROL_RESET:
+        reset(s);
+        return AF_OK;
     }
 
     return AF_UNKNOWN;
@@ -352,17 +375,26 @@ frequencies).
 2. A bass compensation is introduced to ensure that 0-200 Hz are not
 damped (without any real 3D acoustical image, however).
 */
-static int filter(struct af_instance *af, struct mp_audio *data, int flags)
+static int filter(struct af_instance *af, struct mp_audio *data)
 {
     af_hrtf_t *s = af->priv;
+
+    if (!data)
+        return 0;
+    struct mp_audio *outframe =
+        mp_audio_pool_get(af->out_pool, &af->fmt_out, data->samples);
+    if (!outframe) {
+        talloc_free(data);
+        return -1;
+    }
+    mp_audio_copy_attributes(outframe, data);
+
     short *in = data->planes[0]; // Input audio data
-    short *out = NULL; // Output audio data
+    short *out = outframe->planes[0]; // Output audio data
     short *end = in + data->samples * data->nch; // Loop end
     float common, left, right, diff, left_b, right_b;
     const int dblen = s->dlbuflen, hlen = s->hrflen, blen = s->basslen;
 
-    mp_audio_realloc_min(af->data, data->samples);
-
     if(s->print_flag) {
         s->print_flag = 0;
         switch (s->decode_mode) {
@@ -389,8 +421,6 @@ static int filter(struct af_instance *af, struct mp_audio *data, int flags)
                  "channel\n");
     }
 
-    out = af->data->planes[0];
-
     /* MPlayer's 5 channel layout (notation for the variable):
      *
      * 0: L (LF), 1: R (RF), 2: Ls (LR), 3: Rs (RR), 4: C (CF), matrix
@@ -528,10 +558,8 @@ static int filter(struct af_instance *af, struct mp_audio *data, int flags)
             s->cyc_pos += dblen;
     }
 
-    /* Set output data */
-    data->planes[0] = af->data->planes[0];
-    mp_audio_set_num_channels(data, 2);
-
+    talloc_free(data);
+    af_add_output_frame(af, outframe);
     return 0;
 }
 
@@ -565,7 +593,7 @@ static int af_open(struct af_instance* af)
 
     af->control = control;
     af->uninit = uninit;
-    af->filter = filter;
+    af->filter_frame = filter;
 
     s = af->priv;
 

audio/filter/af_karaoke.c

@@ -41,10 +41,15 @@ static int control(struct af_instance* af, int cmd, void* arg)
         return AF_UNKNOWN;
 }
 
-// Filter data through filter
-static int play(struct af_instance* af, struct mp_audio* data, int flags)
+static int filter_frame(struct af_instance *af, struct mp_audio *c)
 {
-        struct mp_audio*        c       = data;          // Current working data
+        if (!c)
+                return 0;
+        if (af_make_writeable(af, c) < 0) {
+                talloc_free(c);
+                return 0;
+        }
+
         float*          a       = c->planes[0];  // Audio data
         int                     nch     = c->nch;        // Number of channels
         int                     len     = c->samples*nch;        // Number of samples in current audio block
@@ -62,13 +67,14 @@ static int play(struct af_instance* af, struct mp_audio* data, int flags)
                 a[i+1]=a[i];
         }
 
+        af_add_output_frame(af, c);
         return 0;
 }
 
 // Allocate memory and set function pointers
 static int af_open(struct af_instance* af){
         af->control     = control;
-        af->filter      = play;
+        af->filter_frame = filter_frame;
         return AF_OK;
 }