RPI support

This requires FFmpeg git master for accelerated hardware decoding.
Keep in mind that FFmpeg must be compiled with --enable-mmal. Libav
will also work.

Most things work. Screenshots don't work with accelerated/opaque
decoding (except using full window screenshot mode). Subtitles are
very slow - even simple but huge overlays can cause frame drops.

This always uses fullscreen mode. It uses dispmanx and mmal directly,
and there are no window managers or anything on this level.

vo_opengl also kind of works, but is pretty useless and slow. It can't
use opaque hardware decoding (copy back can be used by forcing the
option --vd=lavc:h264_mmal). Keep in mind that the dispmanx backend
is preferred over the X11 ones in case you're trying on X11; but X11
is even more useless on RPI.

This doesn't correctly reject extended h264 profiles and thus doesn't
fallback to software decoding. The hw supports only up to the high
profile, and will e.g. return garbage for Hi10P video.

This sets a precedent of enabling hw decoding by default, but only
if RPI support is compiled (which most hopefully it will be disabled
on desktop Linux platforms). While it's more or less required to use
hw decoding on the weak RPI, it causes more problems than it solves
on real platforms (Linux has the Intel GPU problem, OSX still has
some cases with broken decoding.) So I can live with this compromise
of having different defaults depending on the platform.

Raspberry Pi 2 is required. This wasn't tested on the original RPI,
though at least decoding itself seems to work (but full playback was
not tested).

1 files changed, 567 insertions, 0 deletions

diff --git a/video/out/vo_rpi.c b/video/out/vo_rpi.c
new file mode 100644
index 0000000000..e197477987
--- /dev/null
+++ b/video/out/vo_rpi.c
@@ -0,0 +1,567 @@
+/*
+ * 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 <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+#include <stdbool.h>
+#include <assert.h>
+
+#include <bcm_host.h>
+#include <interface/mmal/mmal.h>
+#include <interface/mmal/util/mmal_util.h>
+#include <interface/mmal/util/mmal_default_components.h>
+
+#include <libavutil/rational.h>
+
+#include "common/common.h"
+#include "common/msg.h"
+#include "options/m_config.h"
+#include "vo.h"
+#include "video/mp_image.h"
+#include "sub/osd.h"
+#include "sub/img_convert.h"
+
+// In theory, the number of RGBA subbitmaps the OSD code could give us is
+// unlimited; but in practice there will be rarely many elements.
+#define MAX_OSD_ELEMS MP_SUB_BB_LIST_MAX
+
+struct osd_elem {
+    DISPMANX_RESOURCE_HANDLE_T resource;
+    DISPMANX_ELEMENT_HANDLE_T element;
+};
+
+struct osd_part {
+    struct osd_elem elems[MAX_OSD_ELEMS];
+    int num_elems;
+    int change_id;
+    bool needed;
+};
+
+struct priv {
+    DISPMANX_DISPLAY_HANDLE_T display;
+    DISPMANX_ELEMENT_HANDLE_T window;
+    DISPMANX_UPDATE_HANDLE_T update;
+    uint32_t w, h;
+
+    struct osd_part osd_parts[MAX_OSD_PARTS];
+    double osd_pts;
+    struct mp_osd_res osd_res;
+
+    MMAL_COMPONENT_T *renderer;
+    bool renderer_enabled;
+
+    struct mp_image *next_image;
+
+    // for RAM input
+    MMAL_POOL_T *swpool;
+
+    int background_layer;
+    int video_layer;
+    int osd_layer;
+
+    int display_nr;
+    int layer;
+};
+
+// Magic alignments (in pixels) expected by the MMAL internals.
+#define ALIGN_W 32
+#define ALIGN_H 16
+
+// Make mpi point to buffer, assuming MMAL_ENCODING_I420.
+// buffer can be NULL.
+// Return the required buffer space.
+static size_t layout_buffer(struct mp_image *mpi, MMAL_BUFFER_HEADER_T *buffer,
+                            struct mp_image_params *params)
+{
+    assert(params->imgfmt == IMGFMT_420P);
+    mp_image_set_params(mpi, params);
+    int w = MP_ALIGN_UP(params->w, ALIGN_W);
+    int h = MP_ALIGN_UP(params->h, ALIGN_H);
+    uint8_t *cur = buffer ? buffer->data : NULL;
+    size_t size = 0;
+    for (int i = 0; i < 3; i++) {
+        int div = i ? 2 : 1;
+        mpi->planes[i] = cur;
+        mpi->stride[i] = w / div;
+        size_t plane_size = h / div * mpi->stride[i];
+        if (cur)
+            cur += plane_size;
+        size += plane_size;
+    }
+    return size;
+}
+
+static void wipe_osd_part(struct vo *vo, struct osd_part *part)
+{
+    struct priv *p = vo->priv;
+
+    for (int n = 0; n < part->num_elems; n++) {
+        vc_dispmanx_element_remove(p->update, part->elems[n].element);
+        vc_dispmanx_resource_delete(part->elems[n].resource);
+    }
+    part->num_elems = 0;
+    part->change_id = -1;
+}
+
+static void wipe_osd(struct vo *vo)
+{
+    struct priv *p = vo->priv;
+
+    for (int x = 0; x < MAX_OSD_PARTS; x++)
+        wipe_osd_part(vo, &p->osd_parts[x]);
+}
+
+static int add_element(struct vo *vo, struct osd_part *part, int index,
+                       struct sub_bitmap *sub)
+{
+    struct priv *p = vo->priv;
+    VC_IMAGE_TYPE_T format = VC_IMAGE_ARGB8888; // assuming RPI is always LE
+
+    struct osd_elem *elem = &part->elems[index];
+    *elem = (struct osd_elem){0};
+
+    // I have no idea why stride must be passed in such a hacky way. It's not
+    // documented. Other software does it too. Other software claims aligning
+    // the width and "probably" the height is required too, but for me it works
+    // just fine without on rpi2. (See Weston's rpi renderer.)
+    elem->resource = vc_dispmanx_resource_create(format,
+                                                 sub->w | (sub->stride << 16),
+                                                 sub->h,
+                                                 &(int32_t){0});
+    if (!elem->resource) {
+        MP_ERR(vo, "Could not create %dx%d sub-bitmap\n", sub->w, sub->h);
+        return -1;
+    }
+
+    VC_RECT_T rc = {.width = sub->w, .height = sub->h};
+    vc_dispmanx_resource_write_data(elem->resource, format,
+                                    sub->stride, sub->bitmap, &rc);
+    VC_RECT_T src = {.width = sub->w << 16, .height = sub->h << 16};
+    VC_RECT_T dst = {.x = sub->x, .y = sub->y, .width = sub->dw, .height = sub->dh};
+    VC_DISPMANX_ALPHA_T alpha = {
+        .flags = DISPMANX_FLAGS_ALPHA_FROM_SOURCE | DISPMANX_FLAGS_ALPHA_PREMULT,
+        .opacity = 0xFF,
+    };
+    elem->element = vc_dispmanx_element_add(p->update, p->display, p->osd_layer,
+                                            &dst, elem->resource, &src,
+                                            DISPMANX_PROTECTION_NONE,
+                                            &alpha, 0, 0);
+    if (!elem->element) {
+        MP_ERR(vo, "Could not create sub-bitmap element\n");
+        return -1;
+    }
+
+    return 0;
+}
+
+static void osd_draw_cb(void *ctx, struct sub_bitmaps *imgs)
+{
+    struct vo *vo = ctx;
+    struct priv *p = vo->priv;
+    struct osd_part *part = &p->osd_parts[imgs->render_index];
+
+    part->needed = true;
+
+    if (imgs->change_id == part->change_id)
+        return;
+
+    wipe_osd_part(vo, part);
+    part->change_id = imgs->change_id;
+
+    for (int n = 0; n < imgs->num_parts; n++) {
+        if (part->num_elems == MAX_OSD_ELEMS) {
+            MP_ERR(vo, "Too many OSD elements.\n");
+            break;
+        }
+        int index = part->num_elems++;
+        if (add_element(vo, part, index, &imgs->parts[n]) < 0)
+            break;
+    }
+}
+
+static void update_osd(struct vo *vo)
+{
+    struct priv *p = vo->priv;
+
+    for (int x = 0; x < MAX_OSD_PARTS; x++)
+        p->osd_parts[x].needed = false;
+
+    static const bool formats[SUBBITMAP_COUNT] = {[SUBBITMAP_RGBA] = true};
+    osd_draw(vo->osd, p->osd_res, p->osd_pts, 0, formats, osd_draw_cb, vo);
+
+    for (int x = 0; x < MAX_OSD_PARTS; x++) {
+        struct osd_part *part = &p->osd_parts[x];
+        if (!part->needed)
+            wipe_osd_part(vo, part);
+    }
+}
+
+static void resize(struct vo *vo)
+{
+    struct priv *p = vo->priv;
+    MMAL_PORT_T *input = p->renderer->input[0];
+
+    struct mp_rect src, dst;
+
+    vo_get_src_dst_rects(vo, &src, &dst, &p->osd_res);
+
+    MMAL_DISPLAYREGION_T dr = {
+        .hdr = { .id = MMAL_PARAMETER_DISPLAYREGION,
+                 .size = sizeof(MMAL_DISPLAYREGION_T), },
+        .src_rect = { .x = src.x0, .y = src.y0,
+                      .width = src.x1 - src.x0, .height = src.y1 - src.y0, },
+        .dest_rect = { .x = dst.x0, .y = dst.y0,
+                       .width = dst.x1 - dst.x0, .height = dst.y1 - dst.y0, },
+        .layer = p->video_layer,
+        .display_num = p->display_nr,
+        .set = MMAL_DISPLAY_SET_SRC_RECT | MMAL_DISPLAY_SET_DEST_RECT |
+               MMAL_DISPLAY_SET_LAYER | MMAL_DISPLAY_SET_NUM,
+    };
+
+    if (mmal_port_parameter_set(input, &dr.hdr))
+        MP_WARN(vo, "could not set video rectangle\n");
+}
+
+static void flip_page(struct vo *vo)
+{
+    struct priv *p = vo->priv;
+    struct mp_image *mpi = p->next_image;
+    p->next_image = NULL;
+
+    // For OSD
+    vc_dispmanx_update_submit_sync(p->update);
+    p->update = vc_dispmanx_update_start(10);
+
+    if (mpi) {
+        MMAL_PORT_T *input = p->renderer->input[0];
+        MMAL_BUFFER_HEADER_T *ref = (void *)mpi->planes[3];
+
+        // Assume this field is free for use by us.
+        ref->user_data = mpi;
+
+        if (mmal_port_send_buffer(input, ref)) {
+            MP_ERR(vo, "could not queue picture!\n");
+            talloc_free(mpi);
+        }
+    }
+}
+
+static void free_mmal_buffer(void *arg)
+{
+    MMAL_BUFFER_HEADER_T *buffer = arg;
+    mmal_buffer_header_release(buffer);
+}
+
+static void draw_image(struct vo *vo, mp_image_t *mpi)
+{
+    struct priv *p = vo->priv;
+
+    talloc_free(p->next_image);
+    p->next_image = NULL;
+
+    p->osd_pts = mpi->pts;
+    update_osd(vo);
+
+    if (vo->params->imgfmt != IMGFMT_MMAL) {
+        MMAL_BUFFER_HEADER_T *buffer = mmal_queue_wait(p->swpool->queue);
+        if (!buffer) {
+            talloc_free(mpi);
+            MP_ERR(vo, "Can't allocate buffer.\n");
+            return;
+        }
+        mmal_buffer_header_reset(buffer);
+
+        struct mp_image *new_ref = mp_image_new_custom_ref(&(struct mp_image){0},
+                                                           buffer,
+                                                           free_mmal_buffer);
+        if (!new_ref) {
+            mmal_buffer_header_release(buffer);
+            talloc_free(mpi);
+            MP_ERR(vo, "Out of memory.\n");
+            return;
+        }
+
+        mp_image_setfmt(new_ref, IMGFMT_MMAL);
+        new_ref->planes[3] = (void *)buffer;
+
+        struct mp_image dmpi = {0};
+        buffer->length = layout_buffer(&dmpi, buffer, vo->params);
+        mp_image_copy(&dmpi, mpi);
+
+        talloc_free(mpi);
+        mpi = new_ref;
+    }
+
+    p->next_image = mpi;
+}
+
+static int query_format(struct vo *vo, int format)
+{
+    return format == IMGFMT_MMAL || format == IMGFMT_420P;
+}
+
+static MMAL_FOURCC_T map_csp(enum mp_csp csp)
+{
+    switch (csp) {
+    case MP_CSP_BT_601:     return MMAL_COLOR_SPACE_ITUR_BT601;
+    case MP_CSP_BT_709:     return MMAL_COLOR_SPACE_ITUR_BT709;
+    case MP_CSP_SMPTE_240M: return MMAL_COLOR_SPACE_SMPTE240M;
+    default:                return MMAL_COLOR_SPACE_UNKNOWN;
+    }
+}
+
+static void control_port_cb(MMAL_PORT_T *port, MMAL_BUFFER_HEADER_T *buffer)
+{
+    mmal_buffer_header_release(buffer);
+}
+
+static void input_port_cb(MMAL_PORT_T *port, MMAL_BUFFER_HEADER_T *buffer)
+{
+    struct mp_image *mpi = buffer->user_data;
+    talloc_free(mpi);
+}
+
+static void disable_renderer(struct vo *vo)
+{
+    struct priv *p = vo->priv;
+
+    if (p->renderer_enabled) {
+        mmal_port_disable(p->renderer->control);
+        mmal_port_disable(p->renderer->input[0]);
+
+        mmal_port_flush(p->renderer->control);
+        mmal_port_flush(p->renderer->input[0]);
+
+        mmal_component_disable(p->renderer);
+    }
+    mmal_pool_destroy(p->swpool);
+    p->swpool = NULL;
+    p->renderer_enabled = false;
+}
+
+static int reconfig(struct vo *vo, struct mp_image_params *params, int flags)
+{
+    struct priv *p = vo->priv;
+    MMAL_PORT_T *input = p->renderer->input[0];
+    bool opaque = params->imgfmt == IMGFMT_MMAL;
+
+    vo->dwidth = p->w;
+    vo->dheight = p->h;
+
+    disable_renderer(vo);
+
+    AVRational dr = {params->d_w, params->d_h};
+    AVRational ir = {params->w, params->h};
+    AVRational par = av_div_q(dr, ir);
+
+    input->format->encoding = opaque ? MMAL_ENCODING_OPAQUE : MMAL_ENCODING_I420;
+    input->format->es->video.width = MP_ALIGN_UP(params->w, ALIGN_W);
+    input->format->es->video.height = MP_ALIGN_UP(params->h, ALIGN_H);
+    input->format->es->video.crop = (MMAL_RECT_T){0, 0, params->w, params->h};
+    input->format->es->video.par = (MMAL_RATIONAL_T){par.num, par.den};
+    input->format->es->video.color_space = map_csp(params->colorspace);
+
+    if (mmal_port_format_commit(input))
+        return -1;
+
+    input->buffer_num = MPMAX(input->buffer_num_min,
+                              input->buffer_num_recommended) + 3;
+    input->buffer_size = MPMAX(input->buffer_size_min,
+                               input->buffer_size_recommended);
+
+    if (!opaque) {
+        size_t size = layout_buffer(&(struct mp_image){0}, NULL, params);
+        if (input->buffer_size != size) {
+            MP_FATAL(vo, "We disagree with MMAL about buffer sizes.\n");
+            return -1;
+        }
+
+        p->swpool = mmal_pool_create(input->buffer_num, input->buffer_size);
+        if (!p->swpool) {
+            MP_FATAL(vo, "Could not allocate buffer pool.\n");
+            return -1;
+        }
+    }
+
+    resize(vo);
+
+    p->renderer_enabled = true;
+
+    if (mmal_port_enable(p->renderer->control, control_port_cb))
+        return -1;
+
+    if (mmal_port_enable(input, input_port_cb))
+        return -1;
+
+    if (mmal_component_enable(p->renderer)) {
+        MP_FATAL(vo, "Failed to enable video renderer.\n");
+        return -1;
+    }
+
+    return 0;
+}
+
+static struct mp_image *take_screenshot(struct vo *vo)
+{
+    struct priv *p = vo->priv;
+
+    struct mp_image *img = mp_image_alloc(IMGFMT_BGRA, p->w, p->h);
+    if (!img)
+        return NULL;
+
+    DISPMANX_RESOURCE_HANDLE_T resource =
+        vc_dispmanx_resource_create(VC_IMAGE_ARGB8888,
+                                    img->w | ((img->w * 4) << 16), img->h,
+                                    &(int32_t){0});
+    if (!resource)
+        goto fail;
+
+    if (vc_dispmanx_snapshot(p->display, resource, 0))
+        goto fail;
+
+    VC_RECT_T rc = {.width = img->w, .height = img->h};
+    if (vc_dispmanx_resource_read_data(resource, &rc, img->planes[0], img->stride[0]))
+        goto fail;
+
+    vc_dispmanx_resource_delete(resource);
+    return img;
+
+fail:
+    vc_dispmanx_resource_delete(resource);
+    talloc_free(img);
+    return NULL;
+}
+
+static int control(struct vo *vo, uint32_t request, void *data)
+{
+    struct priv *p = vo->priv;
+
+    switch (request) {
+    case VOCTRL_GET_PANSCAN:
+        return VO_TRUE;
+    case VOCTRL_SET_PANSCAN:
+        if (p->renderer_enabled)
+            resize(vo);
+        return VO_TRUE;
+    case VOCTRL_REDRAW_FRAME:
+        update_osd(vo);
+        return VO_TRUE;
+    case VOCTRL_SCREENSHOT_WIN:
+        *(struct mp_image **)data = take_screenshot(vo);
+        return VO_TRUE;
+    }
+
+    return VO_NOTIMPL;
+}
+
+static void uninit(struct vo *vo)
+{
+    struct priv *p = vo->priv;
+
+    talloc_free(p->next_image);
+
+    wipe_osd(vo);
+
+    if (p->update)
+        vc_dispmanx_update_submit_sync(p->update);
+
+    if (p->renderer) {
+        disable_renderer(vo);
+        mmal_component_release(p->renderer);
+    }
+
+    if (p->display)
+        vc_dispmanx_display_close(p->display);
+}
+
+static int preinit(struct vo *vo)
+{
+    struct priv *p = vo->priv;
+
+    p->background_layer = p->layer;
+    p->video_layer = p->layer + 1;
+    p->osd_layer = p->layer + 2;
+
+    bcm_host_init();
+
+    p->display = vc_dispmanx_display_open(p->display_nr);
+    p->update = vc_dispmanx_update_start(0);
+    if (!p->display || !p->update) {
+        MP_FATAL(vo, "Could not get DISPMANX objects.\n");
+        goto fail;
+    }
+
+    if (mmal_component_create(MMAL_COMPONENT_DEFAULT_VIDEO_RENDERER, &p->renderer))
+    {
+        MP_FATAL(vo, "Could not create MMAL renderer.\n");
+        goto fail;
+    }
+
+    if (graphics_get_display_size(0, &p->w, &p->h) < 0) {
+        MP_FATAL(vo, "Could not get display size.\n");
+        goto fail;
+    }
+
+    MP_VERBOSE(vo, "Display size: %dx%d\n", p->w, p->h);
+
+    // Just use the whole screen.
+    VC_RECT_T dst = {.width = p->w, .height = p->h};
+    VC_RECT_T src = {.width = p->w << 16, .height = p->h << 16};
+    VC_DISPMANX_ALPHA_T alpha = {
+        .flags = DISPMANX_FLAGS_ALPHA_FIXED_ALL_PIXELS,
+        .opacity = 0xFF,
+    };
+    p->window = vc_dispmanx_element_add(p->update, p->display, p->background_layer,
+                                        &dst, 0, &src, DISPMANX_PROTECTION_NONE,
+                                        &alpha, 0, 0);
+    if (!p->window) {
+        MP_FATAL(vo, "Could not add DISPMANX element.\n");
+        goto fail;
+    }
+
+    vc_dispmanx_update_submit_sync(p->update);
+    p->update = vc_dispmanx_update_start(10);
+
+    return 0;
+
+fail:
+    uninit(vo);
+    return -1;
+}
+
+#define OPT_BASE_STRUCT struct priv
+static const struct m_option options[] = {
+    OPT_INT("display", display_nr, 0),
+    OPT_INT("layer", layer, 0, OPTDEF_INT(-10)),
+    {0},
+};
+
+const struct vo_driver video_out_rpi = {
+    .description = "Raspberry Pi (MMAL)",
+    .name = "rpi",
+    .preinit = preinit,
+    .query_format = query_format,
+    .reconfig = reconfig,
+    .control = control,
+    .draw_image = draw_image,
+    .flip_page = flip_page,
+    .uninit = uninit,
+    .priv_size = sizeof(struct priv),
+    .options = options,
+};