summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
authorwm4 <wm4@nowhere>2015-03-29 15:12:11 +0200
committerwm4 <wm4@nowhere>2015-03-29 16:09:56 +0200
commit8fff12542279960ff6e0a14f186d5c4c4d2bdfe4 (patch)
treec14e7d25ece5613d91cb507d40872a63825dfc2d
parent38b05daf7d16898f4a63e4ccf48479d8964e6e19 (diff)
downloadmpv-8fff12542279960ff6e0a14f186d5c4c4d2bdfe4.tar.bz2
mpv-8fff12542279960ff6e0a14f186d5c4c4d2bdfe4.tar.xz
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).
-rw-r--r--DOCS/man/options.rst1
-rw-r--r--DOCS/man/vo.rst13
-rwxr-xr-xold-configure3
-rw-r--r--options/options.c7
-rw-r--r--video/decode/lavc.h2
-rw-r--r--video/decode/rpi.c56
-rw-r--r--video/decode/vd_lavc.c9
-rw-r--r--video/fmt-conversion.c3
-rw-r--r--video/hwdec.h1
-rw-r--r--video/img_format.h1
-rw-r--r--video/out/gl_common.c3
-rw-r--r--video/out/gl_common.h1
-rw-r--r--video/out/gl_rpi.c219
-rw-r--r--video/out/vo.c4
-rw-r--r--video/out/vo_rpi.c567
-rw-r--r--wscript44
-rw-r--r--wscript_build.py3
17 files changed, 930 insertions, 7 deletions
diff --git a/DOCS/man/options.rst b/DOCS/man/options.rst
index 763e0c832a..45e312eea7 100644
--- a/DOCS/man/options.rst
+++ b/DOCS/man/options.rst
@@ -555,6 +555,7 @@ Video
:vaapi-copy: copies video back into system RAM (Linux with Intel GPUs only)
:vda: requires ``--vo=opengl`` (OS X only)
:dxva2-copy: copies video back to system RAM (Windows only)
+ :rpi: requires ``--vo=rpi`` (Raspberry Pi only - default if available)
``auto`` tries to automatically enable hardware decoding using the first
available method. This still depends what VO you are using. For example,
diff --git a/DOCS/man/vo.rst b/DOCS/man/vo.rst
index 7ac4cfe367..d0fe3c070a 100644
--- a/DOCS/man/vo.rst
+++ b/DOCS/man/vo.rst
@@ -866,3 +866,16 @@ Available video output drivers are:
``mpv --vo=opengl-cb:help`` for a list.
This also supports the ``vo_cmdline`` command.
+
+``rpi`` (Raspberry Pi)
+ Native video output on the Raspberry Pi using the MMAL API.
+
+ ``display=<number>``
+ Select the display number on which the video overlay should be shown
+ (default: 0).
+
+ ``layer=<number>``
+ Select the dispmanx layer on which the video overlay should be shown
+ (default: -10). Note that mpv will also use the 2 layers above the
+ selected layer, to handle the window background and OSD. Actual video
+ rendering will happen on the layer above the selected layer.
diff --git a/old-configure b/old-configure
index 11c2e3ff90..d4b4f31436 100755
--- a/old-configure
+++ b/old-configure
@@ -932,6 +932,9 @@ cat > $TMPC << EOF
#define HAVE_NETBSD_THREAD_NAME 0
#define HAVE_DXVA2_HWACCEL 0
#define HAVE_FCHMOD 0
+#define HAVE_RPI 0
+#define HAVE_RPI_GLES 0
+#define HAVE_AV_PIX_FMT_MMAL 0
#ifdef __OpenBSD__
#define DEFAULT_CDROM_DEVICE "/dev/rcd0c"
diff --git a/options/options.c b/options/options.c
index 20876c0e4a..80b2c2bc5d 100644
--- a/options/options.c
+++ b/options/options.c
@@ -292,7 +292,8 @@ const m_option_t mp_opts[] = {
{"vda", 2},
{"vaapi", 4},
{"vaapi-copy", 5},
- {"dxva2-copy", 6})),
+ {"dxva2-copy", 6},
+ {"rpi", 7})),
OPT_STRING("hwdec-codecs", hwdec_codecs, 0),
OPT_SUBSTRUCT("sws", vo.sws_opts, sws_conf, 0),
@@ -797,6 +798,10 @@ const struct MPOpts mp_default_opts = {
.mf_fps = 1.0,
+#if HAVE_RPI
+ .hwdec_api = -1,
+#endif
+
.display_tags = (char **)(const char*[]){
"Artist", "Album", "Album_Artist", "Comment", "Composer", "Genre",
"Performer", "Title", "Track", "icy-title",
diff --git a/video/decode/lavc.h b/video/decode/lavc.h
index 85cf49abab..eaddd4abc2 100644
--- a/video/decode/lavc.h
+++ b/video/decode/lavc.h
@@ -52,6 +52,8 @@ struct vd_lavc_hwdec {
// For horrible Intel shit-drivers only
void (*lock)(struct lavc_ctx *ctx);
void (*unlock)(struct lavc_ctx *ctx);
+ // Optional; if a special hardware decoder is needed (instead of "hwaccel").
+ const char *(*get_codec)(struct lavc_ctx *ctx);
};
enum {
diff --git a/video/decode/rpi.c b/video/decode/rpi.c
new file mode 100644
index 0000000000..44a550fe2e
--- /dev/null
+++ b/video/decode/rpi.c
@@ -0,0 +1,56 @@
+/*
+ * 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 "lavc.h"
+#include "common/common.h"
+
+static int init_decoder(struct lavc_ctx *ctx, int fmt, int w, int h)
+{
+ return 0;
+}
+
+static void uninit(struct lavc_ctx *ctx)
+{
+}
+
+static int init(struct lavc_ctx *ctx)
+{
+ return 0;
+}
+
+static int probe(struct vd_lavc_hwdec *hwdec, struct mp_hwdec_info *info,
+ const char *decoder)
+{
+ if (strcmp(decoder, "h264") != 0)
+ return HWDEC_ERR_NO_CODEC;
+ return 0;
+}
+
+static const char *get_codec(struct lavc_ctx *ctx)
+{
+ return "h264_mmal";
+}
+
+const struct vd_lavc_hwdec mp_vd_lavc_rpi = {
+ .type = HWDEC_RPI,
+ .image_format = IMGFMT_MMAL,
+ .probe = probe,
+ .init = init,
+ .uninit = uninit,
+ .init_decoder = init_decoder,
+ .get_codec = get_codec,
+};
diff --git a/video/decode/vd_lavc.c b/video/decode/vd_lavc.c
index eecc130208..b328d24102 100644
--- a/video/decode/vd_lavc.c
+++ b/video/decode/vd_lavc.c
@@ -121,8 +121,12 @@ const struct vd_lavc_hwdec mp_vd_lavc_vda;
const struct vd_lavc_hwdec mp_vd_lavc_vaapi;
const struct vd_lavc_hwdec mp_vd_lavc_vaapi_copy;
const struct vd_lavc_hwdec mp_vd_lavc_dxva2_copy;
+const struct vd_lavc_hwdec mp_vd_lavc_rpi;
static const struct vd_lavc_hwdec *const hwdec_list[] = {
+#if HAVE_RPI
+ &mp_vd_lavc_rpi,
+#endif
#if HAVE_VDPAU_HWACCEL
&mp_vd_lavc_vdpau,
#endif
@@ -303,6 +307,8 @@ static int init(struct dec_video *vd, const char *decoder)
if (hwdec) {
ctx->software_fallback_decoder = talloc_strdup(ctx, decoder);
+ if (hwdec->get_codec)
+ decoder = hwdec->get_codec(ctx);
MP_INFO(vd, "Using hardware decoding.\n");
} else if (vd->opts->hwdec_api != HWDEC_NONE) {
MP_INFO(vd, "Using software decoding.\n");
@@ -370,7 +376,8 @@ static void init_avctx(struct dec_video *vd, const char *decoder,
if (ctx->hwdec) {
avctx->thread_count = 1;
avctx->get_format = get_format_hwdec;
- avctx->get_buffer2 = get_buffer2_hwdec;
+ if (ctx->hwdec->allocate_image)
+ avctx->get_buffer2 = get_buffer2_hwdec;
if (ctx->hwdec->init(ctx) < 0)
goto error;
} else {
diff --git a/video/fmt-conversion.c b/video/fmt-conversion.c
index 9ed9777736..2288512011 100644
--- a/video/fmt-conversion.c
+++ b/video/fmt-conversion.c
@@ -124,6 +124,9 @@ static const struct {
#endif
{IMGFMT_VAAPI, AV_PIX_FMT_VAAPI_VLD},
{IMGFMT_DXVA2, AV_PIX_FMT_DXVA2_VLD},
+#if HAVE_AV_PIX_FMT_MMAL
+ {IMGFMT_MMAL, AV_PIX_FMT_MMAL},
+#endif
{0, AV_PIX_FMT_NONE}
};
diff --git a/video/hwdec.h b/video/hwdec.h
index 0574e5c562..b04b7c519b 100644
--- a/video/hwdec.h
+++ b/video/hwdec.h
@@ -12,6 +12,7 @@ enum hwdec_type {
HWDEC_VAAPI = 4,
HWDEC_VAAPI_COPY = 5,
HWDEC_DXVA2_COPY = 6,
+ HWDEC_RPI = 7,
};
struct mp_hwdec_ctx {
diff --git a/video/img_format.h b/video/img_format.h
index e734185045..c6c2886909 100644
--- a/video/img_format.h
+++ b/video/img_format.h
@@ -206,6 +206,7 @@ enum mp_imgfmt {
IMGFMT_VDA,
IMGFMT_VAAPI,
IMGFMT_DXVA2, // IDirect3DSurface9 (NV12)
+ IMGFMT_MMAL, // MMAL_BUFFER_HEADER_T
// Generic pass-through of AV_PIX_FMT_*. Used for formats which don't have
// a corresponding IMGFMT_ value.
diff --git a/video/out/gl_common.c b/video/out/gl_common.c
index 1470227b5c..7e8ed7ce39 100644
--- a/video/out/gl_common.c
+++ b/video/out/gl_common.c
@@ -529,6 +529,9 @@ struct backend {
};
static const struct backend backends[] = {
+#if HAVE_RPI_GLES
+ {"rpi", mpgl_set_backend_rpi},
+#endif
#if HAVE_GL_COCOA
{"cocoa", mpgl_set_backend_cocoa},
#endif
diff --git a/video/out/gl_common.h b/video/out/gl_common.h
index 1d33682f3e..2e25d331c7 100644
--- a/video/out/gl_common.h
+++ b/video/out/gl_common.h
@@ -137,6 +137,7 @@ void mpgl_set_backend_x11es(MPGLContext *ctx);
void mpgl_set_backend_x11egl(MPGLContext *ctx);
void mpgl_set_backend_x11egles(MPGLContext *ctx);
void mpgl_set_backend_wayland(MPGLContext *ctx);
+void mpgl_set_backend_rpi(MPGLContext *ctx);
void mpgl_load_functions(GL *gl, void *(*getProcAddress)(const GLubyte *),
const char *ext2, struct mp_log *log);
diff --git a/video/out/gl_rpi.c b/video/out/gl_rpi.c
new file mode 100644
index 0000000000..f82046e899
--- /dev/null
+++ b/video/out/gl_rpi.c
@@ -0,0 +1,219 @@
+/*
+ * 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/>.
+ *
+ * You can alternatively redistribute this file and/or
+ * modify it 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.
+ */
+
+#include <stddef.h>
+#include <assert.h>
+
+#include <bcm_host.h>
+#include <EGL/egl.h>
+#include <EGL/eglext.h>
+
+#include "common/common.h"
+#include "x11_common.h"
+#include "gl_common.h"
+
+struct priv {
+ EGLDisplay egl_display;
+ EGLContext egl_context;
+ EGLSurface egl_surface;
+ DISPMANX_DISPLAY_HANDLE_T display;
+ DISPMANX_ELEMENT_HANDLE_T window;
+ DISPMANX_UPDATE_HANDLE_T update;
+ // yep, the API keeps a pointer to it
+ EGL_DISPMANX_WINDOW_T egl_window;
+ int w, h;
+};
+
+static void *get_proc_address(const GLubyte *name)
+{
+ void *p = eglGetProcAddress(name);
+ // It looks like eglGetProcAddress() should work even for builtin
+ // functions, but it doesn't work at least with RPI/Broadcom crap.
+ // (EGL 1.4, which current RPI firmware pretends to support, definitely
+ // is required to return non-extension functions.)
+ if (!p) {
+ void *h = dlopen("/opt/vc/lib/libGLESv2.so", RTLD_LAZY);
+ if (h) {
+ p = dlsym(h, name);
+ dlclose(h);
+ }
+ }
+ return p;
+}
+
+static EGLConfig select_fb_config_egl(struct MPGLContext *ctx)
+{
+ struct priv *p = ctx->priv;
+
+ EGLint attributes[] = {
+ EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
+ EGL_RED_SIZE, 8,
+ EGL_GREEN_SIZE, 8,
+ EGL_BLUE_SIZE, 8,
+ EGL_DEPTH_SIZE, 0,
+ EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
+ EGL_NONE
+ };
+
+ EGLint config_count;
+ EGLConfig config;
+
+ eglChooseConfig(p->egl_display, attributes, &config, 1, &config_count);
+
+ if (!config_count) {
+ MP_FATAL(ctx->vo, "Could find EGL configuration!\n");
+ return NULL;
+ }
+
+ return config;
+}
+
+static bool sc_config_window(struct MPGLContext *ctx, int flags)
+{
+ struct priv *p = ctx->priv;
+ struct vo *vo = ctx->vo;
+
+ if (p->egl_context) {
+ vo->dwidth = p->w;
+ vo->dheight = p->h;
+ return true;
+ }
+
+ bcm_host_init();
+
+ p->display = vc_dispmanx_display_open(0);
+ p->update = vc_dispmanx_update_start(0);
+ if (!p->display || !p->update) {
+ MP_FATAL(ctx->vo, "Could not get DISPMANX objects.\n");
+ return false;
+ }
+
+ uint32_t w, h;
+ if (graphics_get_display_size(0, &w, &h) < 0) {
+ MP_FATAL(ctx->vo, "Could not get display size.\n");
+ return false;
+ }
+
+ // dispmanx is like a neanderthal version of Wayland - you can add an
+ // overlay any place on the screen. Just use the whole screen.
+ VC_RECT_T dst = {.width = w, .height = h};
+ VC_RECT_T src = {.width = w << 16, .height = 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, 1, &dst, 0,
+ &src, DISPMANX_PROTECTION_NONE, &alpha, 0, 0);
+ if (!p->window) {
+ MP_FATAL(ctx->vo, "Could not add DISPMANX element.\n");
+ return false;
+ }
+
+ vc_dispmanx_update_submit_sync(p->update);
+
+ p->egl_display = eglGetDisplay(EGL_DEFAULT_DISPLAY);
+ if (!eglInitialize(p->egl_display, NULL, NULL)) {
+ MP_FATAL(ctx->vo, "EGL failed to initialize.\n");
+ return false;
+ }
+
+ eglBindAPI(EGL_OPENGL_ES_API);
+
+ EGLConfig config = select_fb_config_egl(ctx);
+ if (!config)
+ return false;
+
+ p->egl_window = (EGL_DISPMANX_WINDOW_T){.element = p->window, .width = w, .height = h};
+ p->egl_surface = eglCreateWindowSurface(p->egl_display, config, &p->egl_window, NULL);
+
+ if (p->egl_surface == EGL_NO_SURFACE) {
+ MP_FATAL(ctx->vo, "Could not create EGL surface!\n");
+ return false;
+ }
+
+ EGLint context_attributes[] = {
+ EGL_CONTEXT_CLIENT_VERSION, 2,
+ EGL_NONE
+ };
+ p->egl_context = eglCreateContext(p->egl_display, config,
+ EGL_NO_CONTEXT, context_attributes);
+
+ if (p->egl_context == EGL_NO_CONTEXT) {
+ MP_FATAL(ctx->vo, "Could not create EGL context!\n");
+ return false;
+ }
+
+ eglMakeCurrent(p->egl_display, p->egl_surface, p->egl_surface,
+ p->egl_context);
+
+ const char *exts = eglQueryString(p->egl_display, EGL_EXTENSIONS);
+ mpgl_load_functions(ctx->gl, get_proc_address, exts, vo->log);
+
+ vo->dwidth = p->w = w;
+ vo->dheight = p->h = h;
+
+ return true;
+}
+
+static void sc_releaseGlContext(MPGLContext *ctx)
+{
+ struct priv *p = ctx->priv;
+ if (p->egl_context) {
+ eglMakeCurrent(p->egl_display, EGL_NO_SURFACE, EGL_NO_SURFACE,
+ EGL_NO_CONTEXT);
+ eglDestroyContext(p->egl_display, p->egl_context);
+ }
+ p->egl_context = EGL_NO_CONTEXT;
+ eglTerminate(p->egl_display);
+ vc_dispmanx_display_close(p->display);
+}
+
+static void sc_swapGlBuffers(MPGLContext *ctx)
+{
+ struct priv *p = ctx->priv;
+ eglSwapBuffers(p->egl_display, p->egl_surface);
+}
+
+static int sc_vo_init(struct vo *vo)
+{
+ return 1;
+}
+
+static void sc_vo_uninit(struct vo *vo)
+{
+}
+
+static int sc_vo_control(struct vo *vo, int *events, int request, void *arg)
+{
+ return VO_NOTIMPL;
+}
+
+void mpgl_set_backend_rpi(MPGLContext *ctx)
+{
+ ctx->priv = talloc_zero(ctx, struct priv);
+ ctx->config_window = sc_config_window;
+ ctx->releaseGlContext = sc_releaseGlContext;
+ ctx->swapGlBuffers = sc_swapGlBuffers;
+ ctx->vo_init = sc_vo_init;
+ ctx->vo_uninit = sc_vo_uninit;
+ ctx->vo_control = sc_vo_control;
+}
diff --git a/video/out/vo.c b/video/out/vo.c
index a99e9f69f4..e9b1cbfc1d 100644
--- a/video/out/vo.c
+++ b/video/out/vo.c
@@ -63,9 +63,13 @@ extern const struct vo_driver video_out_direct3d_shaders;
extern const struct vo_driver video_out_sdl;
extern const struct vo_driver video_out_vaapi;
extern const struct vo_driver video_out_wayland;
+extern const struct vo_driver video_out_rpi;
const struct vo_driver *const video_out_drivers[] =
{
+#if HAVE_RPI
+ &video_out_rpi,
+#endif
#if HAVE_GL
&video_out_opengl,
#endif
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);</