diff --git a/meta-raspberrypi/dynamic-layers/multimedia-layer/recipes-multimedia/rpidistro-vlc/files/0001-configure-fix-linking-on-RISC-V-ISA.patch b/meta-raspberrypi/dynamic-layers/multimedia-layer/recipes-multimedia/rpidistro-vlc/files/0001-configure-fix-linking-on-RISC-V-ISA.patch
index ac96efa..3be8f1e 100644
--- a/meta-raspberrypi/dynamic-layers/multimedia-layer/recipes-multimedia/rpidistro-vlc/files/0001-configure-fix-linking-on-RISC-V-ISA.patch
+++ b/meta-raspberrypi/dynamic-layers/multimedia-layer/recipes-multimedia/rpidistro-vlc/files/0001-configure-fix-linking-on-RISC-V-ISA.patch
@@ -2,11 +2,17 @@
 Date: Sat, 16 Jun 2018 21:31:45 +0300
 Subject: configure: fix linking on RISC-V ISA
 
-Upstream-status: Pending
+Upstream-Status: Inappropriate
+
+RPI-Distro repo forks original vlc and applies patches
+to enable raspiberry pi support.
+
 ---
  configure.ac | 1 +
  1 file changed, 1 insertion(+)
 
+diff --git a/configure.ac b/configure.ac
+index 2037a9e..df26367 100644
 --- a/configure.ac
 +++ b/configure.ac
 @@ -113,6 +113,7 @@ case "${host_os}" in
diff --git a/meta-raspberrypi/dynamic-layers/multimedia-layer/recipes-multimedia/rpidistro-vlc/files/0002-Revert-configure-Require-libmodplug-0.8.9.patch b/meta-raspberrypi/dynamic-layers/multimedia-layer/recipes-multimedia/rpidistro-vlc/files/0002-Revert-configure-Require-libmodplug-0.8.9.patch
index 3dfcf85..61807b3 100644
--- a/meta-raspberrypi/dynamic-layers/multimedia-layer/recipes-multimedia/rpidistro-vlc/files/0002-Revert-configure-Require-libmodplug-0.8.9.patch
+++ b/meta-raspberrypi/dynamic-layers/multimedia-layer/recipes-multimedia/rpidistro-vlc/files/0002-Revert-configure-Require-libmodplug-0.8.9.patch
@@ -2,13 +2,18 @@
 Date: Mon, 19 Aug 2019 21:08:26 +0200
 Subject: Revert "configure: Require libmodplug >= 0.8.9"
 
-This reverts commit 48f014768dc22ecad23d0e9f53c38805a3aff832.
+Upstream-Status: Inappropriate
 
-Upstream-status: Pending
+RPI-Distro repo forks original vlc and applies patches
+to enable raspiberry pi support.
+
+This reverts commit 48f014768dc22ecad23d0e9f53c38805a3aff832.
 ---
  configure.ac | 2 +-
  1 file changed, 1 insertion(+), 1 deletion(-)
 
+diff --git a/configure.ac b/configure.ac
+index df26367..b8580ec 100644
 --- a/configure.ac
 +++ b/configure.ac
 @@ -2207,7 +2207,7 @@ AC_ARG_ENABLE(mod,
diff --git a/meta-raspberrypi/dynamic-layers/multimedia-layer/recipes-multimedia/rpidistro-vlc/files/0003-CVE-2022-41325.patch b/meta-raspberrypi/dynamic-layers/multimedia-layer/recipes-multimedia/rpidistro-vlc/files/0003-CVE-2022-41325.patch
new file mode 100644
index 0000000..41f7109
--- /dev/null
+++ b/meta-raspberrypi/dynamic-layers/multimedia-layer/recipes-multimedia/rpidistro-vlc/files/0003-CVE-2022-41325.patch
@@ -0,0 +1,83 @@
+From 4fcace61801f418786c42487c6b06b693ee87666 Mon Sep 17 00:00:00 2001
+From: Romain Vimont <rom1v@videolabs.io>
+Date: Mon, 19 Sep 2022 17:17:01 +0200
+Subject: [PATCH] vnc: fix possible buffer overflow
+
+Upstream-Status: Inappropriate
+
+RPI-Distro repo forks original vlc and applies patches
+to enable raspiberry pi support.
+
+Thanks to 0xMitsurugi [1] from Synacktiv [2] for the bug report and fix.
+
+[1] https://twitter.com/0xMitsurugi
+[2] https://www.synacktiv.com/
+
+Fixes #27335
+
+(cherry picked from commit 5eb783fd44ed6298db3e38f7765f21c42e4405f9)
+---
+ modules/access/vnc.c | 23 ++++++++++++++++-------
+ 1 file changed, 16 insertions(+), 7 deletions(-)
+
+--- a/modules/access/vnc.c
++++ b/modules/access/vnc.c
+@@ -33,6 +33,7 @@
+ #ifdef HAVE_CONFIG_H
+ # include "config.h"
+ #endif
++#include <assert.h>
+ 
+ #include <vlc_common.h>
+ #include <vlc_plugin.h>
+@@ -115,7 +116,7 @@
+     int i_cancel_state;
+ 
+     rfbClient* p_client;
+-    int i_framebuffersize;
++    size_t i_framebuffersize;
+     block_t *p_block;
+ 
+     float f_fps;
+@@ -143,11 +144,16 @@
+         p_sys->es = NULL;
+     }
+ 
+-    int i_width = p_client->width;
+-    int i_height = p_client->height;
+-    int i_depth = p_client->format.bitsPerPixel;
++    assert(!(p_client->width & ~0xffff)); // fits in 16 bits
++    uint16_t i_width = p_client->width;
+ 
+-    switch( i_depth )
++    assert(!(p_client->height & ~0xffff)); // fits in 16 bits
++    uint16_t i_height = p_client->height;
++
++    uint8_t i_bits_per_pixel = p_client->format.bitsPerPixel;
++    assert((i_bits_per_pixel & 0x7) == 0); // multiple of 8
++
++    switch( i_bits_per_pixel )
+     {
+         case 8:
+             i_chroma = VLC_CODEC_RGB8;
+@@ -180,7 +186,10 @@
+     }
+ 
+     /* Set up framebuffer */
+-    p_sys->i_framebuffersize = i_width * i_height * i_depth / 8;
++    if (mul_overflow(i_width, i_height * (i_bits_per_pixel / 8), &p_sys->i_framebuffersize)) {
++        msg_Err(p_demux, "VNC framebuffersize overflow");
++        return FALSE;
++    }
+ 
+     /* Reuse unsent block */
+     if ( p_sys->p_block )
+@@ -211,7 +220,7 @@
+     fmt.video.i_frame_rate_base = 1000;
+     fmt.video.i_frame_rate = 1000 * p_sys->f_fps;
+ 
+-    fmt.video.i_bits_per_pixel = i_depth;
++    fmt.video.i_bits_per_pixel = i_bits_per_pixel;
+     fmt.video.i_rmask = p_client->format.redMax << p_client->format.redShift;
+     fmt.video.i_gmask = p_client->format.greenMax << p_client->format.greenShift;
+     fmt.video.i_bmask = p_client->format.blueMax << p_client->format.blueShift;
diff --git a/meta-raspberrypi/dynamic-layers/multimedia-layer/recipes-multimedia/rpidistro-vlc/files/0003-mmal_20.patch b/meta-raspberrypi/dynamic-layers/multimedia-layer/recipes-multimedia/rpidistro-vlc/files/0004-mmal_20.patch
similarity index 99%
rename from meta-raspberrypi/dynamic-layers/multimedia-layer/recipes-multimedia/rpidistro-vlc/files/0003-mmal_20.patch
rename to meta-raspberrypi/dynamic-layers/multimedia-layer/recipes-multimedia/rpidistro-vlc/files/0004-mmal_20.patch
index 6038d0e..ab31730 100644
--- a/meta-raspberrypi/dynamic-layers/multimedia-layer/recipes-multimedia/rpidistro-vlc/files/0003-mmal_20.patch
+++ b/meta-raspberrypi/dynamic-layers/multimedia-layer/recipes-multimedia/rpidistro-vlc/files/0004-mmal_20.patch
@@ -1,4 +1,7 @@
-Upstream-status: Pending
+Upstream-Status: Inappropriate
+
+RPI-Distro repo forks original vlc and applies patches
+to enable raspiberry pi support.
 
 --- a/configure.ac
 +++ b/configure.ac
@@ -26,13 +29,13 @@
  fi
  AM_CONDITIONAL([HAVE_MMAL], [test "${have_mmal}" = "yes"])
 +AM_CONDITIONAL([HAVE_MMAL_AVCODEC], [test "${enable_mmal_avcodec}" = "yes"])
-
+ 
  dnl
  dnl evas plugin
 --- a/include/vlc_fourcc.h
 +++ b/include/vlc_fourcc.h
 @@ -365,6 +365,11 @@
-
+ 
  /* Broadcom MMAL opaque buffer type */
  #define VLC_CODEC_MMAL_OPAQUE     VLC_FOURCC('M','M','A','L')
 +#define VLC_CODEC_MMAL_ZC_SAND8   VLC_FOURCC('Z','S','D','8')
@@ -40,7 +43,7 @@
 +#define VLC_CODEC_MMAL_ZC_SAND30  VLC_FOURCC('Z','S','D','3')
 +#define VLC_CODEC_MMAL_ZC_I420    VLC_FOURCC('Z','4','2','0')
 +#define VLC_CODEC_MMAL_ZC_RGB32   VLC_FOURCC('Z','R','G','B')
-
+ 
  /* DXVA2 opaque video surface for use with D3D9 */
  #define VLC_CODEC_D3D9_OPAQUE     VLC_FOURCC('D','X','A','9') /* 4:2:0  8 bpc */
 --- a/modules/hw/mmal/Makefile.am
@@ -48,12 +51,12 @@
 @@ -1,23 +1,57 @@
  include $(top_srcdir)/modules/common.am
  mmaldir = $(pluginsdir)/mmal
-
+ 
 -AM_CFLAGS += $(CFLAGS_mmal)
 -AM_LDFLAGS += -rpath '$(mmaldir)' $(LDFLAGS_mmal)
 +AM_CFLAGS += -pthread $(CFLAGS_mmal)
 +AM_LDFLAGS += -pthread -rpath '$(mmaldir)' $(LDFLAGS_mmal)
-
+ 
 -libmmal_vout_plugin_la_SOURCES = vout.c mmal_picture.c mmal_picture.h
 +libmmal_vout_plugin_la_SOURCES = vout.c mmal_cma.c mmal_picture.c subpic.c\
 +  mmal_cma.h mmal_picture.h subpic.h transform_ops.h\
@@ -63,7 +66,7 @@
 +libmmal_vout_plugin_la_LDFLAGS = $(AM_LDFLAGS) -lm -lX11 -lXrandr
  libmmal_vout_plugin_la_LIBADD = $(LIBS_mmal)
  mmal_LTLIBRARIES = libmmal_vout_plugin.la
-
+ 
 -libmmal_codec_plugin_la_SOURCES = codec.c
 +libmmal_codec_plugin_la_SOURCES = codec.c mmal_cma.c mmal_picture.c subpic.c\
 +  mmal_cma.h mmal_picture.h subpic.h transform_ops.h\
@@ -72,7 +75,7 @@
  libmmal_codec_plugin_la_LDFLAGS = $(AM_LDFLAGS)
  libmmal_codec_plugin_la_LIBADD = $(LIBS_mmal)
  mmal_LTLIBRARIES += libmmal_codec_plugin.la
-
+ 
 -libmmal_deinterlace_plugin_la_SOURCES = deinterlace.c mmal_picture.c
 +libmmal_deinterlace_plugin_la_SOURCES = deinterlace.c mmal_picture.c mmal_cma.c\
 +  mmal_cma.h mmal_picture.h transform_ops.h\
@@ -517,7 +520,7 @@
 @@ -26,267 +26,443 @@
  #include "config.h"
  #endif
-
+ 
 +#include <stdatomic.h>
 +
  #include <vlc_common.h>
@@ -526,17 +529,17 @@
  #include <vlc_codec.h>
 +#include <vlc_filter.h>
  #include <vlc_threads.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 <interface/vcsm/user-vcsm.h>
 +
 +#include "mmal_cma.h"
  #include "mmal_picture.h"
-
+ 
 +#include "subpic.h"
 +#include "blend_rgba_neon.h"
 +
@@ -550,18 +553,18 @@
  #define NUM_EXTRA_BUFFERS 5
 +//#define NUM_EXTRA_BUFFERS 10
  #define NUM_DECODER_BUFFER_HEADERS 30
-
+ 
 -#define MIN_NUM_BUFFERS_IN_TRANSIT 2
 +#define CONVERTER_BUFFERS 4  // Buffers on the output of the converter
 +
 +#define MMAL_SLICE_HEIGHT 16
 +#define MMAL_ALIGN_W      32
 +#define MMAL_ALIGN_H      16
-
+ 
  #define MMAL_OPAQUE_NAME "mmal-opaque"
  #define MMAL_OPAQUE_TEXT N_("Decode frames directly into RPI VideoCore instead of host memory.")
  #define MMAL_OPAQUE_LONGTEXT N_("Decode frames directly into RPI VideoCore instead of host memory. This option must only be used with the MMAL video output plugin.")
-
+ 
 -static int OpenDecoder(decoder_t *dec);
 -static void CloseDecoder(decoder_t *dec);
 -
@@ -580,7 +583,7 @@
 +#define MMAL_ISP_NAME "mmal-isp"
 +#define MMAL_ISP_TEXT N_("Use mmal isp rather than hvs.")
 +#define MMAL_ISP_LONGTEXT N_("Use mmal isp rather than hvs. This may be faster but has no blend.")
-
+ 
 -struct decoder_sys_t {
 -    bool opaque;
 +typedef struct decoder_sys_t
@@ -593,11 +596,11 @@
 +    hw_mmal_port_pool_ref_t *ppr;
      MMAL_ES_FORMAT_T *output_format;
 -    vlc_sem_t sem;
-
+ 
 +    MMAL_STATUS_T err_stream;
      bool b_top_field_first;
      bool b_progressive;
-
+ 
 +    bool b_flushed;
 +
 +    vcsm_init_type_t vcsm_init_type;
@@ -613,7 +616,7 @@
      atomic_bool started;
 -};
 +} decoder_sys_t;
-
+ 
 -/* Utilities */
 -static int change_output_format(decoder_t *dec);
 -static int send_output_buffer(decoder_t *dec);
@@ -627,7 +630,7 @@
 -static void control_port_cb(MMAL_PORT_T *port, MMAL_BUFFER_HEADER_T *buffer);
 -static void input_port_cb(MMAL_PORT_T *port, MMAL_BUFFER_HEADER_T *buffer);
 -static void output_port_cb(MMAL_PORT_T *port, MMAL_BUFFER_HEADER_T *buffer);
-
+ 
 -static int OpenDecoder(decoder_t *dec)
 -{
 -    int ret = VLC_SUCCESS;
@@ -647,12 +650,12 @@
 +    {{MMAL_PARAMETER_SUPPORTED_ENCODINGS, sizeof(((supported_mmal_enc_t *)0)->supported)}, {0}}, \
 +    -1 \
 +}
-
+ 
 -    if (dec->fmt_in.i_codec != VLC_CODEC_MPGV &&
 -            dec->fmt_in.i_codec != VLC_CODEC_H264)
 -        return VLC_EGENERIC;
 +static supported_mmal_enc_t supported_decode_in_enc = SUPPORTED_MMAL_ENC_INIT;
-
+ 
 -    sys = calloc(1, sizeof(decoder_sys_t));
 -    if (!sys) {
 -        ret = VLC_ENOMEM;
@@ -672,7 +675,7 @@
 -    dec->p_sys = sys;
 +    return false;
 +}
-
+ 
 -    sys->opaque = var_InheritBool(dec, MMAL_OPAQUE_NAME);
 -    bcm_host_init();
 +static bool set_and_test_enc_supported(supported_mmal_enc_t * const support, MMAL_PORT_T * port, const MMAL_FOURCC_T fcc)
@@ -684,7 +687,7 @@
 +    else
 +        support->n = (support->supported.header.size - sizeof(support->supported.header)) /
 +          sizeof(support->supported.encodings[0]);
-
+ 
 -    status = mmal_component_create(MMAL_COMPONENT_DEFAULT_VIDEO_DECODER, &sys->component);
 -    if (status != MMAL_SUCCESS) {
 -        msg_Err(dec, "Failed to create MMAL component %s (status=%"PRIx32" %s)",
@@ -694,7 +697,7 @@
 -    }
 +    return is_enc_supported(support, fcc);
 +}
-
+ 
 -    sys->component->control->userdata = (struct MMAL_PORT_USERDATA_T *)dec;
 -    status = mmal_port_enable(sys->component->control, control_port_cb);
 -    if (status != MMAL_SUCCESS) {
@@ -737,7 +740,7 @@
      }
 +    return 0;
 +}
-
+ 
 -    sys->input = sys->component->input[0];
 -    sys->input->userdata = (struct MMAL_PORT_USERDATA_T *)dec;
 -    if (dec->fmt_in.i_codec == VLC_CODEC_MPGV)
@@ -776,7 +779,7 @@
 +    }
 +    return 0;
 +}
-
+ 
 -    if (dec->fmt_in.i_codec == VLC_CODEC_H264) {
 -        if (dec->fmt_in.i_extra > 0) {
 -            status = mmal_format_extradata_alloc(sys->input->format,
@@ -804,7 +807,7 @@
      }
 +}
 +#endif
-
+ 
 -    status = mmal_port_format_commit(sys->input);
 -    if (status != MMAL_SUCCESS) {
 -        msg_Err(dec, "Failed to commit format for input port %s (status=%"PRIx32" %s)",
@@ -822,7 +825,7 @@
 -    sys->input->buffer_size = sys->input->buffer_size_recommended;
 -    sys->input->buffer_num = sys->input->buffer_num_recommended;
 +}
-
+ 
 -    status = mmal_port_enable(sys->input, input_port_cb);
 -    if (status != MMAL_SUCCESS) {
 -        msg_Err(dec, "Failed to enable input port %s (status=%"PRIx32" %s)",
@@ -830,7 +833,7 @@
 -        ret = VLC_EGENERIC;
 -        goto out;
 -    }
-
+ 
 -    sys->output = sys->component->output[0];
 -    sys->output->userdata = (struct MMAL_PORT_USERDATA_T *)dec;
 +static void draw_corners(void * pic_buf, size_t pic_stride, unsigned int x, unsigned int y, unsigned int w, unsigned int h)
@@ -846,7 +849,7 @@
 +    draw_line(pic_buf, pic_stride, x, y + h - 1, len, -(int)pic_stride);
 +}
 +#endif
-
+ 
 -    if (sys->opaque) {
 -        extra_buffers.hdr.id = MMAL_PARAMETER_EXTRA_BUFFERS;
 -        extra_buffers.hdr.size = sizeof(MMAL_PARAMETER_UINT32_T);
@@ -863,7 +866,7 @@
 +{
 +    static const unsigned int primes[] = {2, 3, 5, 7, 11, 13, 17, 19, 23, 0};
 +    const unsigned int * p = primes;
-
+ 
 -        msg_Dbg(dec, "Activate zero-copy for output port");
 -        MMAL_PARAMETER_BOOLEAN_T zero_copy = {
 -            { MMAL_PARAMETER_ZERO_COPY, sizeof(MMAL_PARAMETER_BOOLEAN_T) },
@@ -873,7 +876,7 @@
 +    if (num == 0 || den == 0) {
 +        return (MMAL_RATIONAL_T){.num = 0, .den = 0};
 +    }
-
+ 
 -        status = mmal_port_parameter_set(sys->output, &zero_copy.hdr);
 -        if (status != MMAL_SUCCESS) {
 -           msg_Err(dec, "Failed to set zero copy on port %s (status=%"PRIx32" %s)",
@@ -889,7 +892,7 @@
      }
 +    return (MMAL_RATIONAL_T){.num = num, .den = den};
 +}
-
+ 
 -    status = mmal_port_enable(sys->output, output_port_cb);
 -    if (status != MMAL_SUCCESS) {
 -        msg_Err(dec, "Failed to enable output port %s (status=%"PRIx32" %s)",
@@ -901,7 +904,7 @@
 +static picture_t * alloc_opaque_pic(decoder_t * const dec, MMAL_BUFFER_HEADER_T * const buf)
 +{
 +    decoder_sys_t *const dec_sys = dec->p_sys;
-
+ 
 -    status = mmal_component_enable(sys->component);
 -    if (status != MMAL_SUCCESS) {
 -        msg_Err(dec, "Failed to enable component %s (status=%"PRIx32" %s)",
@@ -919,11 +922,11 @@
 +        msg_Err(dec, "%s: Empty buffer", __func__);
 +        goto fail2;
      }
-
+ 
 -    sys->input_pool = mmal_pool_create(sys->input->buffer_num, 0);
 +    if ((pic->context = hw_mmal_gen_context(buf, dec_sys->ppr)) == NULL)
 +        goto fail2;
-
+ 
 -    if (sys->opaque) {
 -        dec->fmt_out.i_codec = VLC_CODEC_MMAL_OPAQUE;
 -        dec->fmt_out.video.i_chroma = VLC_CODEC_MMAL_OPAQUE;
@@ -961,22 +964,22 @@
 +        msg_Err(dec, "MMAL error %"PRIx32" \"%s\"", status,
 +                mmal_status_to_string(status));
      }
-
+ 
 -    dec->pf_decode = decode;
 -    dec->pf_flush  = flush_decoder;
 +    mmal_buffer_header_release(buffer);
 +}
-
+ 
 -    vlc_sem_init(&sys->sem, 0);
 +static void input_port_cb(MMAL_PORT_T *port, MMAL_BUFFER_HEADER_T *buffer)
 +{
 +    block_t * const block = (block_t *)buffer->user_data;
-
+ 
 -out:
 -    if (ret != VLC_SUCCESS)
 -        CloseDecoder(dec);
 +    (void)port;  // Unused
-
+ 
 -    return ret;
 +#if TRACE_ALL
 +    msg_Dbg((decoder_t *)port->userdata, "<<< %s: cmd=%d, data=%p, len=%d/%d, pts=%lld", __func__,
@@ -989,14 +992,14 @@
 +    if (block != NULL)
 +        block_Release(block);
  }
-
+ 
 -static void CloseDecoder(decoder_t *dec)
 +static void decoder_output_cb(MMAL_PORT_T *port, MMAL_BUFFER_HEADER_T *buffer)
  {
 -    decoder_sys_t *sys = dec->p_sys;
 -    MMAL_BUFFER_HEADER_T *buffer;
 +    decoder_t * const dec = (decoder_t *)port->userdata;
-
+ 
 -    if (!sys)
 +    if (buffer->cmd == 0 && buffer->length != 0)
 +    {
@@ -1016,7 +1019,7 @@
 +        // Buffer released or attached to pic - do not release again
          return;
 +    }
-
+ 
 -    if (sys->component && sys->component->control->is_enabled)
 -        mmal_port_disable(sys->component->control);
 +    if (buffer->cmd == MMAL_EVENT_FORMAT_CHANGED)
@@ -1024,7 +1027,7 @@
 +        decoder_sys_t * const sys = dec->p_sys;
 +        MMAL_EVENT_FORMAT_CHANGED_T * const fmt = mmal_event_format_changed_get(buffer);
 +        MMAL_ES_FORMAT_T * const format = mmal_format_alloc();
-
+ 
 -    if (sys->input && sys->input->is_enabled)
 -        mmal_port_disable(sys->input);
 +        if (format == NULL)
@@ -1033,7 +1036,7 @@
 +        {
 +            mmal_format_full_copy(format, fmt->format);
 +            format->encoding = MMAL_ENCODING_OPAQUE;
-
+ 
 -    if (sys->output && sys->output->is_enabled)
 -        mmal_port_disable(sys->output);
 +            // If no PAR in the stream - see if we've got one from the demux
@@ -1057,17 +1060,17 @@
 +                        d = 1;
 +                    }
 +                }
-
+ 
 -    if (sys->component && sys->component->is_enabled)
 -        mmal_component_disable(sys->component);
 +                format->es->video.par = rationalize_sar(n, d);
 +            }
-
+ 
 -    if (sys->input_pool)
 -        mmal_pool_destroy(sys->input_pool);
 +            if (sys->output_format != NULL)
 +                mmal_format_free(sys->output_format);
-
+ 
 -    if (sys->output_format)
 -        mmal_format_free(sys->output_format);
 +            sys->output_format = format;
@@ -1077,7 +1080,7 @@
 +        char buf0[5];
 +        msg_Warn(dec, "Unexpected output cb event: %s", str_fourcc(buf0, buffer->cmd));
 +    }
-
+ 
 -    if (sys->output_pool)
 -        mmal_pool_destroy(sys->output_pool);
 +    // If we get here then we were flushing (cmd == 0 && len == 0) or
@@ -1087,13 +1090,13 @@
 +    buffer->user_data = NULL;
 +    mmal_buffer_header_release(buffer);
 +}
-
+ 
 -    if (sys->component)
 -        mmal_component_release(sys->component);
-
+ 
 -    vlc_sem_destroy(&sys->sem);
 -    free(sys);
-
+ 
 -    bcm_host_deinit();
 +static void fill_output_port(decoder_t *dec)
 +{
@@ -1113,7 +1116,7 @@
 +    hw_mmal_port_pool_ref_fill(sys->ppr);
 +    return;
  }
-
+ 
  static int change_output_format(decoder_t *dec)
  {
      MMAL_PARAMETER_VIDEO_INTERLACE_TYPE_T interlace_type;
@@ -1122,7 +1125,7 @@
      MMAL_STATUS_T status;
 -    int pool_size;
      int ret = 0;
-
+ 
 +#if TRACE_ALL
 +    msg_Dbg(dec, "%s: <<<", __func__);
 +#endif
@@ -1132,7 +1135,7 @@
          status = mmal_port_format_commit(sys->output);
 @@ -300,7 +476,9 @@ static int change_output_format(decoder_
      }
-
+ 
  port_reset:
 +#if TRACE_ALL
      msg_Dbg(dec, "%s: Do full port reset", __func__);
@@ -1142,7 +1145,7 @@
          msg_Err(dec, "Failed to disable output port (status=%"PRIx32" %s)",
 @@ -310,6 +488,7 @@ port_reset:
      }
-
+ 
      mmal_format_full_copy(sys->output->format, sys->output_format);
 +
      status = mmal_port_format_commit(sys->output);
@@ -1151,7 +1154,7 @@
 @@ -318,18 +497,10 @@ port_reset:
          goto out;
      }
-
+ 
 -    if (sys->opaque) {
 -        sys->output->buffer_num = NUM_DECODER_BUFFER_HEADERS;
 -        pool_size = NUM_DECODER_BUFFER_HEADERS;
@@ -1163,7 +1166,7 @@
 -
 +    sys->output->buffer_num = NUM_DECODER_BUFFER_HEADERS;
      sys->output->buffer_size = sys->output->buffer_size_recommended;
-
+ 
 -    status = mmal_port_enable(sys->output, output_port_cb);
 +    status = mmal_port_enable(sys->output, decoder_output_cb);
      if (status != MMAL_SUCCESS) {
@@ -1171,7 +1174,7 @@
                  status, mmal_status_to_string(status));
 @@ -338,25 +509,14 @@ port_reset:
      }
-
+ 
      if (!atomic_load(&sys->started)) {
 -        if (!sys->opaque) {
 -            sys->output_pool = mmal_port_pool_create(sys->output, pool_size, 0);
@@ -1179,7 +1182,7 @@
 -        }
 -
          atomic_store(&sys->started, true);
-
+ 
          /* we need one picture from vout for each buffer header on the output
           * port */
 -        dec->i_extra_picture_buffers = pool_size;
@@ -1196,7 +1199,7 @@
          msg_Dbg(dec, "Request %d extra pictures", dec->i_extra_picture_buffers);
 +#endif
      }
-
+ 
  apply_fmt:
 @@ -366,8 +526,8 @@ apply_fmt:
      dec->fmt_out.video.i_y_offset = sys->output->format->es->video.crop.y;
@@ -1208,7 +1211,7 @@
 +    dec->fmt_out.video.i_sar_den = sys->output_format->es->video.par.den;
      dec->fmt_out.video.i_frame_rate = sys->output->format->es->video.frame_rate.num;
      dec->fmt_out.video.i_frame_rate_base = sys->output->format->es->video.frame_rate.den;
-
+ 
 @@ -382,12 +542,19 @@ apply_fmt:
          sys->b_progressive = (interlace_type.eMode == MMAL_InterlaceProgressive);
          sys->b_top_field_first = sys->b_progressive ? true :
@@ -1220,7 +1223,7 @@
                  interlace_type.eMode);
 +#endif
      }
-
+ 
 +    // Tell the rest of the world we have changed format
 +    vlc_mutex_lock(&sys->pic_lock);
 +    ret = decoder_UpdateVideoFormat(dec);
@@ -1232,7 +1235,7 @@
 @@ -395,144 +562,85 @@ out:
      return ret;
  }
-
+ 
 -static int send_output_buffer(decoder_t *dec)
 +static MMAL_STATUS_T
 +set_extradata_and_commit(decoder_t * const dec, decoder_sys_t * const sys)
@@ -1244,7 +1247,7 @@
      MMAL_STATUS_T status;
 -    unsigned buffer_size = 0;
 -    int ret = 0;
-
+ 
 -    if (!sys->output->is_enabled)
 -        return VLC_EGENERIC;
 -
@@ -1318,7 +1321,7 @@
 -    return ret;
 +    return status;
  }
-
+ 
 -static void fill_output_port(decoder_t *dec)
 +static MMAL_STATUS_T decoder_send_extradata(decoder_t * const dec, decoder_sys_t *const sys)
  {
@@ -1341,7 +1344,7 @@
 +        buf->length = dec->fmt_in.i_extra;
 +        buf->data = dec->fmt_in.p_extra;
 +        buf->flags = MMAL_BUFFER_HEADER_FLAG_CONFIG;
-
+ 
 -    if (sys->output_pool) {
 -        max_buffers_in_transit = __MAX(sys->output_pool->headers_num,
 -                MIN_NUM_BUFFERS_IN_TRANSIT);
@@ -1357,7 +1360,7 @@
 +        }
      }
 -    buffers_to_send = max_buffers_in_transit - atomic_load(&sys->output_in_transit);
-
+ 
 -    if (buffers_to_send > buffers_available)
 -        buffers_to_send = buffers_available;
 -
@@ -1373,14 +1376,14 @@
 -            break;
 +    return MMAL_SUCCESS;
  }
-
+ 
  static void flush_decoder(decoder_t *dec)
  {
 -    decoder_sys_t *sys = dec->p_sys;
 -    MMAL_BUFFER_HEADER_T *buffer;
 -    MMAL_STATUS_T status;
 +    decoder_sys_t *const sys = dec->p_sys;
-
+ 
 -    msg_Dbg(dec, "Flushing decoder ports...");
 -    mmal_port_flush(sys->output);
 -    mmal_port_flush(sys->input);
@@ -1404,7 +1407,7 @@
 +    msg_Dbg(dec, "%s: >>>", __func__);
 +#endif
  }
-
+ 
  static int decode(decoder_t *dec, block_t *block)
  {
      decoder_sys_t *sys = dec->p_sys;
@@ -1414,7 +1417,7 @@
 -    uint32_t flags = 0;
 +    uint32_t flags = MMAL_BUFFER_HEADER_FLAG_FRAME_START;
      MMAL_STATUS_T status;
-
+ 
 +#if TRACE_ALL
 +    msg_Dbg(dec, "<<< %s: %lld/%lld", __func__, block == NULL ? -1LL : block->i_dts, block == NULL ? -1LL : block->i_pts);
 +#endif
@@ -1431,12 +1434,12 @@
 @@ -541,18 +649,50 @@ static int decode(decoder_t *dec, block_
              msg_Err(dec, "Failed to change output port format");
      }
-
+ 
 -    if (!block)
 -        goto out;
 +    if (block == NULL)
 +        return VLCDEC_SUCCESS;
-
+ 
      /*
       * Check whether full flush is required
       */
@@ -1453,7 +1456,7 @@
          block_Release(block);
          return VLCDEC_SUCCESS;
      }
-
+ 
 +    // Reenable stuff if the last thing we did was flush
 +    if (!sys->output->is_enabled &&
 +        (status = mmal_port_enable(sys->output, decoder_output_cb)) != MMAL_SUCCESS)
@@ -1481,11 +1484,11 @@
 +    // reported the size & the output stages have been set up
      if (atomic_load(&sys->started))
          fill_output_port(dec);
-
+ 
 @@ -563,18 +703,21 @@ static int decode(decoder_t *dec, block_
      if (block->i_flags & BLOCK_FLAG_CORRUPTED)
          flags |= MMAL_BUFFER_HEADER_FLAG_CORRUPTED;
-
+ 
 -    while (block && block->i_buffer > 0) {
 -        buffer = mmal_queue_timedwait(sys->input_pool->queue, 100);
 +    while (block != NULL)
@@ -1506,7 +1509,7 @@
          buffer->dts = block->i_dts;
          buffer->alloc_size = sys->input->buffer_size;
 +        buffer->user_data = NULL;
-
+ 
          len = block->i_buffer;
          if (len > buffer->alloc_size)
 @@ -585,94 +728,1808 @@ static int decode(decoder_t *dec, block_
@@ -1522,7 +1525,7 @@
              block = NULL;
          }
          buffer->flags = flags;
-
+ 
 +#if TRACE_ALL
 +        msg_Dbg(dec, "%s: -- Send buffer: cmd=%d, data=%p, size=%d, len=%d, offset=%d, flags=%#x, pts=%lld, dts=%lld", __func__,\
 +                buffer->cmd, buffer->data, buffer->alloc_size, buffer->length, buffer->offset,
@@ -1542,17 +1545,17 @@
 +        flags &= ~MMAL_BUFFER_HEADER_FLAG_FRAME_START;
      }
 +    return VLCDEC_SUCCESS;
-
+ 
 -out:
 -    if (need_flush)
 -        flush_decoder(dec);
 +fail:
 +    flush_decoder(dec);
 +    return VLCDEC_ECRITICAL;
-
+ 
 -    return VLCDEC_SUCCESS;
  }
-
+ 
 -static void control_port_cb(MMAL_PORT_T *port, MMAL_BUFFER_HEADER_T *buffer)
 +
 +static void CloseDecoder(decoder_t *dec)
@@ -1921,7 +1924,7 @@
 +#if TRACE_ALL
 +    msg_Dbg(p_filter, "%s: <<< cmd=%d, data=%p, pic=%p", __func__, buffer->cmd, buffer->data, buffer->user_data);
 +#endif
-
+ 
      if (buffer->cmd == MMAL_EVENT_ERROR) {
 -        status = *(uint32_t *)buffer->data;
 -        msg_Err(dec, "MMAL error %"PRIx32" \"%s\"", status,
@@ -1932,10 +1935,10 @@
 +        msg_Err(p_filter, "MMAL error %"PRIx32" \"%s\"", status,
                  mmal_status_to_string(status));
      }
-
+ 
      mmal_buffer_header_release(buffer);
  }
-
+ 
 -static void input_port_cb(MMAL_PORT_T *port, MMAL_BUFFER_HEADER_T *buffer)
 +static void conv_input_port_cb(MMAL_PORT_T *port, MMAL_BUFFER_HEADER_T *buf)
  {
@@ -1967,14 +1970,14 @@
 +    vlc_mutex_lock(&sys->lock);
 +    pic_fifo_put(&sys->ret_pics, pic);
 +    vlc_mutex_unlock(&sys->lock);
-
+ 
 -    mmal_buffer_header_release(buffer);
 -    if (block)
 -        block_Release(block);
 -    atomic_fetch_sub(&sys->input_in_transit, 1);
      vlc_sem_post(&sys->sem);
  }
-
+ 
 -static void output_port_cb(MMAL_PORT_T *port, MMAL_BUFFER_HEADER_T *buffer)
 +static void conv_output_port_cb(MMAL_PORT_T *port, MMAL_BUFFER_HEADER_T *buf)
  {
@@ -2006,7 +2009,7 @@
 -        fmt = mmal_event_format_changed_get(buffer);
 +    filter_t * const p_filter = (filter_t *)port->userdata;
 +    filter_sys_t * const sys = p_filter->p_sys;
-
+ 
 -        format = mmal_format_alloc();
 -        mmal_format_full_copy(format, fmt->format);
 +#if TRACE_ALL
@@ -2016,7 +2019,7 @@
 +#endif
 +    if (buf->cmd == 0) {
 +        picture_t * const pic = (picture_t *)buf->user_data;
-
+ 
 -        if (sys->opaque)
 -            format->encoding = MMAL_ENCODING_OPAQUE;
 +        if (pic == NULL) {
@@ -2713,9 +2716,9 @@
 +        if (use_isp || use_resizer)
 +            return VLC_EGENERIC;
 +    }
-
+ 
 -        sys->output_format = format;
-
+ 
 -        mmal_buffer_header_release(buffer);
 +    if (use_resizer) {
 +        // use resizer overrides use_isp
@@ -3858,7 +3861,7 @@
 @@ -26,11 +26,12 @@
  #include "config.h"
  #endif
-
+ 
 -#include <vlc_picture_pool.h>
 +#include <stdatomic.h>
 +
@@ -3867,31 +3870,31 @@
  #include <vlc_plugin.h>
  #include <vlc_filter.h>
 -#include <vlc_atomic.h>
-
+ 
  #include "mmal_picture.h"
-
+ 
 @@ -39,468 +40,814 @@
  #include <interface/mmal/util/mmal_util.h>
  #include <interface/mmal/util/mmal_default_components.h>
-
+ 
 -#define MIN_NUM_BUFFERS_IN_TRANSIT 2
 +#define MMAL_DEINTERLACE_NO_QPU "mmal-deinterlace-no-qpu"
 +#define MMAL_DEINTERLACE_NO_QPU_TEXT N_("Do not use QPUs for advanced HD deinterlacing.")
 +#define MMAL_DEINTERLACE_NO_QPU_LONGTEXT N_("Do not make use of the QPUs to allow higher quality deinterlacing of HD content.")
-
+ 
 -#define MMAL_DEINTERLACE_QPU "mmal-deinterlace-adv-qpu"
 -#define MMAL_DEINTERLACE_QPU_TEXT N_("Use QPUs for advanced HD deinterlacing.")
 -#define MMAL_DEINTERLACE_QPU_LONGTEXT N_("Make use of the QPUs to allow higher quality deinterlacing of HD content.")
 +#define MMAL_DEINTERLACE_ADV "mmal-deinterlace-adv"
 +#define MMAL_DEINTERLACE_ADV_TEXT N_("Force advanced deinterlace")
 +#define MMAL_DEINTERLACE_ADV_LONGTEXT N_("Force advanced deinterlace")
-
+ 
 -static int Open(filter_t *filter);
 -static void Close(filter_t *filter);
 +#define MMAL_DEINTERLACE_FAST "mmal-deinterlace-fast"
 +#define MMAL_DEINTERLACE_FAST_TEXT N_("Force fast deinterlace")
 +#define MMAL_DEINTERLACE_FAST_LONGTEXT N_("Force fast deinterlace")
-
+ 
 -vlc_module_begin()
 -    set_shortname(N_("MMAL deinterlace"))
 -    set_description(N_("MMAL-based deinterlace filter plugin"))
@@ -3915,7 +3918,7 @@
 +#define MMAL_DEINTERLACE_FULL_RATE "mmal-deinterlace-full-rate"
 +#define MMAL_DEINTERLACE_FULL_RATE_TEXT N_("Full output framerate")
 +#define MMAL_DEINTERLACE_FULL_RATE_LONGTEXT N_("Full output framerate. 1 output frame for each interlaced field input")
-
+ 
 -struct filter_sys_t {
 +
 +typedef struct filter_sys_t
@@ -3940,14 +3943,14 @@
 +    bool use_passthrough;
 +    unsigned int seq_in;    // Seq of next frame to submit (1-15) [Init=1]
 +    unsigned int seq_out;   // Seq of last frame received  (1-15) [Init=15]
-
+ 
 -    MMAL_QUEUE_T *filtered_pictures;
 -    vlc_sem_t sem;
 +    vcsm_init_type_t vcsm_init_type;
-
+ 
 -    atomic_bool started;
 +} filter_sys_t;
-
+ 
 -    /* statistics */
 -    int output_in_transit;
 -    int input_in_transit;
@@ -3958,9 +3961,9 @@
 -static void output_port_cb(MMAL_PORT_T *port, MMAL_BUFFER_HEADER_T *buffer);
 -static picture_t *deinterlace(filter_t *filter, picture_t *picture);
 -static void flush(filter_t *filter);
-
+ 
  #define MMAL_COMPONENT_DEFAULT_DEINTERLACE "vc.ril.image_fx"
-
+ 
 -static int Open(filter_t *filter)
 +#define TRACE_ALL 0
 +
@@ -3975,7 +3978,7 @@
 -    bool use_qpu = var_InheritBool(filter, MMAL_DEINTERLACE_QPU);
 +    filter_sys_t *const filter_sys = p_filter->p_sys;
 +    picture_t * const pic = filter_NewPicture(p_filter);
-
+ 
 -    MMAL_PARAMETER_IMAGEFX_PARAMETERS_T imfx_param = {
 -            { MMAL_PARAMETER_IMAGE_EFFECT_PARAMETERS, sizeof(imfx_param) },
 -            MMAL_PARAM_IMAGEFX_DEINTERLACE_ADV,
@@ -3984,7 +3987,7 @@
 -    };
 +    if (pic == NULL)
 +        goto fail1;
-
+ 
 -    int ret = VLC_SUCCESS;
 -    MMAL_STATUS_T status;
 -    filter_sys_t *sys;
@@ -3992,28 +3995,28 @@
 +        msg_Err(p_filter, "%s: Empty buffer", __func__);
 +        goto fail2;
 +    }
-
+ 
 -    msg_Dbg(filter, "Try to open mmal_deinterlace filter. frame_duration: %d, QPU %s!",
 -            frame_duration, use_qpu ? "used" : "unused");
 +    if ((pic->context = hw_mmal_gen_context(buf, filter_sys->out_ppr)) == NULL)
 +        goto fail2;
-
+ 
 -    if (filter->fmt_in.video.i_chroma != VLC_CODEC_MMAL_OPAQUE)
 -        return VLC_EGENERIC;
 +    buf_to_pic_copy_props(pic, buf);
-
+ 
 -    if (filter->fmt_out.video.i_chroma != VLC_CODEC_MMAL_OPAQUE)
 -        return VLC_EGENERIC;
 +#if TRACE_ALL
 +    msg_Dbg(p_filter, "pic: prog=%d, tff=%d, date=%lld", pic->b_progressive, pic->b_top_field_first, (long long)pic->date);
 +#endif
-
+ 
 -    sys = calloc(1, sizeof(filter_sys_t));
 -    if (!sys)
 -        return VLC_ENOMEM;
 -    filter->p_sys = sys;
 +    return pic;
-
+ 
 -    bcm_host_init();
 +fail2:
 +    picture_Release(pic);
@@ -4021,7 +4024,7 @@
 +//    mmal_buffer_header_release(buf);
 +    return NULL;
 +}
-
+ 
 -    status = mmal_component_create(MMAL_COMPONENT_DEFAULT_DEINTERLACE, &sys->component);
 -    if (status != MMAL_SUCCESS) {
 -        msg_Err(filter, "Failed to create MMAL component %s (status=%"PRIx32" %s)",
@@ -4040,7 +4043,7 @@
 +#else
 +    VLC_UNUSED(port);
 +#endif
-
+ 
 -    status = mmal_port_parameter_set(sys->component->output[0], &imfx_param.hdr);
 -    if (status != MMAL_SUCCESS) {
 -        msg_Err(filter, "Failed to configure MMAL component %s (status=%"PRIx32" %s)",
@@ -4049,7 +4052,7 @@
 -        goto out;
 -    }
 +    mmal_buffer_header_release(buffer);
-
+ 
 -    sys->component->control->userdata = (struct MMAL_PORT_USERDATA_T *)filter;
 -    status = mmal_port_enable(sys->component->control, control_port_cb);
 -    if (status != MMAL_SUCCESS) {
@@ -4080,7 +4083,7 @@
 +#endif
 +        return;
      }
-
+ 
 -    sys->input = sys->component->input[0];
 -    sys->input->userdata = (struct MMAL_PORT_USERDATA_T *)filter;
 -    if (filter->fmt_in.i_codec == VLC_CODEC_MMAL_OPAQUE)
@@ -4096,10 +4099,10 @@
 +    mmal_buffer_header_reset(buf);   // User data stays intact so release will kill pic
 +    mmal_buffer_header_release(buf);
 +}
-
+ 
 -    es_format_Copy(&filter->fmt_out, &filter->fmt_in);
 -    filter->fmt_out.video.i_frame_rate *= 2;
-
+ 
 -    status = mmal_port_format_commit(sys->input);
 -    if (status != MMAL_SUCCESS) {
 -        msg_Err(filter, "Failed to commit format for input port %s (status=%"PRIx32" %s)",
@@ -4109,7 +4112,7 @@
 -    }
 -    sys->input->buffer_size = sys->input->buffer_size_recommended;
 -    sys->input->buffer_num = sys->input->buffer_num_recommended;
-
+ 
 -    if (filter->fmt_in.i_codec == VLC_CODEC_MMAL_OPAQUE) {
 -        MMAL_PARAMETER_BOOLEAN_T zero_copy = {
 -            { MMAL_PARAMETER_ZERO_COPY, sizeof(MMAL_PARAMETER_BOOLEAN_T) },
@@ -4118,7 +4121,7 @@
 +static MMAL_STATUS_T fill_output_from_q(filter_t * const p_filter, filter_sys_t * const sys, MMAL_QUEUE_T * const q)
 +{
 +    MMAL_BUFFER_HEADER_T * out_buf;
-
+ 
 -        status = mmal_port_parameter_set(sys->input, &zero_copy.hdr);
 -        if (status != MMAL_SUCCESS) {
 -           msg_Err(filter, "Failed to set zero copy on port %s (status=%"PRIx32" %s)",
@@ -4136,7 +4139,7 @@
      }
 +    return MMAL_SUCCESS;
 +}
-
+ 
 -    status = mmal_port_enable(sys->input, input_port_cb);
 -    if (status != MMAL_SUCCESS) {
 -        msg_Err(filter, "Failed to enable input port %s (status=%"PRIx32" %s)",
@@ -4149,14 +4152,14 @@
 +static MMAL_BOOL_T out_buffer_pre_release_cb(MMAL_BUFFER_HEADER_T *header, void *userdata)
 +{
 +    VLC_UNUSED(userdata);
-
+ 
 -    sys->output = sys->component->output[0];
 -    sys->output->userdata = (struct MMAL_PORT_USERDATA_T *)filter;
 -    mmal_format_full_copy(sys->output->format, sys->input->format);
 +    cma_buf_t * const cb = header->user_data;
 +    header->user_data = NULL;
 +    cma_buf_unref(cb);  // Copes fine with NULL
-
+ 
 -    status = mmal_port_format_commit(sys->output);
 -    if (status != MMAL_SUCCESS) {
 -        msg_Err(filter, "Failed to commit format for output port %s (status=%"PRIx32" %s)",
@@ -4240,7 +4243,7 @@
 +            goto fail;
 +        }
 +        mmal_buffer_header_reset(out_buf);
-
+ 
 -    sys->output->buffer_num = 3;
 +        // Attach cma_buf to the buffer & ensure it is freed when the buffer is released
 +        // On a good send callback the pic will be extracted to avoid this
@@ -4264,7 +4267,7 @@
 +                p_pic, out_buf->data, out_buf->user_data, out_buf->flags,
 +                out_buf->length, out_buf->alloc_size, (long long)out_buf->pts);
 +#endif
-
+ 
 -    if (filter->fmt_in.i_codec == VLC_CODEC_MMAL_OPAQUE) {
 -        MMAL_PARAMETER_UINT32_T extra_buffers = {
 -            { MMAL_PARAMETER_EXTRA_BUFFERS, sizeof(MMAL_PARAMETER_UINT32_T) },
@@ -4282,7 +4285,7 @@
          }
 +        out_buf = NULL;
 +    }
-
+ 
 -        MMAL_PARAMETER_BOOLEAN_T zero_copy = {
 -            { MMAL_PARAMETER_ZERO_COPY, sizeof(MMAL_PARAMETER_BOOLEAN_T) },
 -            1
@@ -4297,7 +4300,7 @@
 +            msg_Err(p_filter, "Pic has not attached buffer");
 +            goto fail;
 +        }
-
+ 
 -        status = mmal_port_parameter_set(sys->output, &zero_copy.hdr);
 -        if (status != MMAL_SUCCESS) {
 -           msg_Err(filter, "Failed to set zero copy on port %s (status=%"PRIx32" %s)",
@@ -4317,7 +4320,7 @@
 +            goto fail;
          }
      }
-
+ 
 -    status = mmal_port_enable(sys->output, output_port_cb);
 -    if (status != MMAL_SUCCESS) {
 -        msg_Err(filter, "Failed to enable output port %s (status=%"PRIx32" %s)",
@@ -4410,7 +4413,7 @@
 +        // Crash on lockup
 +        assert(ret_pics != NULL || seq_delta(sys->seq_in, sys->seq_out) < 5);
      }
-
+ 
 -    status = mmal_component_enable(sys->component);
 -    if (status != MMAL_SUCCESS) {
 -        msg_Err(filter, "Failed to enable component %s (status=%"PRIx32" %s)",
@@ -4471,20 +4474,20 @@
 +        // Leaving the input disabled is fine - but we want to leave the output enabled
 +        // so we can retrieve buffers that are still bound to pictures
      }
-
+ 
 -    sys->filtered_pictures = mmal_queue_create();
 +    sys->seq_in = 1;
 +    sys->seq_out = 15;
-
+ 
 -    filter->pf_video_filter = deinterlace;
 -    filter->pf_flush = flush;
 +#if TRACE_ALL
 +    msg_Dbg(p_filter, ">>> %s", __func__);
 +#endif
 +}
-
+ 
 -    vlc_sem_init(&sys->sem, 0);
-
+ 
 -out:
 -    if (ret != VLC_SUCCESS)
 -        Close(filter);
@@ -4493,7 +4496,7 @@
 +    // Nothing to do
 +    VLC_UNUSED(p_filter);
 +}
-
+ 
 -    return ret;
 +static picture_t * pass_deinterlace(filter_t * p_filter, picture_t * p_pic)
 +{
@@ -4502,7 +4505,7 @@
 +    p_pic->b_progressive = true;
 +    return p_pic;
  }
-
+ 
 -static void Close(filter_t *filter)
 +
 +static void control_port_cb(MMAL_PORT_T *port, MMAL_BUFFER_HEADER_T *buffer)
@@ -4511,7 +4514,7 @@
 -    MMAL_BUFFER_HEADER_T *buffer;
 +    filter_t *filter = (filter_t *)port->userdata;
 +    MMAL_STATUS_T status;
-
+ 
 -    if (!sys)
 +    if (buffer->cmd == MMAL_EVENT_ERROR) {
 +        status = *(uint32_t *)buffer->data;
@@ -4533,7 +4536,7 @@
 +
 +    if (sys == NULL)
          return;
-
+ 
 -    if (sys->component && sys->component->control->is_enabled)
 -        mmal_port_disable(sys->component->control);
 +    if (sys->use_passthrough)
@@ -4541,19 +4544,19 @@
 +        free(sys);
 +        return;
 +    }
-
+ 
 -    if (sys->input && sys->input->is_enabled)
 -        mmal_port_disable(sys->input);
 +    di_flush(filter);
-
+ 
 -    if (sys->output && sys->output->is_enabled)
 -        mmal_port_disable(sys->output);
 +    if (sys->component && sys->component->control->is_enabled)
 +        mmal_port_disable(sys->component->control);
-
+ 
      if (sys->component && sys->component->is_enabled)
          mmal_component_disable(sys->component);
-
+ 
 -    while ((buffer = mmal_queue_get(sys->filtered_pictures))) {
 -        picture_t *pic = (picture_t *)buffer->user_data;
 -        picture_Release(pic);
@@ -4575,22 +4578,22 @@
 +        if (sys->out_pool != NULL)
 +            mmal_pool_destroy(sys->out_pool);
      }
-
+ 
 -    if (sys->filtered_pictures)
 -        mmal_queue_destroy(sys->filtered_pictures);
 +    if (sys->out_q != NULL)
 +        mmal_queue_destroy(sys->out_q);
-
+ 
      if (sys->component)
          mmal_component_release(sys->component);
-
+ 
 -    vlc_sem_destroy(&sys->sem);
 +    cma_vcsm_exit(sys->vcsm_init_type);
 +
      free(sys);
 +}
 +
-
+ 
 -    bcm_host_deinit();
 +static bool is_fmt_valid_in(const vlc_fourcc_t fmt)
 +{
@@ -4598,7 +4601,7 @@
 +           fmt == VLC_CODEC_MMAL_ZC_I420 ||
 +           fmt == VLC_CODEC_MMAL_ZC_SAND8;
  }
-
+ 
 -static int send_output_buffer(filter_t *filter)
 +static int OpenMmalDeinterlace(filter_t *filter)
  {
@@ -4619,7 +4622,7 @@
 +    if (!is_fmt_valid_in(filter->fmt_in.video.i_chroma) ||
 +        filter->fmt_out.video.i_chroma != filter->fmt_in.video.i_chroma)
 +        return VLC_EGENERIC;
-
+ 
 -    if (!sys->output->is_enabled) {
 -        ret = VLC_EGENERIC;
 -        goto out;
@@ -4665,7 +4668,7 @@
 +            msg_Warn(filter, "Deinterlace bypassed due to lack of GPU memory");
 +        }
      }
-
+ 
 -    picture = filter_NewPicture(filter);
 -    if (!picture) {
 -        msg_Warn(filter, "Failed to get new picture");
@@ -4717,7 +4720,7 @@
      }
 -    picture->format.i_frame_rate = filter->fmt_out.video.i_frame_rate;
 -    picture->format.i_frame_rate_base = filter->fmt_out.video.i_frame_rate_base;
-
+ 
 -    buffer = picture->p_sys->buffer;
 -    buffer->user_data = picture;
 -    buffer->cmd = 0;
@@ -4727,7 +4730,7 @@
 +                MMAL_COMPONENT_DEFAULT_DEINTERLACE, status, mmal_status_to_string(status));
 +        goto fail;
 +    }
-
+ 
 -    mmal_picture_lock(picture);
 +    {
 +        const MMAL_PARAMETER_IMAGEFX_PARAMETERS_T imfx_param = {
@@ -4738,7 +4741,7 @@
 +            4,
 +            { 5 /* Frame type: mixed */, frame_duration, sys->half_rate, sys->use_qpu }
 +        };
-
+ 
 -    status = mmal_port_send_buffer(sys->output, buffer);
 +        status = mmal_port_parameter_set(sys->component->output[0], &imfx_param.hdr);
 +        if (status != MMAL_SUCCESS) {
@@ -4763,7 +4766,7 @@
 +                sys->component->control->name, status, mmal_status_to_string(status));
 +        goto fail;
      }
-
+ 
 -out:
 -    return ret;
 -}
@@ -4771,7 +4774,7 @@
 +    sys->input->userdata = (struct MMAL_PORT_USERDATA_T *)filter;
 +    sys->input->format->encoding = vlc_to_mmal_video_fourcc(&filter->fmt_in.video);
 +    hw_mmal_vlc_fmt_to_mmal_fmt(sys->input->format, &filter->fmt_in.video);
-
+ 
 -static void fill_output_port(filter_t *filter)
 -{
 -    filter_sys_t *sys = filter->p_sys;
@@ -4785,7 +4788,7 @@
 +    es_format_Copy(&filter->fmt_out, &filter->fmt_in);
 +    if (!sys->half_rate)
 +        filter->fmt_out.video.i_frame_rate *= 2;
-
+ 
 -    if (buffers_to_send > buffers_available)
 -        buffers_to_send = buffers_available;
 +    status = mmal_port_format_commit(sys->input);
@@ -4797,7 +4800,7 @@
 +    sys->input->buffer_size = sys->input->buffer_size_recommended;
 +    sys->input->buffer_num = 30;
 +//    sys->input->buffer_num = sys->input->buffer_num_recommended;
-
+ 
 -#ifndef NDEBUG
 -    msg_Dbg(filter, "Send %d buffers to output port (available: %d, in_transit: %d, buffer_num: %d)",
 -                    buffers_to_send, buffers_available, sys->output_in_transit,
@@ -4812,7 +4815,7 @@
 +        goto fail;
      }
 -}
-
+ 
 -static picture_t *deinterlace(filter_t *filter, picture_t *picture)
 -{
 -    filter_sys_t *sys = filter->p_sys;
@@ -4827,7 +4830,7 @@
 +                sys->input->name, status, mmal_status_to_string(status));
 +       goto fail;
 +    }
-
+ 
 -    fill_output_port(filter);
 +    status = mmal_port_enable(sys->input, di_input_port_cb);
 +    if (status != MMAL_SUCCESS) {
@@ -4835,12 +4838,12 @@
 +                sys->input->name, status, mmal_status_to_string(status));
 +        goto fail;
 +    }
-
+ 
 -    buffer = picture->p_sys->buffer;
 -    buffer->user_data = picture;
 -    buffer->pts = picture->date;
 -    buffer->cmd = 0;
-
+ 
 -    if (!picture->p_sys->displayed) {
 -        status = mmal_port_send_buffer(sys->input, buffer);
 -        if (status != MMAL_SUCCESS) {
@@ -4881,7 +4884,7 @@
      }
 -    if (out_picture)
 -        out_picture->p_next = NULL;
-
+ 
 -    return ret;
 -}
 -
@@ -4891,7 +4894,7 @@
 -    MMAL_BUFFER_HEADER_T *buffer;
 +    sys->output = sys->component->output[0];
 +    mmal_format_full_copy(sys->output->format, sys->input->format);
-
+ 
 -    msg_Dbg(filter, "flush deinterlace filter");
 +    if (!sys->is_cma)
 +    {
@@ -4908,7 +4911,7 @@
 +            msg_Err(filter, "Failed to alloc cma buf pool");
 +            goto fail;
 +        }
-
+ 
 -    msg_Dbg(filter, "flush: flush ports (input: %d, output: %d in transit)",
 -            sys->input_in_transit, sys->output_in_transit);
 -    mmal_port_flush(sys->output);
@@ -4934,13 +4937,13 @@
 +            msg_Err(filter, "Failed to alloc out pool");
 +            goto fail;
 +        }
-
+ 
 -static void control_port_cb(MMAL_PORT_T *port, MMAL_BUFFER_HEADER_T *buffer)
 -{
 -    filter_t *filter = (filter_t *)port->userdata;
 -    MMAL_STATUS_T status;
 +        port_parameter_set_bool(sys->output, MMAL_PARAMETER_ZERO_COPY, true);
-
+ 
 -    if (buffer->cmd == MMAL_EVENT_ERROR) {
 -        status = *(uint32_t *)buffer->data;
 -        msg_Err(filter, "MMAL error %"PRIx32" \"%s\"", status,
@@ -4951,12 +4954,12 @@
 +            msg_Err(filter, "Output port format commit failed");
 +            goto fail;
 +        }
-
+ 
 -    mmal_buffer_header_release(buffer);
 -}
 +        sys->output->buffer_num = 30;
 +        sys->output->buffer_size = sys->output->buffer_size_recommended;
-
+ 
 -static void input_port_cb(MMAL_PORT_T *port, MMAL_BUFFER_HEADER_T *buffer)
 -{
 -    picture_t *picture = (picture_t *)buffer->user_data;
@@ -4970,7 +4973,7 @@
 +            goto fail;
 +        }
 +    }
-
+ 
 -    if (picture) {
 -        picture_Release(picture);
 -    } else {
@@ -4982,7 +4985,7 @@
 +                sys->component->name, status, mmal_status_to_string(status));
 +        goto fail;
      }
-
+ 
 -    atomic_fetch_sub(&sys->input_in_transit, 1);
 -    vlc_sem_post(&sys->sem);
 +    filter->pf_video_filter = deinterlace;
@@ -4993,7 +4996,7 @@
 +    CloseMmalDeinterlace(filter);
 +    return ret;
  }
-
+ 
 -static void output_port_cb(MMAL_PORT_T *port, MMAL_BUFFER_HEADER_T *buffer)
 -{
 -    filter_t *filter = (filter_t *)port->userdata;
@@ -5022,7 +5025,7 @@
 +
 +vlc_module_end()
 +
-
+ 
 -    if (buffer->cmd == 0) {
 -        if (buffer->length > 0) {
 -            atomic_store(&sys->started, true);
@@ -8126,7 +8129,7 @@
 @@ -21,25 +21,1542 @@
   * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
   *****************************************************************************/
-
+ 
 +// We would really like to use vlc_thread.h but the detach thread stuff can't be
 +// used here :-(
 +#include <pthread.h>
@@ -8148,7 +8151,7 @@
 +#include <interface/mmal/util/mmal_default_components.h>
 +#include <interface/vmcs_host/vcgencmd.h>
 +#include <interface/vcsm/user-vcsm.h>
-
+ 
 +#include "mmal_cma.h"
  #include "mmal_picture.h"
 +#include "transform_ops.h"
@@ -9291,7 +9294,7 @@
 +            ent = ent_list_extract_pic_ent(&pc->ents_cur, pic);
 +
 +//        printf("ent_found: %p\n", ent);
-
+ 
 -int mmal_picture_lock(picture_t *picture)
 +        if (ent == NULL)
 +        {
@@ -9523,7 +9526,7 @@
 +        case MMAL_ENCODING_RGB16:
 +            pb = 2;
 +            break;
-
+ 
 -    int offset = 0;
 -    picture->p[0].p_pixels = buffer->data;
 -    for (int i = 1; i < picture->i_planes; i++) {
@@ -9544,14 +9547,14 @@
 +//            msg_Err(p_filter, "%s: Unexpected format", __func__);
 +            return VLC_EGENERIC;
      }
-
+ 
 -    pic_sys->displayed = false;
 +    // Fix up SAR if unset
 +    if (pic->format.i_sar_den == 0 || pic->format.i_sar_num == 0) {
 +        pic->format.i_sar_den = mm_fmt->par.den;
 +        pic->format.i_sar_num = mm_fmt->par.num;
 +    }
-
+ 
 +    pic->i_planes = planes;
 +    unsigned int offset = 0;
 +    for (unsigned int i = 0; i != planes; ++i) {
@@ -9680,17 +9683,17 @@
 @@ -24,19 +24,298 @@
  #ifndef VLC_MMAL_MMAL_PICTURE_H_
  #define VLC_MMAL_MMAL_PICTURE_H_
-
+ 
 +#include <stdatomic.h>
 +
  #include <vlc_common.h>
  #include <interface/mmal/mmal.h>
-
+ 
 +#include "mmal_cma.h"
 +
  /* Think twice before changing this. Incorrect values cause havoc. */
  #define NUM_ACTUAL_OPAQUE_BUFFERS 30
-
+ 
 -struct picture_sys_t {
 -    vlc_object_t *owner;
 +#ifndef VLC_TICK_INVALID
@@ -9969,18 +9972,18 @@
 +vcsm_init_type_t cma_vcsm_type(void);
 +const char * cma_vcsm_init_str(const vcsm_init_type_t init_mode);
 +
-
+ 
 -    MMAL_BUFFER_HEADER_T *buffer;
 -    bool displayed;
 -};
 +#define VOUT_DISPLAY_CHANGE_MMAL_BASE 1024
 +#define VOUT_DISPLAY_CHANGE_MMAL_HIDE (VOUT_DISPLAY_CHANGE_MMAL_BASE + 0)
-
+ 
 -int mmal_picture_lock(picture_t *picture);
 +#define MMAL_COMPONENT_DEFAULT_RESIZER "vc.ril.resize"
 +#define MMAL_COMPONENT_ISP_RESIZER     "vc.ril.isp"
 +#define MMAL_COMPONENT_HVS             "vc.ril.hvs"
-
+ 
  #endif
 --- /dev/null
 +++ b/modules/hw/mmal/rpi_prof.h
@@ -10879,17 +10882,17 @@
 +++ b/modules/hw/mmal/vout.c
 @@ -27,21 +27,28 @@
  #endif
-
+ 
  #include <math.h>
 +#include <stdatomic.h>
-
+ 
  #include <vlc_common.h>
 -#include <vlc_atomic.h>
  #include <vlc_plugin.h>
  #include <vlc_threads.h>
  #include <vlc_vout_display.h>
 +#include <vlc_modules.h>
-
+ 
 -#include "mmal_picture.h"
 -
 +#pragma GCC diagnostic push
@@ -10907,13 +10910,13 @@
 +#include "transform_ops.h"
 +
 +#define TRACE_ALL 0
-
+ 
  #define MAX_BUFFERS_IN_TRANSIT 1
  #define VC_TV_MAX_MODE_IDS 127
 @@ -50,10 +57,28 @@
  #define MMAL_LAYER_TEXT N_("VideoCore layer where the video is displayed.")
  #define MMAL_LAYER_LONGTEXT N_("VideoCore layer where the video is displayed. Subpictures are displayed directly above and a black background directly below.")
-
+ 
 -#define MMAL_BLANK_BACKGROUND_NAME "mmal-blank-background"
 -#define MMAL_BLANK_BACKGROUND_TEXT N_("Blank screen below video.")
 -#define MMAL_BLANK_BACKGROUND_LONGTEXT N_("Render blank screen below video. " \
@@ -10940,13 +10943,13 @@
 +#define MMAL_VOUT_TRANSPARENT_LONGTEXT N_("Enable layers beneath the video layer."\
 +" By default these are disabled."\
 +" Having the lower layers enabled can impact video performance")
-
+ 
  #define MMAL_ADJUST_REFRESHRATE_NAME "mmal-adjust-refreshrate"
  #define MMAL_ADJUST_REFRESHRATE_TEXT N_("Adjust HDMI refresh rate to the video.")
 @@ -68,332 +93,628 @@
  #define PHASE_OFFSET_TARGET ((double)0.25)
  #define PHASE_CHECK_INTERVAL 100
-
+ 
 -static int Open(vlc_object_t *);
 -static void Close(vlc_object_t *);
 -
@@ -10965,7 +10968,7 @@
 -    set_callbacks(Open, Close)
 -vlc_module_end()
 +#define SUBS_MAX 4
-
+ 
 -struct dmx_region_t {
 -    struct dmx_region_t *next;
 -    picture_t *picture;
@@ -10982,12 +10985,12 @@
 +    MMAL_COMPONENT_T *component;
 +    subpic_reg_stash_t sub;
 +} vout_subpic_t;
-
+ 
  struct vout_display_sys_t {
 -    vlc_cond_t buffer_cond;
 -    vlc_mutex_t buffer_mutex;
      vlc_mutex_t manage_mutex;
-
+ 
 -    plane_t planes[3]; /* Depending on video format up to 3 planes are used */
 -    picture_t **pictures; /* Actual list of alloced pictures passed into picture_pool */
 -    picture_pool_t *picture_pool;
@@ -10998,11 +11001,11 @@
      MMAL_POOL_T *pool; /* mmal buffer headers, used for pushing pictures to component*/
 -    struct dmx_region_t *dmx_region;
      int i_planes; /* Number of actually used planes, 1 for opaque, 3 for i420 */
-
+ 
 -    uint32_t buffer_size; /* size of actual mmal buffers */
      int buffers_in_transit; /* number of buffers currently pushed to mmal component */
      unsigned num_buffers; /* number of buffers allocated at mmal port */
-
+ 
 -    DISPMANX_DISPLAY_HANDLE_T dmx_handle;
 -    DISPMANX_ELEMENT_HANDLE_T bkg_element;
 -    DISPMANX_RESOURCE_HANDLE_T bkg_resource;
@@ -11018,17 +11021,17 @@
 +    MMAL_DISPLAYTRANSFORM_T dest_transform;      // Dest window coord transform
 +    MMAL_DISPLAYTRANSFORM_T display_transform;  // "Native" display transform
 +    MMAL_DISPLAYTRANSFORM_T video_transform;     // Combined config+native transform
-
+ 
 -    int i_frame_rate_base; /* cached framerate to detect changes for rate adjustment */
 -    int i_frame_rate;
 +    unsigned int i_frame_rate_base; /* cached framerate to detect changes for rate adjustment */
 +    unsigned int i_frame_rate;
-
+ 
      int next_phase_check; /* lowpass for phase check frequency */
      int phase_offset; /* currently applied offset to presentation time in ns */
      int layer; /* the dispman layer (z-index) used for video rendering */
 +    bool transparent;           // Do not disable layers beneath ours
-
+ 
      bool need_configure_display; /* indicates a required display reconfigure to main thread */
      bool adjust_refresh_rate;
      bool native_interlaced;
@@ -11037,7 +11040,7 @@
 -    bool opaque; /* indicated use of opaque picture format (zerocopy) */
 -};
 +    bool force_config;
-
+ 
 -static const vlc_fourcc_t subpicture_chromas[] = {
 -    VLC_CODEC_RGBA,
 -    0
@@ -11058,14 +11061,14 @@
 +        MMAL_POOL_T * out_pool;
 +        bool pending;
 +    } isp;
-
+ 
 -/* Utility functions */
 -static inline uint32_t align(uint32_t x, uint32_t y);
 -static int configure_display(vout_display_t *vd, const vout_display_cfg_t *cfg,
 -                const video_format_t *fmt);
 +    MMAL_POOL_T * copy_pool;
 +    MMAL_BUFFER_HEADER_T * copy_buf;
-
+ 
 -/* VLC vout display callbacks */
 -static picture_pool_t *vd_pool(vout_display_t *vd, unsigned count);
 -static void vd_prepare(vout_display_t *vd, picture_t *picture,
@@ -11081,14 +11084,14 @@
 +    // Subpic blend if we have to do it here
 +    vzc_pool_ctl_t * vzc;
 +};
-
+ 
 -/* TV service */
 -static int query_resolution(vout_display_t *vd, unsigned *width, unsigned *height);
 -static void tvservice_cb(void *callback_data, uint32_t reason, uint32_t param1,
 -                uint32_t param2);
 -static void adjust_refresh_rate(vout_display_t *vd, const video_format_t *fmt);
 -static int set_latency_target(vout_display_t *vd, bool enable);
-
+ 
 -/* DispManX */
 -static void display_subpicture(vout_display_t *vd, subpicture_t *subpicture);
 -static void close_dmx(vout_display_t *vd);
@@ -11101,7 +11104,7 @@
 -static void show_background(vout_display_t *vd, bool enable);
 -static void maintain_phase_sync(vout_display_t *vd);
 +// ISP setup
-
+ 
 -static int Open(vlc_object_t *object)
 +static inline bool want_isp(const vout_display_t * const vd)
  {
@@ -11115,14 +11118,14 @@
 -    unsigned i;
 +    return (vd->fmt.i_chroma == VLC_CODEC_MMAL_ZC_SAND10);
 +}
-
+ 
 -    if (vout_display_IsWindowed(vd))
 -        return VLC_EGENERIC;
 +static inline bool want_copy(const vout_display_t * const vd)
 +{
 +    return (vd->fmt.i_chroma == VLC_CODEC_I420 || vd->fmt.i_chroma == VLC_CODEC_I420_10L);
 +}
-
+ 
 -    sys = calloc(1, sizeof(struct vout_display_sys_t));
 -    if (!sys)
 -        return VLC_ENOMEM;
@@ -11133,7 +11136,7 @@
 +        VLC_CODEC_I420 :
 +        vd->fmt.i_chroma;
 +}
-
+ 
 -    sys->layer = var_InheritInteger(vd, MMAL_LAYER_NAME);
 -    bcm_host_init();
 +static MMAL_FOURCC_T vout_vlc_to_mmal_pic_fourcc(const unsigned int fcc)
@@ -11155,14 +11158,14 @@
 +    }
 +    return MMAL_ENCODING_I420;
 +}
-
+ 
 -    sys->opaque = vd->fmt.i_chroma == VLC_CODEC_MMAL_OPAQUE;
 +static void display_set_format(const vout_display_t * const vd, MMAL_ES_FORMAT_T *const es_fmt, const bool is_intermediate)
 +{
 +    const unsigned int w = is_intermediate ? vd->fmt.i_visible_width  : vd->fmt.i_width ;
 +    const unsigned int h = is_intermediate ? vd->fmt.i_visible_height : vd->fmt.i_height;
 +    MMAL_VIDEO_FORMAT_T * const v_fmt = &es_fmt->es->video;
-
+ 
 -    status = mmal_component_create(MMAL_COMPONENT_DEFAULT_VIDEO_RENDERER, &sys->component);
 -    if (status != MMAL_SUCCESS) {
 -        msg_Err(vd, "Failed to create MMAL component %s (status=%"PRIx32" %s)",
@@ -11189,7 +11192,7 @@
 +    v_fmt->frame_rate.num = vd->fmt.i_frame_rate;
 +    v_fmt->frame_rate.den = vd->fmt.i_frame_rate_base;
 +    v_fmt->color_space    = vlc_to_mmal_color_space(vd->fmt.space);
-
+ 
 -    sys->component->control->userdata = (struct MMAL_PORT_USERDATA_T *)vd;
 -    status = mmal_port_enable(sys->component->control, control_port_cb);
 -    if (status != MMAL_SUCCESS) {
@@ -11241,12 +11244,12 @@
 +        status = *(uint32_t *)buffer->data;
 +        msg_Err(vd, "MMAL error %"PRIx32" \"%s\"", status, mmal_status_to_string(status));
      }
-
+ 
 -    sys->input = sys->component->input[0];
 -    sys->input->userdata = (struct MMAL_PORT_USERDATA_T *)vd;
 +    mmal_buffer_header_release(buffer);
 +}
-
+ 
 -    if (sys->opaque) {
 -        sys->input->format->encoding = MMAL_ENCODING_OPAQUE;
 -        sys->i_planes = 1;
@@ -11276,7 +11279,7 @@
 +        // but might not on later flushes as we shut down
 +        vout_display_t * const vd = (vout_display_t *)port->userdata;
 +        struct vout_isp_conf_s *const isp = &vd->sys->isp;
-
+ 
 -    status = mmal_port_format_commit(sys->input);
 -    if (status != MMAL_SUCCESS) {
 -        msg_Err(vd, "Failed to commit format for input port %s (status=%"PRIx32" %s)",
@@ -11298,7 +11301,7 @@
 +        mmal_buffer_header_release(buf);
 +    }
 +}
-
+ 
 -    vout_display_PlacePicture(&place, &vd->source, vd->cfg, false);
 -    display_region.hdr.id = MMAL_PARAMETER_DISPLAYREGION;
 -    display_region.hdr.size = sizeof(MMAL_DISPLAYREGION_T);
@@ -11355,7 +11358,7 @@
 +            return err;
 +        }
      }
-
+ 
 -    for (i = 0; i < sys->i_planes; ++i) {
 -        sys->planes[i].i_lines = buffer_height;
 -        sys->planes[i].i_pitch = buffer_pitch;
@@ -11368,7 +11371,7 @@
 +            return err;
 +        }
 +    }
-
+ 
 -        if (i > 0) {
 -            sys->planes[i].i_lines /= 2;
 -            sys->planes[i].i_pitch /= 2;
@@ -11383,7 +11386,7 @@
      }
 +    return MMAL_SUCCESS;
 +}
-
+ 
 -    vlc_mutex_init(&sys->buffer_mutex);
 -    vlc_cond_init(&sys->buffer_cond);
 -    vlc_mutex_init(&sys->manage_mutex);
@@ -11391,7 +11394,7 @@
 +{
 +    struct vout_isp_conf_s * const isp = &vd_sys->isp;
 +    VLC_UNUSED(vd);
-
+ 
 -    vd->pool = vd_pool;
 -    vd->prepare = vd_prepare;
 -    vd->display = vd_display;
@@ -11399,10 +11402,10 @@
 -    vd->manage = vd_manage;
 +    if (isp->component == NULL)
 +        return;
-
+ 
 -    vc_tv_register_callback(tvservice_cb, vd);
 +    isp_flush(isp);
-
+ 
 -    if (query_resolution(vd, &sys->display_width, &sys->display_height) >= 0) {
 -        vout_display_SendEventDisplaySize(vd, sys->display_width, sys->display_height);
 -    } else {
@@ -11418,28 +11421,28 @@
 +        mmal_queue_destroy(isp->out_q);
 +        isp->out_q = NULL;
      }
-
+ 
 -    sys->dmx_handle = vc_dispmanx_display_open(0);
 -    vd->info.subpicture_chromas = subpicture_chromas;
 +    if (isp->out_pool != NULL) {
 +        mmal_port_pool_destroy(isp->output, isp->out_pool);
 +        isp->out_pool = NULL;
 +    }
-
+ 
 -    vout_display_DeleteWindow(vd, NULL);
 +    isp->input = NULL;
 +    isp->output = NULL;
-
+ 
 -out:
 -    if (ret != VLC_SUCCESS)
 -        Close(object);
 +    mmal_component_release(isp->component);
 +    isp->component = NULL;
-
+ 
 -    return ret;
 +    return;
  }
-
+ 
 -static void Close(vlc_object_t *object)
 +// Restuff into output rather than return to pool is we can
 +static MMAL_BOOL_T isp_out_pool_cb(MMAL_POOL_T *pool, MMAL_BUFFER_HEADER_T *buffer, void *userdata)
@@ -11457,13 +11460,13 @@
 +    }
 +    return MMAL_TRUE;
 +}
-
+ 
 -    vc_tv_unregister_callback_full(tvservice_cb, vd);
 +static MMAL_STATUS_T isp_setup(vout_display_t * const vd, vout_display_sys_t * const vd_sys)
 +{
 +    struct vout_isp_conf_s * const isp = &vd_sys->isp;
 +    MMAL_STATUS_T err;
-
+ 
 -    if (sys->dmx_handle)
 -        close_dmx(vd);
 +    if ((err = mmal_component_create(MMAL_COMPONENT_ISP_RESIZER, &isp->component)) != MMAL_SUCCESS) {
@@ -11472,7 +11475,7 @@
 +    }
 +    isp->input = isp->component->input[0];
 +    isp->output = isp->component->output[0];
-
+ 
 -    if (sys->component && sys->component->control->is_enabled)
 -        mmal_port_disable(sys->component->control);
 +    isp->component->control->userdata = (void *)vd;
@@ -11480,29 +11483,29 @@
 +        msg_Err(vd, "Failed to enable ISP control port");
 +        goto fail;
 +    }
-
+ 
 -    if (sys->input && sys->input->is_enabled)
 -        mmal_port_disable(sys->input);
 +    isp->input->userdata = (void *)vd;
 +    display_set_format(vd, isp->input->format, false);
-
+ 
 -    if (sys->component && sys->component->is_enabled)
 -        mmal_component_disable(sys->component);
 +    if ((err = port_parameter_set_bool(isp->input, MMAL_PARAMETER_ZERO_COPY, true)) != MMAL_SUCCESS)
 +        goto fail;
-
+ 
 -    if (sys->pool)
 -        mmal_port_pool_destroy(sys->input, sys->pool);
 +    if ((err = mmal_port_format_commit(isp->input)) != MMAL_SUCCESS) {
 +        msg_Err(vd, "Failed to set ISP input format");
 +        goto fail;
 +    }
-
+ 
 -    if (sys->component)
 -        mmal_component_release(sys->component);
 +    isp->input->buffer_size = isp->input->buffer_size_recommended;
 +    isp->input->buffer_num = 30;
-
+ 
 -    if (sys->picture_pool)
 -        picture_pool_Release(sys->picture_pool);
 -    else
@@ -11516,7 +11519,7 @@
 +        msg_Err(vd, "Failed to create input pool");
 +        goto fail;
 +    }
-
+ 
 -    vlc_mutex_destroy(&sys->buffer_mutex);
 -    vlc_cond_destroy(&sys->buffer_cond);
 -    vlc_mutex_destroy(&sys->manage_mutex);
@@ -11525,7 +11528,7 @@
 +        err = MMAL_ENOMEM;
 +        goto fail;
 +    }
-
+ 
 -    if (sys->native_interlaced) {
 -        if (vc_gencmd(response, sizeof(response), "hvs_update_fields 0") < 0 ||
 -                response[18] != '0')
@@ -11539,7 +11542,7 @@
 +        msg_Err(vd, "Failed to set ISP input format");
 +        goto fail;
      }
-
+ 
 -    free(sys->pictures);
 -    free(sys);
 +    isp->output->buffer_size = isp->output->buffer_size_recommended;
@@ -11558,13 +11561,13 @@
 +        goto fail;
 +
 +    return MMAL_SUCCESS;
-
+ 
 -    bcm_host_deinit();
 +fail:
 +    isp_close(vd, vd_sys);
 +    return err;
  }
-
+ 
 -static inline uint32_t align(uint32_t x, uint32_t y) {
 -    uint32_t mod = x % y;
 -    if (mod == 0)
@@ -11792,7 +11795,7 @@
 +    }
 +    return 0;
  }
-
+ 
  static int configure_display(vout_display_t *vd, const vout_display_cfg_t *cfg,
                  const video_format_t *fmt)
  {
@@ -11801,7 +11804,7 @@
 -    MMAL_DISPLAYREGION_T display_region;
 +    vout_display_sys_t * const sys = vd->sys;
      MMAL_STATUS_T status;
-
+ 
      if (!cfg && !fmt)
 +    {
 +        msg_Err(vd, "%s: Missing cfg & fmt", __func__);
@@ -11809,17 +11812,17 @@
 +    }
 +
 +    isp_check(vd, sys);
-
+ 
      if (fmt) {
          sys->input->format->es->video.par.num = fmt->i_sar_num;
 @@ -412,30 +733,14 @@ static int configure_display(vout_displa
      if (!cfg)
          cfg = vd->cfg;
-
+ 
 -    vout_display_PlacePicture(&place, fmt, cfg, false);
 +    sys->video_transform = combine_transform(
 +        vlc_to_mmal_transform(fmt->orientation), sys->display_transform);
-
+ 
 -    display_region.hdr.id = MMAL_PARAMETER_DISPLAYREGION;
 -    display_region.hdr.size = sizeof(MMAL_DISPLAYREGION_T);
 -    display_region.fullscreen = MMAL_FALSE;
@@ -11843,7 +11846,7 @@
 +    if (set_input_region(vd, fmt) != 0)
          return -EINVAL;
 -    }
-
+ 
 -    show_background(vd, var_InheritBool(vd, MMAL_BLANK_BACKGROUND_NAME));
      sys->adjust_refresh_rate = var_InheritBool(vd, MMAL_ADJUST_REFRESHRATE_NAME);
      sys->native_interlaced = var_InheritBool(vd, MMAL_NATIVE_INTERLACED);
@@ -11851,7 +11854,7 @@
 @@ -446,204 +751,217 @@ static int configure_display(vout_displa
      return 0;
  }
-
+ 
 +static void kill_pool(vout_display_sys_t * const sys)
 +{
 +    if (sys->pic_pool != NULL) {
@@ -11870,21 +11873,21 @@
 -    MMAL_STATUS_T status;
 -    unsigned i;
 +    vout_display_sys_t * const sys = vd->sys;
-
+ 
 -    if (sys->picture_pool) {
 -        if (sys->num_buffers < count)
 -            msg_Warn(vd, "Picture pool with %u pictures requested, but we already have one with %u pictures",
 -                            count, sys->num_buffers);
 +    msg_Dbg(vd, "%s: fmt:%dx%d,sar:%d/%d; source:%dx%d", __func__,
 +            vd->fmt.i_width, vd->fmt.i_height, vd->fmt.i_sar_num, vd->fmt.i_sar_den, vd->source.i_width, vd->source.i_height);
-
+ 
 -        goto out;
 +    if (sys->pic_pool == NULL) {
 +        sys->pic_pool = picture_pool_NewFromFormat(&vd->fmt, count);
      }
 +    return sys->pic_pool;
 +}
-
+ 
 -    if (sys->opaque) {
 -        if (count <= NUM_ACTUAL_OPAQUE_BUFFERS)
 -            count = NUM_ACTUAL_OPAQUE_BUFFERS;
@@ -11896,7 +11899,7 @@
 +        return true;
 +    return false;
 +}
-
+ 
 -        MMAL_PARAMETER_BOOLEAN_T zero_copy = {
 -            { MMAL_PARAMETER_ZERO_COPY, sizeof(MMAL_PARAMETER_BOOLEAN_T) },
 -            1
@@ -11906,7 +11909,7 @@
 +{
 +    vout_display_sys_t * const sys = vd->sys;
 +    MMAL_STATUS_T err;
-
+ 
 -        status = mmal_port_parameter_set(sys->input, &zero_copy.hdr);
 -        if (status != MMAL_SUCCESS) {
 -           msg_Err(vd, "Failed to set zero copy on port %s (status=%"PRIx32" %s)",
@@ -11930,7 +11933,7 @@
 -#ifndef NDEBUG
 -    msg_Dbg(vd, "Creating picture pool with %u pictures", count);
  #endif
-
+ 
 -    sys->input->buffer_num = count;
 -    status = mmal_port_enable(sys->input, input_port_cb);
 -    if (status != MMAL_SUCCESS) {
@@ -11942,7 +11945,7 @@
 +    if (subpicture != NULL) {
 +        subpicture_Delete(subpicture);
      }
-
+ 
 -    status = mmal_component_enable(sys->component);
 -    if (status != MMAL_SUCCESS) {
 -        msg_Err(vd, "Failed to enable component %s (status=%"PRIx32" %s)",
@@ -12017,11 +12020,11 @@
 +            msg_Err(vd, "Replicated buffer get fail");
 +            goto fail;
          }
-
+ 
 -        sys->pictures[i]->i_planes = sys->i_planes;
 -        memcpy(sys->pictures[i]->p, sys->planes, sys->i_planes * sizeof(plane_t));
 -    }
-
+ 
 -    memset(&picture_pool_cfg, 0, sizeof(picture_pool_configuration_t));
 -    picture_pool_cfg.picture_count = sys->num_buffers;
 -    picture_pool_cfg.picture = sys->pictures;
@@ -12035,7 +12038,7 @@
 +            if (mmal_port_format_commit(sys->input) != MMAL_SUCCESS)
 +                msg_Warn(vd, "Input format commit failed");
 +        }
-
+ 
 -    sys->picture_pool = picture_pool_NewExtended(&picture_pool_cfg);
 -    if (!sys->picture_pool) {
 -        msg_Err(vd, "Failed to create picture pool");
@@ -12047,7 +12050,7 @@
 +            goto fail;
 +        }
      }
-
+ 
 -out:
 -    return sys->picture_pool;
 -}
@@ -12123,18 +12126,18 @@
 -    } else {
 -        picture_Release(picture);
      }
-
+ 
 -    display_subpicture(vd, subpicture);
 +fail:
 +    for (unsigned int i = 0; i != SUBS_MAX && sys->subpic_bufs[i] != NULL; ++i) {
 +        mmal_buffer_header_release(sys->subpic_bufs[i]);
 +        sys->subpic_bufs[i] = NULL;
 +    }
-
+ 
 -    if (subpicture)
 -        subpicture_Delete(subpicture);
 +    picture_Release(p_pic);
-
+ 
      if (sys->next_phase_check == 0 && sys->adjust_refresh_rate)
          maintain_phase_sync(vd);
      sys->next_phase_check = (sys->next_phase_check + 1) % PHASE_CHECK_INTERVAL;
@@ -12146,7 +12149,7 @@
 -        vlc_mutex_unlock(&sys->buffer_mutex);
 -    }
  }
-
+ 
  static int vd_control(vout_display_t *vd, int query, va_list args)
  {
 -    vout_display_sys_t *sys = vd->sys;
@@ -12155,7 +12158,7 @@
 +    vout_display_sys_t * const sys = vd->sys;
      int ret = VLC_EGENERIC;
 +    VLC_UNUSED(args);
-
+ 
      switch (query) {
 -        case VOUT_DISPLAY_CHANGE_DISPLAY_SIZE:
 -            tmp_cfg = va_arg(args, const vout_display_cfg_t *);
@@ -12175,7 +12178,7 @@
 +            if (configure_display(vd, vd->cfg, &vd->source) >= 0)
                  ret = VLC_SUCCESS;
              break;
-
+ 
 -        case VOUT_DISPLAY_RESET_PICTURES:
 -            vlc_assert_unreachable();
          case VOUT_DISPLAY_CHANGE_ZOOM:
@@ -12218,13 +12221,13 @@
 +            ret = VLC_SUCCESS;
              break;
 +        }
-
+ 
          default:
              msg_Warn(vd, "Unknown control query %d", query);
 @@ -653,79 +971,207 @@ static int vd_control(vout_display_t *vd
      return ret;
  }
-
+ 
 +static void set_display_windows(vout_display_t *const vd, vout_display_sys_t *const sys)
 +{
 +    unsigned int width, height;
@@ -12245,9 +12248,9 @@
 -    vout_display_sys_t *sys = vd->sys;
 -    unsigned width, height;
 +    vout_display_sys_t *const sys = vd->sys;
-
+ 
      vlc_mutex_lock(&sys->manage_mutex);
-
+ 
      if (sys->need_configure_display) {
 -        close_dmx(vd);
 -        sys->dmx_handle = vc_dispmanx_display_open(0);
@@ -12261,10 +12264,10 @@
          sys->need_configure_display = false;
 +        set_display_windows(vd, sys);
      }
-
+ 
      vlc_mutex_unlock(&sys->manage_mutex);
  }
-
+ 
 -static void control_port_cb(MMAL_PORT_T *port, MMAL_BUFFER_HEADER_T *buffer)
 +
 +static int attach_subpics(vout_display_t * const vd, vout_display_sys_t * const sys,
@@ -12273,7 +12276,7 @@
 -    vout_display_t *vd = (vout_display_t *)port->userdata;
 -    MMAL_STATUS_T status;
 +    unsigned int n = 0;
-
+ 
 -    if (buffer->cmd == MMAL_EVENT_ERROR) {
 -        status = *(uint32_t *)buffer->data;
 -        msg_Err(vd, "MMAL error %"PRIx32" \"%s\"", status, mmal_status_to_string(status));
@@ -12284,7 +12287,7 @@
 +            return VLC_ENOMEM;
 +        }
      }
-
+ 
 -    mmal_buffer_header_release(buffer);
 +    // Attempt to import the subpics
 +    for (subpicture_t * spic = subpicture; spic != NULL; spic = spic->p_next)
@@ -12330,7 +12333,7 @@
 +    }
 +    return VLC_SUCCESS;
  }
-
+ 
 -static void input_port_cb(MMAL_PORT_T *port, MMAL_BUFFER_HEADER_T *buffer)
 +
 +static void vd_prepare(vout_display_t *vd, picture_t *p_pic,
@@ -12425,12 +12428,12 @@
      vout_display_sys_t *sys = vd->sys;
 -    picture_t *picture = (picture_t *)buffer->user_data;
 +    picture_sys_t *pic_sys = picture->p_sys;
-
+ 
 -    if (picture)
 -        picture_Release(picture);
 +    if (!sys->adjust_refresh_rate || pic_sys->displayed)
 +        return;
-
+ 
 -    vlc_mutex_lock(&sys->buffer_mutex);
 -    atomic_fetch_sub(&sys->buffers_in_transit, 1);
 -    vlc_cond_signal(&sys->buffer_cond);
@@ -12440,7 +12443,7 @@
 +    picture->date += sys->phase_offset;
 +#endif
  }
-
+ 
 -static int query_resolution(vout_display_t *vd, unsigned *width, unsigned *height)
 +
 +static void vd_control_port_cb(MMAL_PORT_T *port, MMAL_BUFFER_HEADER_T *buffer)
@@ -12449,7 +12452,7 @@
 -    int ret = 0;
 +    vout_display_t *vd = (vout_display_t *)port->userdata;
 +    MMAL_STATUS_T status;
-
+ 
 -    if (vc_tv_get_display_state(&display_state) == 0) {
 -        if (display_state.state & 0xFF) {
 -            *width = display_state.display.hdmi.width;
@@ -12468,23 +12471,23 @@
 +        status = *(uint32_t *)buffer->data;
 +        msg_Err(vd, "MMAL error %"PRIx32" \"%s\"", status, mmal_status_to_string(status));
      }
-
+ 
 -    return ret;
 +    mmal_buffer_header_release(buffer);
  }
-
+ 
  static void tvservice_cb(void *callback_data, uint32_t reason, uint32_t param1, uint32_t param2)
 @@ -780,9 +1226,9 @@ static void adjust_refresh_rate(vout_dis
      double best_score, score;
      int i;
-
+ 
 -    vc_tv_get_display_state(&display_state);
 +    vc_tv_get_display_state_id(sys->display_id, &display_state);
      if(display_state.display.hdmi.mode != HDMI_MODE_OFF) {
 -        num_modes = vc_tv_hdmi_get_supported_modes_new(display_state.display.hdmi.group,
 +        num_modes = vc_tv_hdmi_get_supported_modes_new_id(sys->display_id, display_state.display.hdmi.group,
                          supported_modes, VC_TV_MAX_MODE_IDS, NULL, NULL);
-
+ 
          for (i = 0; i < num_modes; ++i) {
 @@ -810,7 +1256,7 @@ static void adjust_refresh_rate(vout_dis
          if((best_id >= 0) && (display_state.display.hdmi.mode != supported_modes[best_id].code)) {
@@ -12498,7 +12501,7 @@
 @@ -828,148 +1274,12 @@ static void adjust_refresh_rate(vout_dis
      }
  }
-
+ 
 -static void display_subpicture(vout_display_t *vd, subpicture_t *subpicture)
 -{
 -    vout_display_sys_t *sys = vd->sys;
@@ -12648,7 +12651,7 @@
 @@ -1012,32 +1322,436 @@ static void maintain_phase_sync(vout_dis
      }
  }
-
+ 
 -static void show_background(vout_display_t *vd, bool enable)
 +static void CloseMmalVout(vlc_object_t *object)
  {
@@ -13700,7 +13703,7 @@
 @@ -43,6 +43,8 @@
  # include "../android/utils.h"
  #endif
-
+ 
 +#define REQUIRE_DMA_BUF_IMPORT 1
 +
  typedef struct vlc_gl_sys_t
@@ -13709,7 +13712,7 @@
 @@ -355,6 +357,14 @@ static int Open (vlc_object_t *obj, cons
          goto error;
      }
-
+ 
 +#if REQUIRE_DMA_BUF_IMPORT
 +    if (!CheckToken(ext, "EGL_EXT_image_dma_buf_import"))
 +    {
@@ -13728,7 +13731,7 @@
      p_owner->b_waiting = false;
      vlc_cond_signal( &p_owner->wait_request );
 +    vlc_mutex_unlock( &p_owner->lock );
-
+ 
      /* If the video output is paused or slow, or if the picture pool size was
       * under-estimated (e.g. greedy video filter, buggy decoder...), the
 @@ -2005,7 +2006,6 @@ void input_DecoderDelete( decoder_t *p_d
@@ -13736,9 +13739,9 @@
      if( p_owner->p_vout != NULL )
          vout_Cancel( p_owner->p_vout, true );
 -    vlc_mutex_unlock( &p_owner->lock );
-
+ 
      vlc_join( p_owner->thread, NULL );
-
+ 
 --- a/src/misc/fourcc.c
 +++ b/src/misc/fourcc.c
 @@ -755,8 +755,13 @@ static const struct
@@ -13762,7 +13765,7 @@
 @@ -365,10 +365,30 @@ void picture_CopyProperties( picture_t *
      p_dst->b_top_field_first = p_src->b_top_field_first;
  }
-
+ 
 +static inline bool is_zc_chroma(const vlc_fourcc_t i_chroma)
 +{
 +    return i_chroma == VLC_CODEC_MMAL_OPAQUE ||
@@ -13789,15 +13792,15 @@
 +        for( int i = 0; i < p_src->i_planes; i++ )
 +            plane_CopyPixels( p_dst->p+i, p_src->p+i );
 +    }
-
+ 
      assert( p_dst->context == NULL );
-
+ 
 --- a/src/video_output/video_output.c
 +++ b/src/video_output/video_output.c
 @@ -964,6 +964,17 @@ static picture_t *ConvertRGB32AndBlend(v
      return NULL;
  }
-
+ 
 +
 +static inline bool is_zc_chroma(const vlc_fourcc_t i_chroma)
 +{
@@ -13814,7 +13817,7 @@
      vout_thread_sys_t *sys = vout->p;
 @@ -1098,7 +1109,7 @@ static int ThreadDisplayRenderPicture(vo
      }
-
+ 
      assert(vout_IsDisplayFiltered(vd) == !sys->display.use_dr);
 -    if (sys->display.use_dr && !is_direct) {
 +    if (sys->display.use_dr && !is_direct && !is_zc_chroma(todisplay->format.i_chroma)) {
diff --git a/meta-raspberrypi/dynamic-layers/multimedia-layer/recipes-multimedia/rpidistro-vlc/files/0004-mmal_exit_fix.patch b/meta-raspberrypi/dynamic-layers/multimedia-layer/recipes-multimedia/rpidistro-vlc/files/0005-mmal_exit_fix.patch
similarity index 78%
rename from meta-raspberrypi/dynamic-layers/multimedia-layer/recipes-multimedia/rpidistro-vlc/files/0004-mmal_exit_fix.patch
rename to meta-raspberrypi/dynamic-layers/multimedia-layer/recipes-multimedia/rpidistro-vlc/files/0005-mmal_exit_fix.patch
index b8ac0a0..d8fc7fb 100644
--- a/meta-raspberrypi/dynamic-layers/multimedia-layer/recipes-multimedia/rpidistro-vlc/files/0004-mmal_exit_fix.patch
+++ b/meta-raspberrypi/dynamic-layers/multimedia-layer/recipes-multimedia/rpidistro-vlc/files/0005-mmal_exit_fix.patch
@@ -1,4 +1,7 @@
-Upstream-status: Pending
+Upstream-Status: Inappropriate
+
+RPI-Distro repo forks original vlc and applies patches
+to enable raspiberry pi support.
 
 --- a/bin/vlc.c
 +++ b/bin/vlc.c
@@ -12,5 +15,5 @@
 +//    signal (SIGINT, SIG_DFL);
 +    _exit(0);
  }
-
+ 
  /*****************************************************************************
diff --git a/meta-raspberrypi/dynamic-layers/multimedia-layer/recipes-multimedia/rpidistro-vlc/files/0006-Use-packageconfig-to-detect-mmal-support.patch b/meta-raspberrypi/dynamic-layers/multimedia-layer/recipes-multimedia/rpidistro-vlc/files/0006-Use-packageconfig-to-detect-mmal-support.patch
deleted file mode 100644
index 3a2ac23..0000000
--- a/meta-raspberrypi/dynamic-layers/multimedia-layer/recipes-multimedia/rpidistro-vlc/files/0006-Use-packageconfig-to-detect-mmal-support.patch
+++ /dev/null
@@ -1,56 +0,0 @@
-From: Vincent Davis Jr <vince@underview.tech>
-Date: Fri, 07 Jan 2022 07:10:47 PM CST
-Subject: [PATCH] Use packageconfig to acquire mmal flags
-
-Need to use userland graphics libraries package files as it's best to not assume /opt/vc is where
-all libs and headers are installed per distro. Also, needed to include $BCMHOST_MMAL_LIBS variable as
-AC_CHECK_LIB(bcm_host) fails to find `vc_tv_unregister_callback_full`. Adding $BCMHOST_MMAL_LIBS uses all
-libs inside bcm_host,mmal,vcsm,openmaxil .pc files when checking for `vc_tv_unregister_callback_full`
-function.
-
-Upstream-status: Pending
-
-Signed-off-by: Vincent Davis Jr <vince@underview.tech>
-diff --git a/configure.ac b/configure.ac
-index bff220510..4d487409d 100644
---- a/configure.ac
-+++ b/configure.ac
-@@ -3483,23 +3483,25 @@ AC_ARG_ENABLE(mmal_avcodec,
-     [Use MMAL enabled avcodec libs (default disable)]))
- if test "${enable_mmal}" != "no"; then
-   VLC_SAVE_FLAGS
--  LDFLAGS="${LDFLAGS} -L/opt/vc/lib -lvchostif"
--  CPPFLAGS="${CPPFLAGS} -isystem /opt/vc/include -isystem /opt/vc/include/interface/vcos/pthreads -isystem /opt/vc/include/interface/vmcs_host/linux"
--  AC_CHECK_HEADERS(interface/mmal/mmal.h,
--    [ AC_CHECK_LIB(bcm_host, vc_tv_unregister_callback_full, [
-+  PKG_CHECK_MODULES(BCMHOST_MMAL, [bcm_host mmal vcsm openmaxil egl], [
-+    HAVE_MMAL=yes
-+    AC_CHECK_HEADERS(interface/mmal/mmal.h,
-+      [ AC_CHECK_LIB(bcm_host $BCMHOST_MMAL_LIBS, vc_tv_unregister_callback_full, [
-         have_mmal="yes"
--        VLC_ADD_PLUGIN([mmal])
--        VLC_ADD_LDFLAGS([mmal],[ -L/opt/vc/lib ])
--        VLC_ADD_CFLAGS([mmal],[ -isystem /opt/vc/include -isystem /opt/vc/include/interface/vcos/pthreads -isystem /opt/vc/include/interface/vmcs_host/linux ])
--        VLC_ADD_LIBS([mmal],[ -lbcm_host -lmmal -lmmal_core -lmmal_components -lmmal_util -lvchostif -lvchiq_arm -lvcsm ]) ], [
-+        VLC_ADD_PLUGIN([bcm_host mmal vcsm openmaxil egl])
-+        VLC_ADD_CFLAGS([bcm_host mmal vcsm openmaxil egl],[$BCMHOST_MMAL_CFLAGS])
-+        VLC_ADD_LIBS([bcm_host mmal vcsm openmaxil egl],[$BCMHOST_MMAL_LIBS]) ], [
-           AS_IF([test "${enable_mmal}" = "yes"],
-             [ AC_MSG_ERROR([Cannot find bcm library...]) ],
-             [ AC_MSG_WARN([Cannot find bcm library...]) ])
--          ],
--        [])
--    ] , [ AS_IF([test "${enable_mmal}" = "yes"],
--      [ AC_MSG_ERROR([Cannot find development headers for mmal...]) ],
--      [ AC_MSG_WARN([Cannot find development headers for mmal...]) ]) ])
-+        ],[])
-+      ],[ AS_IF([test "${enable_mmal}" = "yes"],
-+        [ AC_MSG_ERROR([Cannot find development headers for mmal...]) ],
-+        [ AC_MSG_WARN([Cannot find development headers for mmal...]) ]) ])
-+  ],:[
-+    AC_MSG_WARN([${BCMHOST_PKG_ERRORS}: userland graphics not available.])
-+    HAVE_MMAL=no
-+  ])
-   VLC_RESTORE_FLAGS
- fi
- AM_CONDITIONAL([HAVE_MMAL], [test "${have_mmal}" = "yes"])
diff --git a/meta-raspberrypi/dynamic-layers/multimedia-layer/recipes-multimedia/rpidistro-vlc/files/0005-mmal_chain.patch b/meta-raspberrypi/dynamic-layers/multimedia-layer/recipes-multimedia/rpidistro-vlc/files/0006-mmal_chain.patch
similarity index 84%
rename from meta-raspberrypi/dynamic-layers/multimedia-layer/recipes-multimedia/rpidistro-vlc/files/0005-mmal_chain.patch
rename to meta-raspberrypi/dynamic-layers/multimedia-layer/recipes-multimedia/rpidistro-vlc/files/0006-mmal_chain.patch
index abd31df..99fd03e 100644
--- a/meta-raspberrypi/dynamic-layers/multimedia-layer/recipes-multimedia/rpidistro-vlc/files/0005-mmal_chain.patch
+++ b/meta-raspberrypi/dynamic-layers/multimedia-layer/recipes-multimedia/rpidistro-vlc/files/0006-mmal_chain.patch
@@ -1,10 +1,13 @@
-Upstream-status: Pending
+Upstream-Status: Inappropriate
+
+RPI-Distro repo forks original vlc and applies patches
+to enable raspiberry pi support.
 
 --- a/modules/video_chroma/chain.c
 +++ b/modules/video_chroma/chain.c
 @@ -280,8 +280,9 @@ static int BuildTransformChain( filter_t
          return VLC_SUCCESS;
-
+ 
      /* Lets try resize+chroma first, then transform */
 -    msg_Dbg( p_filter, "Trying to build chroma+resize" );
 -    EsFormatMergeSize( &fmt_mid, &p_filter->fmt_out, &p_filter->fmt_in );
diff --git a/meta-raspberrypi/dynamic-layers/multimedia-layer/recipes-multimedia/rpidistro-vlc/files/0007-armv6.patch b/meta-raspberrypi/dynamic-layers/multimedia-layer/recipes-multimedia/rpidistro-vlc/files/0007-armv6.patch
new file mode 100644
index 0000000..64a2426
--- /dev/null
+++ b/meta-raspberrypi/dynamic-layers/multimedia-layer/recipes-multimedia/rpidistro-vlc/files/0007-armv6.patch
@@ -0,0 +1,53 @@
+Upstream-Status: Inappropriate
+
+RPI-Distro repo forks original vlc and applies patches
+to enable raspiberry pi support.
+
+--- a/modules/hw/mmal/blend_rgba_neon.S
++++ b/modules/hw/mmal/blend_rgba_neon.S
+@@ -1,10 +1,10 @@
+-        .syntax unified
+-        .arm
+-//      .thumb
+-        .text
++#include "../../arm_neon/asm.S"
+         .align 16
+         .arch armv7-a
+-        .fpu neon-vfpv4
++        .syntax unified
++#if HAVE_AS_FPU_DIRECTIVE
++        .fpu    neon-vfpv4
++#endif
+ 
+ @ blend_rgbx_rgba_neon
+ 
+--- a/modules/hw/mmal/codec.c
++++ b/modules/hw/mmal/codec.c
+@@ -29,6 +29,7 @@
+ #include <stdatomic.h>
+ 
+ #include <vlc_common.h>
++#include <vlc_cpu.h>
+ #include <vlc_plugin.h>
+ #include <vlc_codec.h>
+ #include <vlc_filter.h>
+@@ -2311,6 +2312,9 @@ static int OpenBlendMmal(vlc_object_t *o
+     filter_t * const p_filter = (filter_t *)object;
+     const vlc_fourcc_t vfcc_dst = p_filter->fmt_out.video.i_chroma;
+ 
++    if (!vlc_CPU_ARM_NEON())
++        return VLC_EGENERIC;
++
+     if (!hw_mmal_chroma_is_mmal(vfcc_dst) ||
+         !hw_mmal_vzc_subpic_fmt_valid(&p_filter->fmt_in.video))
+     {
+@@ -2421,6 +2425,9 @@ static int OpenBlendNeon(vlc_object_t *o
+     MMAL_FOURCC_T mfcc_dst = vlc_to_mmal_video_fourcc(&p_filter->fmt_out.video);
+     blend_neon_fn * blend_fn = (blend_neon_fn *)0;
+ 
++    if (!vlc_CPU_ARM_NEON())
++        return VLC_EGENERIC;
++
+     // Non-alpha RGB only for dest
+     if (vfcc_dst != VLC_CODEC_RGB32)
+         return VLC_EGENERIC;
diff --git a/meta-raspberrypi/dynamic-layers/multimedia-layer/recipes-multimedia/rpidistro-vlc/files/0007-use-vorbisidec.patch b/meta-raspberrypi/dynamic-layers/multimedia-layer/recipes-multimedia/rpidistro-vlc/files/0007-use-vorbisidec.patch
deleted file mode 100644
index 18bdc4d..0000000
--- a/meta-raspberrypi/dynamic-layers/multimedia-layer/recipes-multimedia/rpidistro-vlc/files/0007-use-vorbisidec.patch
+++ /dev/null
@@ -1,18 +0,0 @@
-* tremor provides libvorbisidec, use it instead of libvorbisdec
-
-Upstream-status: Pending
-
-Signed-off-by: Tim Orling <TicoTimo@gmail.com>
-
-Index: vlc-2.2.1/modules/codec/Makefile.am
-===================================================================
---- vlc-2.2.1.orig/modules/codec/Makefile.am
-+++ vlc-2.2.1/modules/codec/Makefile.am
-@@ -234,7 +234,7 @@ codec_LTLIBRARIES += $(LTLIBtheora)
- libtremor_plugin_la_SOURCES = codec/vorbis.c
- libtremor_plugin_la_CPPFLAGS = $(AM_CPPFLAGS) -DMODULE_NAME_IS_tremor
- libtremor_plugin_la_LDFLAGS = $(AM_LDFLAGS) -rpath '$(codecdir)'
--libtremor_plugin_la_LIBADD = -lvorbisdec -logg
-+libtremor_plugin_la_LIBADD = -lvorbisidec -logg
- EXTRA_LTLIBRARIES += libtremor_plugin.la
- codec_LTLIBRARIES += $(LTLIBtremor)
diff --git a/meta-raspberrypi/dynamic-layers/multimedia-layer/recipes-multimedia/rpidistro-vlc/files/0010-fix-numeric_limits-is-not-a-member-of-std.patch b/meta-raspberrypi/dynamic-layers/multimedia-layer/recipes-multimedia/rpidistro-vlc/files/0010-fix-numeric_limits-is-not-a-member-of-std.patch
deleted file mode 100644
index a13b337..0000000
--- a/meta-raspberrypi/dynamic-layers/multimedia-layer/recipes-multimedia/rpidistro-vlc/files/0010-fix-numeric_limits-is-not-a-member-of-std.patch
+++ /dev/null
@@ -1,35 +0,0 @@
-From: Vincent Davis Jr <vince@underview.tech>
-Date: Fri, 07 Jan 2022 07:10:47 PM CST
-Subject: [PATCH] Fix numeric limits not a member
-
-* Fixes bellow compiler issue:
-  ../../git/modules/demux/adaptive/playlist/SegmentInformation.cpp:397:23: error: 'numeric_limits' is not a member of 'std'
-  397 |     if(number == std::numeric_limits<uint64_t>::max())
-
-Upstream-status: Pending
-
-Signed-off-by: Vincent Davis Jr <vince@underview.tech>
-diff --git a/modules/demux/adaptive/playlist/SegmentInformation.cpp b/modules/demux/adaptive/playlist/SegmentInformation.cpp
-index 344e155c7..8eeb05439 100644
---- a/modules/demux/adaptive/playlist/SegmentInformation.cpp
-+++ b/modules/demux/adaptive/playlist/SegmentInformation.cpp
-@@ -34,6 +34,7 @@
-
- #include <algorithm>
- #include <cassert>
-+#include <limits>
-
- using namespace adaptive::playlist;
-
-diff --git a/modules/demux/hls/playlist/Parser.cpp b/modules/demux/hls/playlist/Parser.cpp
-index 67110e4cd..743969922 100644
---- a/modules/demux/hls/playlist/Parser.cpp
-+++ b/modules/demux/hls/playlist/Parser.cpp
-@@ -42,6 +42,7 @@
- #include <map>
- #include <cctype>
- #include <algorithm>
-+#include <limits>
-
- using namespace adaptive;
- using namespace adaptive::playlist;
diff --git a/meta-raspberrypi/dynamic-layers/multimedia-layer/recipes-multimedia/rpidistro-vlc/files/0008-fix-luaL-checkint.patch b/meta-raspberrypi/dynamic-layers/multimedia-layer/recipes-multimedia/rpidistro-vlc/files/2001-fix-luaL-checkint.patch
similarity index 98%
rename from meta-raspberrypi/dynamic-layers/multimedia-layer/recipes-multimedia/rpidistro-vlc/files/0008-fix-luaL-checkint.patch
rename to meta-raspberrypi/dynamic-layers/multimedia-layer/recipes-multimedia/rpidistro-vlc/files/2001-fix-luaL-checkint.patch
index 96b5d2d..e8990fc 100644
--- a/meta-raspberrypi/dynamic-layers/multimedia-layer/recipes-multimedia/rpidistro-vlc/files/0008-fix-luaL-checkint.patch
+++ b/meta-raspberrypi/dynamic-layers/multimedia-layer/recipes-multimedia/rpidistro-vlc/files/2001-fix-luaL-checkint.patch
@@ -1,7 +1,10 @@
 * luaL_checkint and luaL_optint were deprecated in lua 5.3
 * replacement functions are luaL_checkinteger and luaL_optinteger
 
-Upstream-status: Pending
+Upstream-Status: Inappropriate
+
+RPI-Distro repo forks original vlc and applies patches to enable
+raspiberry pi support.
 
 Signed-off-by: Tim Orling <TicoTimo@gmail.com>
 
diff --git a/meta-raspberrypi/dynamic-layers/multimedia-layer/recipes-multimedia/rpidistro-vlc/files/2002-use-vorbisidec.patch b/meta-raspberrypi/dynamic-layers/multimedia-layer/recipes-multimedia/rpidistro-vlc/files/2002-use-vorbisidec.patch
new file mode 100644
index 0000000..bfabf21
--- /dev/null
+++ b/meta-raspberrypi/dynamic-layers/multimedia-layer/recipes-multimedia/rpidistro-vlc/files/2002-use-vorbisidec.patch
@@ -0,0 +1,33 @@
+From d0a7ba506fd302ad195f79f287b5a5a154ac02a3 Mon Sep 17 00:00:00 2001
+From: Vincent Davis Jr <vince@underview.tech>
+Date: Sun, 4 Dec 2022 16:09:51 -0600
+Subject: [PATCH] tremor provides libvorbisidec, use it instead of libvorbisdec
+
+Upstream-Status: Inappropriate
+
+RPI-Distro repo forks original vlc and applies patches to enable
+raspiberry pi support.
+
+THIS PATCHES HAS BEEN REIMPLEMENTED INORDER TO APPLY PROPERLY.
+
+Signed-off-by: Tim Orling <TicoTimo@gmail.com>
+---
+ modules/codec/Makefile.am | 2 +-
+ 1 file changed, 1 insertion(+), 1 deletion(-)
+
+diff --git a/modules/codec/Makefile.am b/modules/codec/Makefile.am
+index 3dadf1119..8b6189e92 100644
+--- a/modules/codec/Makefile.am
++++ b/modules/codec/Makefile.am
+@@ -324,7 +324,7 @@ codec_LTLIBRARIES += $(LTLIBdaala)
+ libtremor_plugin_la_SOURCES = codec/vorbis.c
+ libtremor_plugin_la_CPPFLAGS = $(AM_CPPFLAGS) -DMODULE_NAME_IS_tremor
+ libtremor_plugin_la_LDFLAGS = $(AM_LDFLAGS) -rpath '$(codecdir)'
+-libtremor_plugin_la_LIBADD = -lvorbisdec -logg
++libtremor_plugin_la_LIBADD = -lvorbisidec -logg
+ EXTRA_LTLIBRARIES += libtremor_plugin.la
+ codec_LTLIBRARIES += $(LTLIBtremor)
+ 
+-- 
+2.38.1
+
diff --git a/meta-raspberrypi/dynamic-layers/multimedia-layer/recipes-multimedia/rpidistro-vlc/files/3001-configure.ac-setup-for-OE-usage.patch b/meta-raspberrypi/dynamic-layers/multimedia-layer/recipes-multimedia/rpidistro-vlc/files/3001-configure.ac-setup-for-OE-usage.patch
new file mode 100644
index 0000000..d676be3
--- /dev/null
+++ b/meta-raspberrypi/dynamic-layers/multimedia-layer/recipes-multimedia/rpidistro-vlc/files/3001-configure.ac-setup-for-OE-usage.patch
@@ -0,0 +1,124 @@
+From ddc2ea76058466b45a1acf37bed0d794cd3112a3 Mon Sep 17 00:00:00 2001
+From: Vincent Davis Jr <vince@underview.tech>
+Date: Fri, 9 Dec 2022 19:04:42 -0600
+Subject: [PATCH] configure.ac: setup for OE usage
+
+Upstream-Status: Inappropriate
+
+RPI-Distro repo forks original vlc and applies patches to enable
+raspiberry pi support.
+
+Need to use userland graphics libraries package files as it's best
+to not assume /opt/vc is where all libs and headers are installed per
+distro. Also, needed to include $BCMHOST_MMAL_LIBS variable as
+AC_CHECK_LIB(bcm_host) fails to find `vc_tv_unregister_callback_full`.
+Adding $BCMHOST_MMAL_LIBS uses all libs inside
+bcm_host.pc, mmal.pc, vcsm.pc, openmaxil.pc files when checking
+for `vc_tv_unregister_callback_full` function.
+
+Supposed to change linked version to opengl to GLESv2
+
+Ensure correct package config file is used for:
+* opencv
+* freerdp
+
+Adds Workaround for modules/codec/omxil/omxil_core.h
+   multiple definition of `pf_enable_graphic_buffers'
+   multiple definition of `pf_get_graphic_buffer_usage'
+   multiple definition of `pf_get_hal_format'
+
+Signed-off-by: Vincent Davis Jr <vince@underview.tech>
+---
+ configure.ac | 34 ++++++++++++++++++++++------------
+ 1 file changed, 22 insertions(+), 12 deletions(-)
+
+diff --git a/configure.ac b/configure.ac
+index a72dca0b6..5b8585a26 100644
+--- a/configure.ac
++++ b/configure.ac
+@@ -95,6 +95,13 @@ AS_IF([test -n "${with_binary_version}"],[
+          [Binary specific version])
+ ])
+ 
++# Workaround for modules/codec/omxil/omxil_core.h
++#   multiple definition of `pf_enable_graphic_buffers'
++#   multiple definition of `pf_get_graphic_buffer_usage'
++#   multiple definition of `pf_get_hal_format'
++AC_SUBST([AM_CXXFLAGS], [-fcommon])
++AC_SUBST([AM_CFLAGS], [-fcommon])
++
+ dnl Prevent clang from accepting unknown flags with a mere warning
+ AX_APPEND_COMPILE_FLAGS([-Werror=unknown-warning-option -Werror=invalid-command-line-argument], [CFLAGS])
+ AX_APPEND_COMPILE_FLAGS([-Werror=unknown-warning-option -Werror=invalid-command-line-argument], [CXXFLAGS])
+@@ -1900,7 +1907,7 @@ PKG_ENABLE_MODULES_VLC([BLURAY], [libbluray], [libbluray >= 0.6.2], (libbluray f
+ dnl
+ dnl  OpenCV wrapper and example filters
+ dnl
+-PKG_ENABLE_MODULES_VLC([OPENCV], [opencv_example opencv_wrapper], [opencv > 2.0], (OpenCV (computer vision) filter), [auto])
++PKG_ENABLE_MODULES_VLC([OPENCV], [opencv_example opencv_wrapper], [opencv4 >= 2.0], (OpenCV (computer vision) filter), [auto])
+ 
+ 
+ dnl
+@@ -2077,7 +2084,7 @@ PKG_ENABLE_MODULES_VLC([VNC], [vnc], [libvncclient >= 0.9.9], (VNC/rfb client su
+ 
+ dnl  RDP/Remote Desktop access module
+ dnl
+-PKG_ENABLE_MODULES_VLC([FREERDP], [rdp], [freerdp >= 1.0.1], (RDP/Remote Desktop client support) )
++PKG_ENABLE_MODULES_VLC([FREERDP], [rdp], [freerdp2 >= 1.0.1], (RDP/Remote Desktop client support) )
+ 
+ dnl
+ dnl  Real RTSP plugin
+@@ -3089,14 +3096,14 @@ PKG_CHECK_MODULES([GL], [gl], [
+ #ifdef _WIN32
+ # include <GL/glew.h>
+ #endif
+-#include <GL/gl.h>
++#include <GLES2/gl2.h>
+ ]], [
+     [int t0 = GL_TEXTURE0;]])
+   ], [
+     GL_CFLAGS=""
+     have_gl="yes"
+     AS_IF([test "${SYS}" != "mingw32"], [
+-      GL_LIBS="-lGL"
++      GL_LIBS="-lGLESv2"
+     ], [
+       GL_LIBS="-lopengl32"
+     ])
+@@ -3483,15 +3490,14 @@ AC_ARG_ENABLE(mmal_avcodec,
+     [Use MMAL enabled avcodec libs (default disable)]))
+ if test "${enable_mmal}" != "no"; then
+   VLC_SAVE_FLAGS
+-  LDFLAGS="${LDFLAGS} -L/opt/vc/lib -lvchostif"
+-  CPPFLAGS="${CPPFLAGS} -isystem /opt/vc/include -isystem /opt/vc/include/interface/vcos/pthreads -isystem /opt/vc/include/interface/vmcs_host/linux"
+-  AC_CHECK_HEADERS(interface/mmal/mmal.h,
+-    [ AC_CHECK_LIB(bcm_host, vc_tv_unregister_callback_full, [
++  PKG_CHECK_MODULES(BCMHOST_MMAL, [bcm_host mmal vcsm openmaxil egl], [
++    HAVE_MMAL=yes
++    AC_CHECK_HEADERS(interface/mmal/mmal.h,
++      [ AC_CHECK_LIB(bcm_host $BCMHOST_MMAL_LIBS, vc_tv_unregister_callback_full, [
+         have_mmal="yes"
+-        VLC_ADD_PLUGIN([mmal])
+-        VLC_ADD_LDFLAGS([mmal],[ -L/opt/vc/lib ])
+-        VLC_ADD_CFLAGS([mmal],[ -isystem /opt/vc/include -isystem /opt/vc/include/interface/vcos/pthreads -isystem /opt/vc/include/interface/vmcs_host/linux ])
+-        VLC_ADD_LIBS([mmal],[ -lbcm_host -lmmal -lmmal_core -lmmal_components -lmmal_util -lvchostif -lvchiq_arm -lvcsm ]) ], [
++        VLC_ADD_PLUGIN([bcm_host mmal vcsm openmaxil egl])
++        VLC_ADD_CFLAGS([bcm_host mmal vcsm openmaxil egl],[$BCMHOST_MMAL_CFLAGS])
++        VLC_ADD_LIBS([bcm_host mmal vcsm openmaxil egl],[$BCMHOST_MMAL_LIBS -lmmal_components]) ], [
+           AS_IF([test "${enable_mmal}" = "yes"],
+             [ AC_MSG_ERROR([Cannot find bcm library...]) ],
+             [ AC_MSG_WARN([Cannot find bcm library...]) ])
+@@ -3500,6 +3506,10 @@ if test "${enable_mmal}" != "no"; then
+     ] , [ AS_IF([test "${enable_mmal}" = "yes"],
+       [ AC_MSG_ERROR([Cannot find development headers for mmal...]) ],
+       [ AC_MSG_WARN([Cannot find development headers for mmal...]) ]) ])
++  ],:[
++    AC_MSG_WARN([${BCMHOST_PKG_ERRORS}: userland graphics not available.])
++    HAVE_MMAL=NO
++  ])
+   VLC_RESTORE_FLAGS
+ fi
+ AM_CONDITIONAL([HAVE_MMAL], [test "${have_mmal}" = "yes"])
+-- 
+2.38.1
+
diff --git a/meta-raspberrypi/dynamic-layers/multimedia-layer/recipes-multimedia/rpidistro-vlc/files/0009-fix-EGL-macro-undeclared-and-EGLImageKHR.patch b/meta-raspberrypi/dynamic-layers/multimedia-layer/recipes-multimedia/rpidistro-vlc/files/3002-fix-EGL-macro-undeclared-and-EGLImageKHR.patch
similarity index 95%
rename from meta-raspberrypi/dynamic-layers/multimedia-layer/recipes-multimedia/rpidistro-vlc/files/0009-fix-EGL-macro-undeclared-and-EGLImageKHR.patch
rename to meta-raspberrypi/dynamic-layers/multimedia-layer/recipes-multimedia/rpidistro-vlc/files/3002-fix-EGL-macro-undeclared-and-EGLImageKHR.patch
index 9bd6b41..ab72b4f 100644
--- a/meta-raspberrypi/dynamic-layers/multimedia-layer/recipes-multimedia/rpidistro-vlc/files/0009-fix-EGL-macro-undeclared-and-EGLImageKHR.patch
+++ b/meta-raspberrypi/dynamic-layers/multimedia-layer/recipes-multimedia/rpidistro-vlc/files/3002-fix-EGL-macro-undeclared-and-EGLImageKHR.patch
@@ -2,11 +2,14 @@
 Date: Fri, 07 Jan 2022 07:01:47 PM CST
 Subject: [PATCH] Fix EGL macro undeclared and EGLImageKHR
 
+Upstream-Status: Inappropriate
+
+RPI-Distro repo forks original vlc and applies patches to enable
+raspiberry pi support.
+
 * Fixes compiler issues related to EGL macro constant/enum value type not being defined
 * Updates EGLImage to EGLImageKHR
 
-Upstream-status: Pending
-
 Signed-off-by: Vincent Davis Jr <vince@underview.tech>
 diff --git a/modules/hw/mmal/converter_mmal.c b/modules/hw/mmal/converter_mmal.c
 index f31cb81d8..426af668b 100644
diff --git a/meta-raspberrypi/dynamic-layers/multimedia-layer/recipes-multimedia/rpidistro-vlc/files/3003-codec-omxil_core-replace-opt-vc-path-with-usr-lib.patch b/meta-raspberrypi/dynamic-layers/multimedia-layer/recipes-multimedia/rpidistro-vlc/files/3003-codec-omxil_core-replace-opt-vc-path-with-usr-lib.patch
new file mode 100644
index 0000000..a2dba50
--- /dev/null
+++ b/meta-raspberrypi/dynamic-layers/multimedia-layer/recipes-multimedia/rpidistro-vlc/files/3003-codec-omxil_core-replace-opt-vc-path-with-usr-lib.patch
@@ -0,0 +1,43 @@
+From 85f6603aca1d174848b42e696a4cff8af57613d6 Mon Sep 17 00:00:00 2001
+From: Vincent Davis Jr <vince@underview.tech>
+Date: Thu, 8 Dec 2022 23:38:36 -0600
+Subject: [PATCH] codec: omxil_core replace /opt/vc path with /usr/lib
+
+Upstream-Status: Inappropriate
+
+RPI-Distro repo clones original VLC and applies patches to enable
+raspiberry pi support.
+
+Configures omxil_core.c for OE usages as libbcm_host.so
+and libopenmaxil.so are located in a different location.
+
+Signed-off-by: Vincent Davis Jr <vince@underview.tech>
+---
+ modules/codec/omxil/omxil_core.c | 4 ++--
+ 1 file changed, 2 insertions(+), 2 deletions(-)
+
+diff --git a/modules/codec/omxil/omxil_core.c b/modules/codec/omxil/omxil_core.c
+index 5098f517a..5922d9034 100644
+--- a/modules/codec/omxil/omxil_core.c
++++ b/modules/codec/omxil/omxil_core.c
+@@ -56,7 +56,7 @@ static const char *ppsz_dll_list[] =
+ #if defined(USE_IOMX)
+     "libiomx.so", /* Not used when using IOMX, the lib should already be loaded */
+ #elif defined(RPI_OMX)
+-    "/opt/vc/lib/libopenmaxil.so",  /* Broadcom IL core */
++    "/usr/lib/libopenmaxil.so",  /* Broadcom IL core */
+ #elif 1
+     "libOMX_Core.so", /* TI OMAP IL core */
+     "libOmxCore.so", /* Qualcomm IL core */
+@@ -70,7 +70,7 @@ static const char *ppsz_dll_list[] =
+ #ifdef RPI_OMX
+ static const char *ppsz_extra_dll_list[] =
+ {
+-    "/opt/vc/lib/libbcm_host.so",  /* Broadcom host library */
++    "/usr/lib/libbcm_host.so",  /* Broadcom host library */
+     0
+ };
+ #endif
+-- 
+2.38.1
+
diff --git a/meta-raspberrypi/dynamic-layers/multimedia-layer/recipes-multimedia/rpidistro-vlc/files/3004-use-GLESv2-headers-over-GL-headers.patch b/meta-raspberrypi/dynamic-layers/multimedia-layer/recipes-multimedia/rpidistro-vlc/files/3004-use-GLESv2-headers-over-GL-headers.patch
new file mode 100644
index 0000000..8016ab3
--- /dev/null
+++ b/meta-raspberrypi/dynamic-layers/multimedia-layer/recipes-multimedia/rpidistro-vlc/files/3004-use-GLESv2-headers-over-GL-headers.patch
@@ -0,0 +1,60 @@
+From 377a67af6c3f7c38f6f7ba24f042ba1a6cfd3f24 Mon Sep 17 00:00:00 2001
+From: Vincent Davis Jr <vince@underview.tech>
+Date: Fri, 9 Dec 2022 00:21:43 -0600
+Subject: [PATCH] use GLESv2 headers over GL headers
+
+Upstream-Status: Inappropriate
+
+RPI-Distro repo forks original vlc and applies patches to enable
+raspiberry pi support.
+
+We utilize GLESv2 during compilation. Patches ensures
+we utilize headers for it.
+
+Signed-off-by: Vincent Davis Jr <vince@underview.tech>
+---
+ modules/video_output/opengl/converter.h | 12 +++---------
+ modules/visualization/glspectrum.c      |  4 +++-
+ 2 files changed, 6 insertions(+), 10 deletions(-)
+
+diff --git a/modules/video_output/opengl/converter.h b/modules/video_output/opengl/converter.h
+index 7000e1f38..a3fe32671 100644
+--- a/modules/video_output/opengl/converter.h
++++ b/modules/video_output/opengl/converter.h
+@@ -41,15 +41,9 @@
+ #  include <OpenGLES/ES2/glext.h>
+ # endif
+ #else /* !defined (__APPLE__) */
+-# if defined (USE_OPENGL_ES2)
+-#  include <GLES2/gl2.h>
+-#  include <GLES2/gl2ext.h>
+-# else
+-#  ifdef _WIN32
+-#   include <GL/glew.h>
+-#  endif
+-#  include <GL/gl.h>
+-# endif
++#define USE_OPENGL_ES2
++#include <GLES2/gl2.h>
++#include <GLES2/gl2ext.h>
+ #endif
+ 
+ #define VLCGL_PICTURE_MAX 128
+diff --git a/modules/visualization/glspectrum.c b/modules/visualization/glspectrum.c
+index 06f8d1bdf..470080b1a 100644
+--- a/modules/visualization/glspectrum.c
++++ b/modules/visualization/glspectrum.c
+@@ -37,7 +37,9 @@
+ #ifdef __APPLE__
+ # include <OpenGL/gl.h>
+ #else
+-# include <GL/gl.h>
++#define USE_OPENGL_ES2
++#include <GLES2/gl2.h>
++#include <GLES2/gl2ext.h>
+ #endif
+ 
+ #include <math.h>
+-- 
+2.38.1
+
diff --git a/meta-raspberrypi/dynamic-layers/multimedia-layer/recipes-multimedia/rpidistro-vlc/files/3005-modules-remove-glspectrum-usage.patch b/meta-raspberrypi/dynamic-layers/multimedia-layer/recipes-multimedia/rpidistro-vlc/files/3005-modules-remove-glspectrum-usage.patch
new file mode 100644
index 0000000..7cf210b
--- /dev/null
+++ b/meta-raspberrypi/dynamic-layers/multimedia-layer/recipes-multimedia/rpidistro-vlc/files/3005-modules-remove-glspectrum-usage.patch
@@ -0,0 +1,149 @@
+From 5f1bb5889d838719e381350b25c00ef3a75d0e02 Mon Sep 17 00:00:00 2001
+From: Vincent Davis Jr <vince@underview.tech>
+Date: Fri, 9 Dec 2022 01:07:55 -0600
+Subject: [PATCH] modules: remove glspectrum usage
+
+Upstream-Status: Inappropriate
+
+RPI-Distro repo forks original vlc and applies patches to enable
+raspiberry pi support.
+
+The glspectrum modules requries OpenGL
+while we only want to utilize GLESv2.
+
+Signed-off-by: Vincent Davis Jr <vince@underview.tech>
+---
+ modules/Makefile.in               | 24 ------------------------
+ modules/visualization/Makefile.am | 10 ----------
+ 2 files changed, 34 deletions(-)
+
+diff --git a/modules/Makefile.in b/modules/Makefile.in
+index bde45db53..c9c4342ad 100644
+--- a/modules/Makefile.in
++++ b/modules/Makefile.in
+@@ -481,7 +481,6 @@ TESTS = hpack_test$(EXEEXT) hpackenc_test$(EXEEXT) \
+ @HAVE_WIN32_FALSE@am__append_247 = $(X_LIBS) $(X_PRE_LIBS) -lX11
+ @HAVE_DARWIN_FALSE@@HAVE_WIN32_FALSE@am__append_248 = $(X_LIBS) $(X_PRE_LIBS) -lX11
+ @HAVE_EVAS_TRUE@am__append_249 = libevas_plugin.la
+-@HAVE_GL_TRUE@am__append_250 = libglspectrum_plugin.la
+ @ENABLE_SOUT_TRUE@@HAVE_GCRYPT_TRUE@am__append_251 = libaccess_output_livehttp_plugin.la
+ @ENABLE_SOUT_TRUE@am__append_252 = libaccess_output_shout_plugin.la \
+ @ENABLE_SOUT_TRUE@	libaccess_output_srt_plugin.la \
+@@ -2028,13 +2027,7 @@ libgles2_plugin_la_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CC \
+ 	$(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=link $(CCLD) \
+ 	$(libgles2_plugin_la_CFLAGS) $(CFLAGS) \
+ 	$(libgles2_plugin_la_LDFLAGS) $(LDFLAGS) -o $@
+-libglspectrum_plugin_la_DEPENDENCIES = $(am__DEPENDENCIES_1) \
+ 	$(am__DEPENDENCIES_1)
+-am_libglspectrum_plugin_la_OBJECTS = visualization/glspectrum.lo \
+-	visualization/visual/fft.lo visualization/visual/window.lo
+-libglspectrum_plugin_la_OBJECTS =  \
+-	$(am_libglspectrum_plugin_la_OBJECTS)
+-@HAVE_GL_TRUE@am_libglspectrum_plugin_la_rpath = -rpath $(visudir)
+ libglwin32_plugin_la_DEPENDENCIES = libchroma_copy.la \
+ 	$(am__DEPENDENCIES_1) $(am__DEPENDENCIES_5)
+ am__objects_23 =  \
+@@ -6507,7 +6500,6 @@ am__depfiles_remade =  \
+ 	video_splitter/$(DEPDIR)/clone.Plo \
+ 	video_splitter/$(DEPDIR)/libpanoramix_plugin_la-panoramix.Plo \
+ 	video_splitter/$(DEPDIR)/wall.Plo \
+-	visualization/$(DEPDIR)/glspectrum.Plo \
+ 	visualization/$(DEPDIR)/libgoom_plugin_la-goom.Plo \
+ 	visualization/$(DEPDIR)/libprojectm_plugin_la-projectm.Plo \
+ 	visualization/$(DEPDIR)/libvsxu_plugin_la-vsxu.Plo \
+@@ -6731,7 +6723,6 @@ SOURCES = $(liba52_plugin_la_SOURCES) $(libaa_plugin_la_SOURCES) \
+ 	$(libglconv_vaapi_x11_plugin_la_SOURCES) \
+ 	$(libglconv_vdpau_plugin_la_SOURCES) \
+ 	$(libgles2_plugin_la_SOURCES) \
+-	$(libglspectrum_plugin_la_SOURCES) \
+ 	$(libglwin32_plugin_la_SOURCES) $(libglx_plugin_la_SOURCES) \
+ 	$(libgme_plugin_la_SOURCES) $(libgnutls_plugin_la_SOURCES) \
+ 	$(libgoom_plugin_la_SOURCES) $(libgradfun_plugin_la_SOURCES) \
+@@ -7130,7 +7121,6 @@ DIST_SOURCES = $(liba52_plugin_la_SOURCES) $(libaa_plugin_la_SOURCES) \
+ 	$(libglconv_vaapi_x11_plugin_la_SOURCES) \
+ 	$(libglconv_vdpau_plugin_la_SOURCES) \
+ 	$(libgles2_plugin_la_SOURCES) \
+-	$(libglspectrum_plugin_la_SOURCES) \
+ 	$(libglwin32_plugin_la_SOURCES) $(libglx_plugin_la_SOURCES) \
+ 	$(libgme_plugin_la_SOURCES) $(libgnutls_plugin_la_SOURCES) \
+ 	$(libgoom_plugin_la_SOURCES) $(libgradfun_plugin_la_SOURCES) \
+@@ -12696,13 +12686,6 @@ libevent_thread_la_LDFLAGS = -static
+ visudir = $(pluginsdir)/visualization
+ visu_LTLIBRARIES = $(am__append_250) $(LTLIBgoom) $(LTLIBprojectm) \
+ 	libvisual_plugin.la $(LTLIBvsxu)
+-libglspectrum_plugin_la_SOURCES = \
+-	visualization/glspectrum.c \
+-	visualization/visual/fft.c visualization/visual/fft.h \
+-	visualization/visual/window.c visualization/visual/window.h \
+-	visualization/visual/window_presets.h
+-
+-libglspectrum_plugin_la_LIBADD = $(GL_LIBS) $(LIBM)
+ libgoom_plugin_la_SOURCES = visualization/goom.c
+ libgoom_plugin_la_CPPFLAGS = $(AM_CPPFLAGS) $(GOOM_CFLAGS)
+ libgoom_plugin_la_LDFLAGS = $(AM_LDFLAGS) -rpath '$(visudir)'
+@@ -15715,8 +15698,6 @@ visualization/$(am__dirstamp):
+ visualization/$(DEPDIR)/$(am__dirstamp):
+ 	@$(MKDIR_P) visualization/$(DEPDIR)
+ 	@: > visualization/$(DEPDIR)/$(am__dirstamp)
+-visualization/glspectrum.lo: visualization/$(am__dirstamp) \
+-	visualization/$(DEPDIR)/$(am__dirstamp)
+ visualization/visual/$(am__dirstamp):
+ 	@$(MKDIR_P) visualization/visual
+ 	@: > visualization/visual/$(am__dirstamp)
+@@ -15728,8 +15709,6 @@ visualization/visual/fft.lo: visualization/visual/$(am__dirstamp) \
+ visualization/visual/window.lo: visualization/visual/$(am__dirstamp) \
+ 	visualization/visual/$(DEPDIR)/$(am__dirstamp)
+ 
+-libglspectrum_plugin.la: $(libglspectrum_plugin_la_OBJECTS) $(libglspectrum_plugin_la_DEPENDENCIES) $(EXTRA_libglspectrum_plugin_la_DEPENDENCIES) 
+-	$(AM_V_CCLD)$(LINK) $(am_libglspectrum_plugin_la_rpath) $(libglspectrum_plugin_la_OBJECTS) $(libglspectrum_plugin_la_LIBADD) $(LIBS)
+ video_output/opengl/libglwin32_plugin_la-vout_helper.lo:  \
+ 	video_output/opengl/$(am__dirstamp) \
+ 	video_output/opengl/$(DEPDIR)/$(am__dirstamp)
+@@ -21420,7 +21399,6 @@ distclean-compile:
+ @AMDEP_TRUE@@am__include@ @am__quote@video_splitter/$(DEPDIR)/clone.Plo@am__quote@ # am--include-marker
+ @AMDEP_TRUE@@am__include@ @am__quote@video_splitter/$(DEPDIR)/libpanoramix_plugin_la-panoramix.Plo@am__quote@ # am--include-marker
+ @AMDEP_TRUE@@am__include@ @am__quote@video_splitter/$(DEPDIR)/wall.Plo@am__quote@ # am--include-marker
+-@AMDEP_TRUE@@am__include@ @am__quote@visualization/$(DEPDIR)/glspectrum.Plo@am__quote@ # am--include-marker
+ @AMDEP_TRUE@@am__include@ @am__quote@visualization/$(DEPDIR)/libgoom_plugin_la-goom.Plo@am__quote@ # am--include-marker
+ @AMDEP_TRUE@@am__include@ @am__quote@visualization/$(DEPDIR)/libprojectm_plugin_la-projectm.Plo@am__quote@ # am--include-marker
+ @AMDEP_TRUE@@am__include@ @am__quote@visualization/$(DEPDIR)/libvsxu_plugin_la-vsxu.Plo@am__quote@ # am--include-marker
+@@ -30324,7 +30302,6 @@ distclean: distclean-recursive
+ 	-rm -f video_splitter/$(DEPDIR)/clone.Plo
+ 	-rm -f video_splitter/$(DEPDIR)/libpanoramix_plugin_la-panoramix.Plo
+ 	-rm -f video_splitter/$(DEPDIR)/wall.Plo
+-	-rm -f visualization/$(DEPDIR)/glspectrum.Plo
+ 	-rm -f visualization/$(DEPDIR)/libgoom_plugin_la-goom.Plo
+ 	-rm -f visualization/$(DEPDIR)/libprojectm_plugin_la-projectm.Plo
+ 	-rm -f visualization/$(DEPDIR)/libvsxu_plugin_la-vsxu.Plo
+@@ -31722,7 +31699,6 @@ maintainer-clean: maintainer-clean-recursive
+ 	-rm -f video_splitter/$(DEPDIR)/clone.Plo
+ 	-rm -f video_splitter/$(DEPDIR)/libpanoramix_plugin_la-panoramix.Plo
+ 	-rm -f video_splitter/$(DEPDIR)/wall.Plo
+-	-rm -f visualization/$(DEPDIR)/glspectrum.Plo
+ 	-rm -f visualization/$(DEPDIR)/libgoom_plugin_la-goom.Plo
+ 	-rm -f visualization/$(DEPDIR)/libprojectm_plugin_la-projectm.Plo
+ 	-rm -f visualization/$(DEPDIR)/libvsxu_plugin_la-vsxu.Plo
+diff --git a/modules/visualization/Makefile.am b/modules/visualization/Makefile.am
+index 10619e030..aafc97f87 100644
+--- a/modules/visualization/Makefile.am
++++ b/modules/visualization/Makefile.am
+@@ -1,16 +1,6 @@
+ visudir = $(pluginsdir)/visualization
+ visu_LTLIBRARIES =
+ 
+-libglspectrum_plugin_la_SOURCES = \
+-	visualization/glspectrum.c \
+-	visualization/visual/fft.c visualization/visual/fft.h \
+-	visualization/visual/window.c visualization/visual/window.h \
+-	visualization/visual/window_presets.h
+-libglspectrum_plugin_la_LIBADD = $(GL_LIBS) $(LIBM)
+-if HAVE_GL
+-visu_LTLIBRARIES += libglspectrum_plugin.la
+-endif
+-
+ libgoom_plugin_la_SOURCES = visualization/goom.c
+ libgoom_plugin_la_CPPFLAGS = $(AM_CPPFLAGS) $(GOOM_CFLAGS)
+ libgoom_plugin_la_LDFLAGS = $(AM_LDFLAGS) -rpath '$(visudir)'
+-- 
+2.38.1
+
diff --git a/meta-raspberrypi/dynamic-layers/multimedia-layer/recipes-multimedia/rpidistro-vlc/files/3006-codec-omxil_core.h-fix-multiple-definition-of.patch b/meta-raspberrypi/dynamic-layers/multimedia-layer/recipes-multimedia/rpidistro-vlc/files/3006-codec-omxil_core.h-fix-multiple-definition-of.patch
new file mode 100644
index 0000000..e680c88
--- /dev/null
+++ b/meta-raspberrypi/dynamic-layers/multimedia-layer/recipes-multimedia/rpidistro-vlc/files/3006-codec-omxil_core.h-fix-multiple-definition-of.patch
@@ -0,0 +1,43 @@
+From fd4d233757cc46cd89f68b45ec4b059940dd84ae Mon Sep 17 00:00:00 2001
+From: Vincent Davis Jr <vince@underview.tech>
+Date: Fri, 9 Dec 2022 19:58:11 -0600
+Subject: [PATCH] codec: omxil_core.h fix multiple definition of
+
+Upstream-Status: Inappropriate
+
+RPI-Distro repo forks original vlc and applies patches
+to enable raspiberry pi support.
+
+Issue occurs during compilation as
+* pf_enable_graphic_buffers
+* pf_get_graphic_buffer_usage
+* pf_get_hal_format
+
+Apears to be defined multiple times as the omxil_core.h
+is included in multiple files.
+
+Signed-off-by: Vincent Davis Jr <vince@underview.tech>
+---
+ modules/codec/omxil/omxil_core.h | 6 +++---
+ 1 file changed, 3 insertions(+), 3 deletions(-)
+
+diff --git a/modules/codec/omxil/omxil_core.h b/modules/codec/omxil/omxil_core.h
+index ac3db510b..f6e42f5ed 100644
+--- a/modules/codec/omxil/omxil_core.h
++++ b/modules/codec/omxil/omxil_core.h
+@@ -34,9 +34,9 @@ extern OMX_ERRORTYPE (*pf_component_enum)(OMX_STRING, OMX_U32, OMX_U32);
+ extern OMX_ERRORTYPE (*pf_get_roles_of_component)(OMX_STRING, OMX_U32 *, OMX_U8 **);
+ 
+ /* Extra IOMX android functions. Can be NULL if we don't link with libiomx */
+-OMX_ERRORTYPE (*pf_enable_graphic_buffers)(OMX_HANDLETYPE, OMX_U32, OMX_BOOL);
+-OMX_ERRORTYPE (*pf_get_graphic_buffer_usage)(OMX_HANDLETYPE, OMX_U32, OMX_U32*);
+-OMX_ERRORTYPE (*pf_get_hal_format) (const char *, int *);
++extern OMX_ERRORTYPE (*pf_enable_graphic_buffers)(OMX_HANDLETYPE, OMX_U32, OMX_BOOL);
++extern OMX_ERRORTYPE (*pf_get_graphic_buffer_usage)(OMX_HANDLETYPE, OMX_U32, OMX_U32*);
++extern OMX_ERRORTYPE (*pf_get_hal_format) (const char *, int *);
+ 
+ int InitOmxCore(vlc_object_t *p_this);
+ void DeinitOmxCore(void);
+-- 
+2.38.1
+
diff --git a/meta-raspberrypi/dynamic-layers/multimedia-layer/recipes-multimedia/rpidistro-vlc/files/3007-remove-xorg-related-link-libs.patch b/meta-raspberrypi/dynamic-layers/multimedia-layer/recipes-multimedia/rpidistro-vlc/files/3007-remove-xorg-related-link-libs.patch
new file mode 100644
index 0000000..a0487fa
--- /dev/null
+++ b/meta-raspberrypi/dynamic-layers/multimedia-layer/recipes-multimedia/rpidistro-vlc/files/3007-remove-xorg-related-link-libs.patch
@@ -0,0 +1,36 @@
+From 34e4f4dad923095989ccb0ab8efb883c592bdbfd Mon Sep 17 00:00:00 2001
+From: Vincent Davis Jr <vince@underview.tech>
+Date: Fri, 9 Dec 2022 20:04:27 -0600
+Subject: [PATCH] remove xorg related link libs
+
+Upstream-Status: Inappropriate
+
+RPI-Distro repo forks original vlc and applies patches
+to enable raspiberry pi support.
+
+If x11 isn't defined in DISTRO_FEATURES
+required xorg related libs are not included
+in recipe-sysroot resulting in compilation
+failure.
+
+Signed-off-by: Vincent Davis Jr <vince@underview.tech>
+---
+ modules/hw/mmal/Makefile.am | 2 +-
+ 1 file changed, 1 insertion(+), 1 deletion(-)
+
+diff --git a/modules/hw/mmal/Makefile.am b/modules/hw/mmal/Makefile.am
+index 4abe68e2e..86dad2c2d 100644
+--- a/modules/hw/mmal/Makefile.am
++++ b/modules/hw/mmal/Makefile.am
+@@ -8,7 +8,7 @@ libmmal_vout_plugin_la_SOURCES = vout.c mmal_cma.c mmal_picture.c subpic.c\
+   mmal_cma.h mmal_picture.h subpic.h transform_ops.h\
+   mmal_piccpy_neon.S
+ libmmal_vout_plugin_la_CFLAGS = $(AM_CFLAGS)
+-libmmal_vout_plugin_la_LDFLAGS = $(AM_LDFLAGS) -lm -lX11 -lXrandr
++libmmal_vout_plugin_la_LDFLAGS = $(AM_LDFLAGS) -lm
+ libmmal_vout_plugin_la_LIBADD = $(LIBS_mmal)
+ mmal_LTLIBRARIES = libmmal_vout_plugin.la
+ 
+-- 
+2.38.1
+
diff --git a/meta-raspberrypi/dynamic-layers/multimedia-layer/recipes-multimedia/rpidistro-vlc/files/3008-vo-Makefile.am-exclude-libgl_plugin.patch b/meta-raspberrypi/dynamic-layers/multimedia-layer/recipes-multimedia/rpidistro-vlc/files/3008-vo-Makefile.am-exclude-libgl_plugin.patch
new file mode 100644
index 0000000..8806c80
--- /dev/null
+++ b/meta-raspberrypi/dynamic-layers/multimedia-layer/recipes-multimedia/rpidistro-vlc/files/3008-vo-Makefile.am-exclude-libgl_plugin.patch
@@ -0,0 +1,97 @@
+From 28917a258a4173af0abda0eef7faef5cbf95f123 Mon Sep 17 00:00:00 2001
+From: Vincent Davis Jr <vince@underview.tech>
+Date: Fri, 9 Dec 2022 21:28:48 -0600
+Subject: [PATCH] vo: Makefile.am exclude libgl_plugin
+
+Upstream-Status: Inappropriate
+
+RPI-Distro repo forks original vlc and applies patches
+to enable raspiberry pi support.
+
+In the situation where opengl isn't included in
+DISTRO_FEATURES. We need to exclude the opengl
+vout plugin from being built.
+
+Signed-off-by: Vincent Davis Jr <vince@underview.tech>
+---
+ modules/video_output/Makefile.am | 64 --------------------------------
+ 1 file changed, 64 deletions(-)
+
+diff --git a/modules/video_output/Makefile.am b/modules/video_output/Makefile.am
+index 78c06cfc4..14a330e68 100644
+--- a/modules/video_output/Makefile.am
++++ b/modules/video_output/Makefile.am
+@@ -57,70 +57,6 @@ if HAVE_TVOS
+ vout_LTLIBRARIES += libvout_ios_plugin.la libglconv_cvpx_plugin.la
+ endif
+ 
+-### OpenGL ###
+-libgles2_plugin_la_SOURCES = $(OPENGL_COMMONSOURCES) video_output/opengl/display.c
+-libgles2_plugin_la_CFLAGS = $(AM_CFLAGS) $(GLES2_CFLAGS) -DUSE_OPENGL_ES2 $(OPENGL_COMMONCLFAGS)
+-libgles2_plugin_la_LIBADD = $(GLES2_LIBS) $(LIBM) $(OPENGL_COMMONLIBS)
+-libgles2_plugin_la_LDFLAGS = $(AM_LDFLAGS) -rpath '$(voutdir)'
+-
+-EXTRA_LTLIBRARIES += libgles2_plugin.la
+-vout_LTLIBRARIES += $(LTLIBgles2)
+-
+-libgl_plugin_la_SOURCES = $(OPENGL_COMMONSOURCES) video_output/opengl/display.c
+-libgl_plugin_la_CFLAGS = $(AM_CFLAGS) $(GL_CFLAGS) $(OPENGL_COMMONCLFAGS)
+-libgl_plugin_la_LIBADD = $(LIBM) $(OPENGL_COMMONLIBS)
+-if HAVE_WIN32
+-libgl_plugin_la_CFLAGS += -DHAVE_GL_CORE_SYMBOLS
+-libgl_plugin_la_LIBADD += $(GL_LIBS)
+-endif
+-
+-libglconv_vaapi_wl_plugin_la_SOURCES = video_output/opengl/converter_vaapi.c \
+-	video_output/opengl/converter.h \
+-	hw/vaapi/vlc_vaapi.c hw/vaapi/vlc_vaapi.h
+-libglconv_vaapi_wl_plugin_la_CFLAGS = $(AM_CFLAGS) $(GL_CFLAGS) -DHAVE_VA_WL $(LIBVA_WL_CFLAGS)
+-libglconv_vaapi_wl_plugin_la_LIBADD = $(LIBVA_LIBS) $(LIBVA_EGL_LIBS) \
+-	$(LIBVA_WL_LIBS)
+-
+-libglconv_vaapi_x11_plugin_la_SOURCES = $(libglconv_vaapi_wl_plugin_la_SOURCES)
+-libglconv_vaapi_x11_plugin_la_CFLAGS = $(AM_CFLAGS) -DHAVE_VA_X11
+-libglconv_vaapi_x11_plugin_la_LIBADD = $(LIBVA_LIBS) $(LIBVA_EGL_LIBS) \
+-	$(LIBVA_X11_LIBS) $(X_LIBS) $(X_PRE_LIBS) -lX11
+-
+-libglconv_vaapi_drm_plugin_la_SOURCES = $(libglconv_vaapi_wl_plugin_la_SOURCES)
+-libglconv_vaapi_drm_plugin_la_CFLAGS = $(AM_CFLAGS) -DHAVE_VA_DRM
+-libglconv_vaapi_drm_plugin_la_LIBADD = $(LIBVA_LIBS) $(LIBVA_EGL_LIBS) \
+-	$(LIBVA_DRM_LIBS)
+-
+-libglconv_vdpau_plugin_la_SOURCES = video_output/opengl/converter_vdpau.c \
+-	video_output/opengl/converter.h hw/vdpau/vlc_vdpau.h
+-libglconv_vdpau_plugin_la_CFLAGS = $(AM_CFLAGS) $(VDPAU_CFLAGS)
+-libglconv_vdpau_plugin_la_LIBADD = $(LIBDL) libvlc_vdpau.la $(X_LIBS) $(X_PRE_LIBS) -lX11
+-
+-if HAVE_GL
+-vout_LTLIBRARIES += libgl_plugin.la
+-if HAVE_EGL
+-if HAVE_VAAPI
+-if HAVE_WAYLAND_EGL
+-if HAVE_VAAPI_WL
+-vout_LTLIBRARIES += libglconv_vaapi_wl_plugin.la
+-endif
+-endif
+-if HAVE_XCB
+-if HAVE_VAAPI_X11
+-vout_LTLIBRARIES += libglconv_vaapi_x11_plugin.la
+-endif
+-endif
+-if HAVE_VAAPI_DRM
+-vout_LTLIBRARIES += libglconv_vaapi_drm_plugin.la
+-endif
+-endif
+-endif # HAVE_EGL
+-
+-if HAVE_VDPAU
+-vout_LTLIBRARIES += libglconv_vdpau_plugin.la
+-endif
+-endif # HAVE_GL
+-
+ ### XCB ###
+ libvlc_xcb_events_la_SOURCES = \
+ 	video_output/xcb/events.c video_output/xcb/events.h
+-- 
+2.38.1
+
diff --git a/meta-raspberrypi/dynamic-layers/multimedia-layer/recipes-multimedia/rpidistro-vlc/files/3009-vo-converter_vaapi-Fix-EGL-macro-undeclared.patch b/meta-raspberrypi/dynamic-layers/multimedia-layer/recipes-multimedia/rpidistro-vlc/files/3009-vo-converter_vaapi-Fix-EGL-macro-undeclared.patch
new file mode 100644
index 0000000..0f28199
--- /dev/null
+++ b/meta-raspberrypi/dynamic-layers/multimedia-layer/recipes-multimedia/rpidistro-vlc/files/3009-vo-converter_vaapi-Fix-EGL-macro-undeclared.patch
@@ -0,0 +1,59 @@
+From 35276c4b02b9114436108e74727d192f1e21f239 Mon Sep 17 00:00:00 2001
+From: Vincent Davis Jr <vince@underview.tech>
+Date: Fri, 9 Dec 2022 23:31:33 -0600
+Subject: [PATCH] vo: converter_vaapi Fix EGL macro undeclared
+
+Upstream-Status: Inappropriate
+
+RPI-Distro repo forks original vlc and applies patches to enable
+raspiberry pi support.
+
+Fixes compiler issues related to EGL macro constant/enum value type
+not being defined
+
+Signed-off-by: Vincent Davis Jr <vince@underview.tech>
+---
+ modules/video_output/opengl/converter_vaapi.c | 27 +++++++++++++++++++
+ 1 file changed, 27 insertions(+)
+
+diff --git a/modules/video_output/opengl/converter_vaapi.c b/modules/video_output/opengl/converter_vaapi.c
+index cd842f711..59245fe4c 100644
+--- a/modules/video_output/opengl/converter_vaapi.c
++++ b/modules/video_output/opengl/converter_vaapi.c
+@@ -55,6 +55,33 @@
+ 
+ #define DRM_FORMAT_MOD_INVALID  fourcc_mod_code(NONE, DRM_FORMAT_RESERVED)
+ 
++#define EGL_LINUX_DMA_BUF_EXT           0x3270
++#define EGL_LINUX_DRM_FOURCC_EXT        0x3271
++#define EGL_DMA_BUF_PLANE0_FD_EXT       0x3272
++#define EGL_DMA_BUF_PLANE0_OFFSET_EXT   0x3273
++#define EGL_DMA_BUF_PLANE0_PITCH_EXT    0x3274
++#define EGL_DMA_BUF_PLANE1_FD_EXT       0x3275
++#define EGL_DMA_BUF_PLANE1_OFFSET_EXT   0x3276
++#define EGL_DMA_BUF_PLANE1_PITCH_EXT    0x3277
++#define EGL_DMA_BUF_PLANE2_FD_EXT       0x3278
++#define EGL_DMA_BUF_PLANE2_OFFSET_EXT   0x3279
++#define EGL_DMA_BUF_PLANE2_PITCH_EXT    0x327A
++#define EGL_YUV_COLOR_SPACE_HINT_EXT    0x327B
++#define EGL_SAMPLE_RANGE_HINT_EXT       0x327C
++#define EGL_YUV_CHROMA_HORIZONTAL_SITING_HINT_EXT  0x327D
++#define EGL_YUV_CHROMA_VERTICAL_SITING_HINT_EXT    0x327E
++#define EGL_DMA_BUF_PLANE0_MODIFIER_LO_EXT 0x3443
++#define EGL_DMA_BUF_PLANE0_MODIFIER_HI_EXT 0x3444
++#define EGL_DMA_BUF_PLANE1_MODIFIER_LO_EXT 0x3445
++#define EGL_DMA_BUF_PLANE1_MODIFIER_HI_EXT 0x3446
++#define EGL_DMA_BUF_PLANE2_MODIFIER_LO_EXT 0x3447
++#define EGL_DMA_BUF_PLANE2_MODIFIER_HI_EXT 0x3448
++#define EGL_DMA_BUF_PLANE3_FD_EXT          0x3440
++#define EGL_DMA_BUF_PLANE3_OFFSET_EXT      0x3441
++#define EGL_DMA_BUF_PLANE3_PITCH_EXT       0x3442
++#define EGL_DMA_BUF_PLANE3_MODIFIER_LO_EXT 0x3449
++#define EGL_DMA_BUF_PLANE3_MODIFIER_HI_EXT 0x344A
++
+ struct priv
+ {
+     struct vlc_vaapi_instance *vainst;
+-- 
+2.38.1
+
diff --git a/meta-raspberrypi/dynamic-layers/multimedia-layer/recipes-multimedia/rpidistro-vlc/rpidistro-vlc_3.0.12.bb b/meta-raspberrypi/dynamic-layers/multimedia-layer/recipes-multimedia/rpidistro-vlc/rpidistro-vlc_3.0.17.bb
similarity index 69%
rename from meta-raspberrypi/dynamic-layers/multimedia-layer/recipes-multimedia/rpidistro-vlc/rpidistro-vlc_3.0.12.bb
rename to meta-raspberrypi/dynamic-layers/multimedia-layer/recipes-multimedia/rpidistro-vlc/rpidistro-vlc_3.0.17.bb
index b244dde..2653b28 100644
--- a/meta-raspberrypi/dynamic-layers/multimedia-layer/recipes-multimedia/rpidistro-vlc/rpidistro-vlc_3.0.12.bb
+++ b/meta-raspberrypi/dynamic-layers/multimedia-layer/recipes-multimedia/rpidistro-vlc/rpidistro-vlc_3.0.17.bb
@@ -9,17 +9,25 @@
     git://git@github.com/RPi-Distro/vlc;protocol=https;branch=buster-rpt \
     file://0001-configure-fix-linking-on-RISC-V-ISA.patch \
     file://0002-Revert-configure-Require-libmodplug-0.8.9.patch \
-    file://0003-mmal_20.patch \
-    file://0004-mmal_exit_fix.patch \
-    file://0005-mmal_chain.patch \
-    file://0006-Use-packageconfig-to-detect-mmal-support.patch \
-    file://0007-use-vorbisidec.patch \
-    file://0008-fix-luaL-checkint.patch \
-    file://0009-fix-EGL-macro-undeclared-and-EGLImageKHR.patch \
-    file://0010-fix-numeric_limits-is-not-a-member-of-std.patch \
-"
+    file://0003-CVE-2022-41325.patch \
+    file://0004-mmal_20.patch \
+    file://0005-mmal_exit_fix.patch \
+    file://0006-mmal_chain.patch \
+    file://0007-armv6.patch \
+    file://2001-fix-luaL-checkint.patch \
+    file://2002-use-vorbisidec.patch \
+    file://3001-configure.ac-setup-for-OE-usage.patch \
+    file://3002-fix-EGL-macro-undeclared-and-EGLImageKHR.patch \
+    file://3003-codec-omxil_core-replace-opt-vc-path-with-usr-lib.patch \
+    file://3004-use-GLESv2-headers-over-GL-headers.patch \
+    file://3005-modules-remove-glspectrum-usage.patch \
+    file://3006-codec-omxil_core.h-fix-multiple-definition-of.patch \
+    ${@bb.utils.contains('DISTRO_FEATURES', 'x11', '', 'file://3007-remove-xorg-related-link-libs.patch', d)} \
+    ${@bb.utils.contains('DISTRO_FEATURES', 'opengl', '', 'file://3008-vo-Makefile.am-exclude-libgl_plugin.patch', d)} \
+    file://3009-vo-converter_vaapi-Fix-EGL-macro-undeclared.patch \
+    "
 
-SRCREV = "f7fd69f12a3b89d03768fa3bd468e8f33cd1dc7c"
+SRCREV = "b276eb0d7bc3213363e97dbb681ef7c927be6c73"
 
 S = "${WORKDIR}/git"
 
@@ -37,24 +45,29 @@
     --enable-run-as-root \
     --enable-xvideo \
     --disable-lua \
-    --disable-screen --disable-caca \
+    --disable-screen \
+    --disable-caca \
     --enable-vlm \
     --enable-tremor \
-    --disable-aa --disable-faad \
+    --disable-aa \
+    --disable-faad \
     --enable-dbus \
     --without-contrib \
     --without-kde-solid \
     --enable-realrtsp \
     --disable-libtar \
     --enable-avcodec \
-"
+    --disable-css \
+    "
 
 PACKAGECONFIG ?= "\
     ${@bb.utils.contains('DISTRO_FEATURES', 'x11', 'x11', '', d)} \
     ${@bb.utils.contains('MACHINE_FEATURES', 'vc4graphics', '', 'mmal', d)} \
-    live555 dv1394 notify fontconfig fluidsynth freetype dvdread png udev \
-    x264 alsa harfbuzz jack neon fribidi dvbpsi a52 v4l2 gles2 \
-"
+    ${@bb.utils.contains('DISTRO_FEATURES', 'opengl', 'gles2', '', d)} \
+    ${@bb.utils.contains_any('DISTRO_FEATURES', 'x11', 'notify', '', d)} \
+    live555 dv1394 fontconfig fluidsynth freetype png udev \
+    x264 alsa harfbuzz jack neon fribidi dvbpsi a52 v4l2 \
+    "
 
 PACKAGECONFIG[mmal] = "--enable-omxil --enable-omxil-vout --enable-rpi-omxil --enable-mmal --enable-mmal-avcodec,,userland"
 PACKAGECONFIG[x264] = "--enable-x264,--disable-x264,x264"
@@ -65,13 +78,13 @@
 PACKAGECONFIG[libass] = "--enable-libass,--disable-libass,libass"
 PACKAGECONFIG[postproc] = "--enable-postproc,--disable-postproc,libpostproc"
 PACKAGECONFIG[libva] = "--enable-libva,--disable-libva,libva"
-PACKAGECONFIG[opencv] = "--enable-opencv,--disable-opencv,opencv"
+#PACKAGECONFIG[opencv] = "--enable-opencv,--disable-opencv,opencv"
 PACKAGECONFIG[speex] = "--enable-speex,--disable-speex,speex"
 PACKAGECONFIG[gstreamer] = "--enable-gst-decode,--disable-gst-decode,gstreamer1.0 gstreamer1.0-plugins-base gstreamer1.0-plugins-bad"
 PACKAGECONFIG[vpx] = "--enable-vpx,--disable-vpx, libvpx"
-PACKAGECONFIG[freerdp] = "--enable-freerdp,--disable-freerdp, freerdp"
+#PACKAGECONFIG[freerdp] = "--enable-freerdp,--disable-freerdp, freerdp"
 PACKAGECONFIG[dvbpsi] = "--enable-dvbpsi,--disable-dvbpsi, libdvbpsi"
-PACKAGECONFIG[samba] = "--enable-smbclient,--disable-smbclient, samba"
+#PACKAGECONFIG[samba] = "--enable-smbclient,--disable-smbclient, samba"
 PACKAGECONFIG[upnp] = "--enable-upnp,--disable-upnp,libupnp"
 PACKAGECONFIG[dvdnav] = "--enable-dvdnav,--disable-dvdnav,libdvdnav libdvdcss"
 PACKAGECONFIG[sftp] = "--enable-sftp,--disable-sftp,libssh2"
@@ -84,14 +97,14 @@
 PACKAGECONFIG[notify] = "--enable-notify,--disable-notify, libnotify gtk+3"
 PACKAGECONFIG[fontconfig] = "--enable-fontconfig,--disable-fontconfig, fontconfig"
 PACKAGECONFIG[freetype] = "--enable-freetype,--disable-freetype, freetype"
-PACKAGECONFIG[dvdread] = "--enable-dvdread,--disable-dvdread, libdvdread libdvdcss"
+#PACKAGECONFIG[dvdread] = "--enable-dvdread,--disable-dvdread, libdvdread libdvdcss"
 PACKAGECONFIG[vnc] = "--enable-vnc,--disable-vnc, libvncserver"
-PACKAGECONFIG[x11] = "--with-x --enable-xcb,--without-x --disable-xcb,  xcb-util-keysyms libxpm libxinerama"
+PACKAGECONFIG[x11] = "--with-x --enable-xcb,--without-x --disable-xcb, xcb-util-keysyms libxpm libxinerama"
 PACKAGECONFIG[png] = "--enable-png,--disable-png,libpng"
-PACKAGECONFIG[vdpau] = "--enable-vdpau,--disable-vdpau,libvdpau"
-PACKAGECONFIG[wayland] = "--enable-wayland,--disable-wayland,wayland wayland-native"
+#PACKAGECONFIG[vdpau] = "--enable-vdpau,--disable-vdpau,libvdpau"
+#PACKAGECONFIG[wayland] = "--enable-wayland,--disable-wayland,wayland wayland-native"
 PACKAGECONFIG[gles2] = "--enable-gles2,--disable-gles2,virtual/libgles2"
-PACKAGECONFIG[dca] = "--enable-dca,,"
+#PACKAGECONFIG[dca] = "--enable-dca,--disable-dca,libdca"
 PACKAGECONFIG[fribidi] = "--enable-fribidi,,fribidi"
 PACKAGECONFIG[gnutls] = "--enable-gnutls,,gnutls"
 PACKAGECONFIG[fluidsynth] = "--enable-fluidsynth,,fluidsynth"
@@ -105,25 +118,15 @@
 PACKAGECONFIG[sdl-image] = "--enable-sdl-image,,libsdl-image"
 PACKAGECONFIG[v4l2] = "--enable-v4l2,,v4l-utils"
 
-# Workaround for modules/codec/omxil/omxil_core.h
-#   multiple definition of `pf_enable_graphic_buffers'
-#   multiple definition of `pf_get_graphic_buffer_usage'
-#   multiple definition of `pf_get_hal_format'
-TARGET_CFLAGS:append = " -fcommon"
-TARGET_CXXFLAGS:append = " -fcommon"
+TARGET_CFLAGS:append = " -I${STAGING_INCDIR}/drm"
+TARGET_LDFLAGS:append = " ${@bb.utils.contains('DISTRO_FEATURES', 'opengl', '-lGLESv2', '', d)}"
 
 # Ensures the --enable-mmal-avcodec flag is available for usage
 do_configure:prepend() {
     olddir=`pwd`
     cd ${S}
     ./bootstrap
-    cd $olddir
-}
-
-do_configure:append() {
-    # https://forums.raspberrypi.com/viewtopic.php?p=1601535
-    sed -i "/GLAPI void APIENTRY glShaderSource (/d" ${STAGING_INCDIR}/GL/glext.h
-    #sed -i -e s:'${top_builddir_slash}libtool':'${top_builddir_slash}'${TARGET_SYS}-libtool:g ${B}/doltlibtool
+    cd $olddir 
 }
 
 # This recipe packages vlc as a library as well, so qt4 dependencies
@@ -140,20 +143,20 @@
     ${datadir}/vlc \
     ${datadir}/icons \
     ${datadir}/metainfo/vlc.appdata.xml \
-"
+    "
 
 FILES:${PN}-dbg += "\
     ${libdir}/vlc/*/.debug \
     ${libdir}/vlc/plugins/*/.debug \
-"
+    "
 
 FILES:${PN}-staticdev += "\
     ${libdir}/vlc/plugins/*/*.a \
     ${libdir}/vlc/libcompat.a \
-"
+    "
 
 # Only enable it for rpi class of machines
 COMPATIBLE_HOST = "null"
-COMPATIBLE_HOST:rpi = "'(.*)'"
+COMPATIBLE_HOST:rpi = "(.*)"
 
 INSANE_SKIP:${PN} = "dev-so"
