upnp: remove m_server_list_lock, p_server_list is already protected by s_lock
[vlc.git] / modules / video_filter / transform.c
index 954b96b..cec6ebd 100644 (file)
 /*****************************************************************************
  * transform.c : transform image module for vlc
  *****************************************************************************
- * Copyright (C) 2000-2004 VideoLAN
- * $Id$
+ * Copyright (C) 2000-2006 VLC authors and VideoLAN
+ * Copyright (C) 2010 Laurent Aimar
+ * Copyright (C) 2012 RĂ©mi Denis-Courmont
  *
  * Authors: Samuel Hocevar <sam@zoy.org>
+ *          Laurent Aimar <fenrir _AT_ videolan _DOT_ org>
  *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2.1 of the License, or
  * (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
  *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  *****************************************************************************/
 
 /*****************************************************************************
  * Preamble
  *****************************************************************************/
-#include <stdlib.h>                                      /* malloc(), free() */
-#include <string.h>
 
-#include <vlc/vlc.h>
-#include <vlc/vout.h>
+#ifdef HAVE_CONFIG_H
+#   include "config.h"
+#endif
+#include <limits.h>
 
-#include "filter_common.h"
-
-#define TRANSFORM_MODE_HFLIP   1
-#define TRANSFORM_MODE_VFLIP   2
-#define TRANSFORM_MODE_90      3
-#define TRANSFORM_MODE_180     4
-#define TRANSFORM_MODE_270     5
-
-/*****************************************************************************
- * Local prototypes
- *****************************************************************************/
-static int  Create    ( vlc_object_t * );
-static void Destroy   ( vlc_object_t * );
-
-static int  Init      ( vout_thread_t * );
-static void End       ( vout_thread_t * );
-static void Render    ( vout_thread_t *, picture_t * );
-
-static int  SendEvents( vlc_object_t *, char const *,
-                        vlc_value_t, vlc_value_t, void * );
+#include <vlc_common.h>
+#include <vlc_plugin.h>
+#include <vlc_filter.h>
 
 /*****************************************************************************
  * Module descriptor
  *****************************************************************************/
-#define TYPE_TEXT N_("Transform type")
-#define TYPE_LONGTEXT N_("One of '90', '180', '270', 'hflip' and 'vflip'")
+static int  Open (vlc_object_t *);
+static void Close(vlc_object_t *);
 
-static char *type_list[] = { "90", "180", "270", "hflip", "vflip" };
-static char *type_list_text[] = { N_("Rotate by 90 degrees"),
-  N_("Rotate by 180 degrees"), N_("Rotate by 270 degrees"),
-  N_("Flip horizontally"), N_("Flip vertically") };
+#define CFG_PREFIX "transform-"
 
-vlc_module_begin();
-    set_description( _("Video transformation filter") );
-    set_shortname( N_("Transformation"));
-    set_capability( "video filter", 0 );
-    set_category( CAT_VIDEO );
-    set_subcategory( SUBCAT_VIDEO_VFILTER );
-
-    add_string( "transform-type", "90", NULL,
-                          TYPE_TEXT, TYPE_LONGTEXT, VLC_FALSE);
-        change_string_list( type_list, type_list_text, 0);
-
-    add_shortcut( "transform" );
-    set_callbacks( Create, Destroy );
-vlc_module_end();
+#define TYPE_TEXT N_("Transform type")
+static const char * const type_list[] = { "90", "180", "270",
+    "hflip", "vflip", "transpose", "antitranspose" };
+static const char * const type_list_text[] = { N_("Rotate by 90 degrees"),
+    N_("Rotate by 180 degrees"), N_("Rotate by 270 degrees"),
+    N_("Flip horizontally"), N_("Flip vertically"),
+    N_("Transpose"), N_("Anti-transpose") };
+
+vlc_module_begin()
+    set_description(N_("Video transformation filter"))
+    set_shortname(N_("Transformation"))
+    set_help(N_("Rotate or flip the video"))
+    set_capability("video filter2", 0)
+    set_category(CAT_VIDEO)
+    set_subcategory(SUBCAT_VIDEO_VFILTER)
+
+    add_string(CFG_PREFIX "type", "90", TYPE_TEXT, TYPE_TEXT, false)
+        change_string_list(type_list, type_list_text)
+        change_safe()
+
+    add_shortcut("transform")
+    set_callbacks(Open, Close)
+vlc_module_end()
 
 /*****************************************************************************
- * vout_sys_t: Transform video output method descriptor
- *****************************************************************************
- * This structure is part of the video output thread descriptor.
- * It describes the Transform specific properties of an output thread.
+ * Local prototypes
  *****************************************************************************/
-struct vout_sys_t
+static void HFlip(int *sx, int *sy, int w, int h, int dx, int dy)
 {
-    int i_mode;
-    vlc_bool_t b_rotation;
-    vout_thread_t *p_vout;
-};
-
-/*****************************************************************************
- * Control: control facility for the vout (forwards to child vout)
- *****************************************************************************/
-static int Control( vout_thread_t *p_vout, int i_query, va_list args )
+    VLC_UNUSED( h );
+    *sx = w - 1 - dx;
+    *sy = dy;
+}
+static void VFlip(int *sx, int *sy, int w, int h, int dx, int dy)
 {
-    return vout_vaControl( p_vout->p_sys->p_vout, i_query, args );
+    VLC_UNUSED( w );
+    *sx = dx;
+    *sy = h - 1 - dy;
 }
-
-/*****************************************************************************
- * Create: allocates Transform video thread output method
- *****************************************************************************
- * This function allocates and initializes a Transform vout method.
- *****************************************************************************/
-static int Create( vlc_object_t *p_this )
+static void Transpose(int *sx, int *sy, int w, int h, int dx, int dy)
 {
-    vout_thread_t *p_vout = (vout_thread_t *)p_this;
-    char *psz_method;
-
-    /* Allocate structure */
-    p_vout->p_sys = malloc( sizeof( vout_sys_t ) );
-    if( p_vout->p_sys == NULL )
-    {
-        msg_Err( p_vout, "out of memory" );
-        return VLC_ENOMEM;
-    }
-
-    p_vout->pf_init = Init;
-    p_vout->pf_end = End;
-    p_vout->pf_manage = NULL;
-    p_vout->pf_render = Render;
-    p_vout->pf_display = NULL;
-    p_vout->pf_control = Control;
-
-    /* Look what method was requested */
-    psz_method = config_GetPsz( p_vout, "transform-type" );
-
-    if( psz_method == NULL )
-    {
-        msg_Err( p_vout, "configuration variable %s empty", "transform-type" );
-        msg_Err( p_vout, "no valid transform mode provided, using '90'" );
-        p_vout->p_sys->i_mode = TRANSFORM_MODE_90;
-        p_vout->p_sys->b_rotation = 1;
-    }
-    else
-    {
-        if( !strcmp( psz_method, "hflip" ) )
-        {
-            p_vout->p_sys->i_mode = TRANSFORM_MODE_HFLIP;
-            p_vout->p_sys->b_rotation = 0;
-        }
-        else if( !strcmp( psz_method, "vflip" ) )
-        {
-            p_vout->p_sys->i_mode = TRANSFORM_MODE_VFLIP;
-            p_vout->p_sys->b_rotation = 0;
-        }
-        else if( !strcmp( psz_method, "90" ) )
-        {
-            p_vout->p_sys->i_mode = TRANSFORM_MODE_90;
-            p_vout->p_sys->b_rotation = 1;
-        }
-        else if( !strcmp( psz_method, "180" ) )
-        {
-            p_vout->p_sys->i_mode = TRANSFORM_MODE_180;
-            p_vout->p_sys->b_rotation = 0;
-        }
-        else if( !strcmp( psz_method, "270" ) )
-        {
-            p_vout->p_sys->i_mode = TRANSFORM_MODE_270;
-            p_vout->p_sys->b_rotation = 1;
-        }
-        else
-        {
-            msg_Err( p_vout, "no valid transform mode provided, using '90'" );
-            p_vout->p_sys->i_mode = TRANSFORM_MODE_90;
-            p_vout->p_sys->b_rotation = 1;
-        }
-
-        free( psz_method );
-    }
-
-    return VLC_SUCCESS;
+    VLC_UNUSED( h ); VLC_UNUSED( w );
+    *sx = dy;
+    *sy = dx;
 }
-
-/*****************************************************************************
- * Init: initialize Transform video thread output method
- *****************************************************************************/
-static int Init( vout_thread_t *p_vout )
+static void AntiTranspose(int *sx, int *sy, int w, int h, int dx, int dy)
 {
-    int i_index;
-    picture_t *p_pic;
-    video_format_t fmt = {0};
-
-    I_OUTPUTPICTURES = 0;
-
-    /* Initialize the output structure */
-    p_vout->output.i_chroma = p_vout->render.i_chroma;
-    p_vout->output.i_width  = p_vout->render.i_width;
-    p_vout->output.i_height = p_vout->render.i_height;
-    p_vout->output.i_aspect = p_vout->render.i_aspect;
-
-    fmt.i_width = fmt.i_visible_width = p_vout->render.i_width;
-    fmt.i_height = fmt.i_visible_height = p_vout->render.i_height;
-    fmt.i_x_offset = fmt.i_y_offset = 0;
-    fmt.i_chroma = p_vout->render.i_chroma;
-    fmt.i_aspect = p_vout->render.i_aspect;
-    fmt.i_sar_num = p_vout->render.i_aspect * fmt.i_height / fmt.i_width;
-    fmt.i_sar_den = VOUT_ASPECT_FACTOR;
-
-    /* Try to open the real video output */
-    msg_Dbg( p_vout, "spawning the real video output" );
-
-    if( p_vout->p_sys->b_rotation )
-    {
-        fmt.i_width = fmt.i_visible_width = p_vout->render.i_height;
-        fmt.i_height = fmt.i_visible_height = p_vout->render.i_width;
-        fmt.i_aspect = VOUT_ASPECT_FACTOR *
-            (uint64_t)VOUT_ASPECT_FACTOR / p_vout->render.i_aspect;
-        fmt.i_sar_num = VOUT_ASPECT_FACTOR;
-        fmt.i_sar_den = p_vout->render.i_aspect * fmt.i_height / fmt.i_width;
-
-        p_vout->p_sys->p_vout = vout_Create( p_vout, &fmt );
-    }
-    else
-    {
-        p_vout->p_sys->p_vout = vout_Create( p_vout, &fmt );
-    }
+    *sx = h - 1 - dy;
+    *sy = w - 1 - dx;
+}
+static void R90(int *sx, int *sy, int w, int h, int dx, int dy)
+{
+    VLC_UNUSED( h );
+    *sx = dy;
+    *sy = w - 1 - dx;
+}
+static void R180(int *sx, int *sy, int w, int h, int dx, int dy)
+{
+    *sx = w - 1 - dx;
+    *sy = h - 1 - dy;
+}
+static void R270(int *sx, int *sy, int w, int h, int dx, int dy)
+{
+    VLC_UNUSED( w );
+    *sx = h - 1 - dy;
+    *sy = dx;
+}
+typedef void (*convert_t)(int *, int *, int, int, int, int);
+
+#define PLANE(f,bits) \
+static void Plane##bits##_##f(plane_t *restrict dst, const plane_t *restrict src) \
+{ \
+    const uint##bits##_t *src_pixels = (const void *)src->p_pixels; \
+    uint##bits##_t *restrict dst_pixels = (void *)dst->p_pixels; \
+    const unsigned src_width = src->i_pitch / sizeof (*src_pixels); \
+    const unsigned dst_width = dst->i_pitch / sizeof (*dst_pixels); \
+    const unsigned dst_visible_width = dst->i_visible_pitch / sizeof (*dst_pixels); \
+ \
+    for (int y = 0; y < dst->i_visible_lines; y++) { \
+        for (unsigned x = 0; x < dst_visible_width; x++) { \
+            int sx, sy; \
+            (f)(&sx, &sy, dst_visible_width, dst->i_visible_lines, x, y); \
+            dst_pixels[y * dst_width + x] = \
+                src_pixels[sy * src_width + sx]; \
+        } \
+    } \
+}
 
-    /* Everything failed */
-    if( p_vout->p_sys->p_vout == NULL )
-    {
-        msg_Err( p_vout, "cannot open vout, aborting" );
-        return VLC_EGENERIC;
+static void Plane_VFlip(plane_t *restrict dst, const plane_t *restrict src)
+{
+    const uint8_t *src_pixels = src->p_pixels;
+    uint8_t *restrict dst_pixels = dst->p_pixels;
+
+    dst_pixels += dst->i_pitch * dst->i_visible_lines;
+    for (int y = 0; y < dst->i_visible_lines; y++) {
+        dst_pixels -= dst->i_pitch;
+        memcpy(dst_pixels, src_pixels, dst->i_visible_pitch);
+        src_pixels += src->i_pitch;
     }
+}
 
-    ALLOCATE_DIRECTBUFFERS( VOUT_MAX_PICTURES );
+#define I422(f) \
+static void Plane422_##f(plane_t *restrict dst, const plane_t *restrict src) \
+{ \
+    for (int y = 0; y < dst->i_visible_lines; y += 2) { \
+        for (int x = 0; x < dst->i_visible_pitch; x++) { \
+            int sx, sy, uv; \
+            (f)(&sx, &sy, dst->i_visible_pitch, dst->i_visible_lines / 2, \
+                x, y / 2); \
+            uv = (1 + src->p_pixels[2 * sy * src->i_pitch + sx] + \
+                src->p_pixels[(2 * sy + 1) * src->i_pitch + sx]) / 2; \
+            dst->p_pixels[y * dst->i_pitch + x] = uv; \
+            dst->p_pixels[(y + 1) * dst->i_pitch + x] = uv; \
+        } \
+    } \
+}
 
-    ADD_CALLBACKS( p_vout->p_sys->p_vout, SendEvents );
+#define YUY2(f) \
+static void PlaneYUY2_##f(plane_t *restrict dst, const plane_t *restrict src) \
+{ \
+    unsigned dst_visible_width = dst->i_visible_pitch / 2; \
+ \
+    for (int y = 0; y < dst->i_visible_lines; y += 2) { \
+        for (unsigned x = 0; x < dst_visible_width; x+= 2) { \
+            int sx0, sy0, sx1, sy1; \
+            (f)(&sx0, &sy0, dst_visible_width, dst->i_visible_lines, x, y); \
+            (f)(&sx1, &sy1, dst_visible_width, dst->i_visible_lines, \
+                x + 1, y + 1); \
+            dst->p_pixels[(y + 0) * dst->i_pitch + 2 * (x + 0)] = \
+                src->p_pixels[sy0 * src->i_pitch + 2 * sx0]; \
+            dst->p_pixels[(y + 0) * dst->i_pitch + 2 * (x + 1)] = \
+                src->p_pixels[sy1 * src->i_pitch + 2 * sx0]; \
+            dst->p_pixels[(y + 1) * dst->i_pitch + 2 * (x + 0)] = \
+                src->p_pixels[sy0 * src->i_pitch + 2 * sx1]; \
+            dst->p_pixels[(y + 1) * dst->i_pitch + 2 * (x + 1)] = \
+                src->p_pixels[sy1 * src->i_pitch + 2 * sx1]; \
+ \
+            int sx, sy, u, v; \
+            (f)(&sx, &sy, dst_visible_width / 2, dst->i_visible_lines / 2, \
+                x / 2, y / 2); \
+            u = (1 + src->p_pixels[2 * sy * src->i_pitch + 4 * sx + 1] + \
+                src->p_pixels[(2 * sy + 1) * src->i_pitch + 4 * sx + 1]) / 2; \
+            v = (1 + src->p_pixels[2 * sy * src->i_pitch + 4 * sx + 3] + \
+                src->p_pixels[(2 * sy + 1) * src->i_pitch + 4 * sx + 3]) / 2; \
+            dst->p_pixels[(y + 0) * dst->i_pitch + 2 * x + 1] = u; \
+            dst->p_pixels[(y + 0) * dst->i_pitch + 2 * x + 3] = v; \
+            dst->p_pixels[(y + 1) * dst->i_pitch + 2 * x + 1] = u; \
+            dst->p_pixels[(y + 1) * dst->i_pitch + 2 * x + 3] = v; \
+        } \
+    } \
+}
 
-    ADD_PARENT_CALLBACKS( SendEventsToChild );
+#define PLANES(f) \
+PLANE(f,8) PLANE(f,16) PLANE(f,32)
+
+PLANES(HFlip)
+#define Plane8_VFlip Plane_VFlip
+#define Plane16_VFlip Plane_VFlip
+#define Plane32_VFlip Plane_VFlip
+PLANES(Transpose)
+PLANES(AntiTranspose)
+PLANES(R90)
+PLANES(R180)
+PLANES(R270)
+
+#define Plane422_HFlip Plane16_HFlip
+#define Plane422_VFlip Plane_VFlip
+#define Plane422_R180  Plane16_R180
+I422(Transpose)
+I422(AntiTranspose)
+I422(R90)
+I422(R270)
+
+#define PlaneYUY2_HFlip Plane32_HFlip
+#define PlaneYUY2_VFlip Plane_VFlip
+#define PlaneYUY2_R180  Plane32_R180
+YUY2(Transpose)
+YUY2(AntiTranspose)
+YUY2(R90)
+YUY2(R270)
+
+typedef struct {
+    char      name[16];
+    convert_t convert;
+    convert_t iconvert;
+    video_transform_t operation;
+    void      (*plane8) (plane_t *dst, const plane_t *src);
+    void      (*plane16)(plane_t *dst, const plane_t *src);
+    void      (*plane32)(plane_t *dst, const plane_t *src);
+    void      (*i422)(plane_t *dst, const plane_t *src);
+    void      (*yuyv)(plane_t *dst, const plane_t *src);
+} transform_description_t;
+
+#define DESC(str, f, invf, op) \
+    { str, f, invf, op, Plane8_##f, Plane16_##f, Plane32_##f, \
+      Plane422_##f, PlaneYUY2_##f }
+
+static const transform_description_t descriptions[] = {
+    DESC("90",            R90,           R270,          TRANSFORM_R90),
+    DESC("180",           R180,          R180,          TRANSFORM_R180),
+    DESC("270",           R270,          R90,           TRANSFORM_R270),
+    DESC("hflip",         HFlip,         HFlip,         TRANSFORM_HFLIP),
+    DESC("vflip",         VFlip,         VFlip,         TRANSFORM_VFLIP),
+    DESC("transpose",     Transpose,     Transpose,     TRANSFORM_TRANSPOSE),
+    DESC("antitranspose", AntiTranspose, AntiTranspose, TRANSFORM_ANTI_TRANSPOSE),
+};
 
-    return VLC_SUCCESS;
+static bool dsc_is_rotated(const transform_description_t *dsc)
+{
+    return dsc->plane32 != dsc->yuyv;
 }
 
-/*****************************************************************************
- * End: terminate Transform video thread output method
- *****************************************************************************/
-static void End( vout_thread_t *p_vout )
-{
-    int i_index;
+static const size_t n_transforms =
+    sizeof (descriptions) / sizeof (descriptions[0]);
 
-    /* Free the fake output buffers we allocated */
-    for( i_index = I_OUTPUTPICTURES ; i_index ; )
-    {
-        i_index--;
-        free( PP_OUTPUTPICTURE[ i_index ]->p_data_orig );
-    }
-}
+struct filter_sys_t {
+    const vlc_chroma_description_t *chroma;
+    void (*plane[PICTURE_PLANE_MAX])(plane_t *, const plane_t *);
+    convert_t convert;
+};
 
-/*****************************************************************************
- * Destroy: destroy Transform video thread output method
- *****************************************************************************
- * Terminate an output method created by TransformCreateOutputMethod
- *****************************************************************************/
-static void Destroy( vlc_object_t *p_this )
+static picture_t *Filter(filter_t *filter, picture_t *src)
 {
-    vout_thread_t *p_vout = (vout_thread_t *)p_this;
+    filter_sys_t *sys = filter->p_sys;
 
-    if( p_vout->p_sys->p_vout )
-    {
-        DEL_CALLBACKS( p_vout->p_sys->p_vout, SendEvents );
-        vlc_object_detach( p_vout->p_sys->p_vout );
-        vout_Destroy( p_vout->p_sys->p_vout );
+    picture_t *dst = filter_NewPicture(filter);
+    if (!dst) {
+        picture_Release(src);
+        return NULL;
     }
 
-    DEL_PARENT_CALLBACKS( SendEventsToChild );
+    const vlc_chroma_description_t *chroma = sys->chroma;
+    for (unsigned i = 0; i < chroma->plane_count; i++)
+         (sys->plane[i])(&dst->p[i], &src->p[i]);
 
-    free( p_vout->p_sys );
+    picture_CopyProperties(dst, src);
+    picture_Release(src);
+    return dst;
 }
 
-/*****************************************************************************
- * Render: displays previously rendered output
- *****************************************************************************
- * This function send the currently rendered image to Transform image, waits
- * until it is displayed and switch the two rendering buffers, preparing next
- * frame.
- *****************************************************************************/
-static void Render( vout_thread_t *p_vout, picture_t *p_pic )
+static int Mouse(filter_t *filter, vlc_mouse_t *mouse,
+                 const vlc_mouse_t *mold, const vlc_mouse_t *mnew)
 {
-    picture_t *p_outpic;
-    int i_index;
-
-    /* This is a new frame. Get a structure from the video_output. */
-    while( ( p_outpic = vout_CreatePicture( p_vout->p_sys->p_vout, 0, 0, 0 ) )
-              == NULL )
-    {
-        if( p_vout->b_die || p_vout->b_error )
-        {
-            return;
-        }
-        msleep( VOUT_OUTMEM_SLEEP );
-    }
+    VLC_UNUSED( mold );
 
-    vout_DatePicture( p_vout->p_sys->p_vout, p_outpic, p_pic->date );
-    vout_LinkPicture( p_vout->p_sys->p_vout, p_outpic );
+    const video_format_t *fmt = &filter->fmt_out.video;
+    const filter_sys_t   *sys = filter->p_sys;
 
-    switch( p_vout->p_sys->i_mode )
-    {
-        case TRANSFORM_MODE_90:
-            for( i_index = 0 ; i_index < p_pic->i_planes ; i_index++ )
-            {
-                int i_pitch = p_pic->p[i_index].i_pitch;
-
-                uint8_t *p_in = p_pic->p[i_index].p_pixels;
+    *mouse = *mnew;
+    sys->convert(&mouse->i_x, &mouse->i_y,
+                 fmt->i_visible_width, fmt->i_visible_height,
+                 mouse->i_x, mouse->i_y);
+    return VLC_SUCCESS;
+}
 
-                uint8_t *p_out = p_outpic->p[i_index].p_pixels;
-                uint8_t *p_out_end = p_out +
-                    p_outpic->p[i_index].i_visible_lines *
-                    p_outpic->p[i_index].i_pitch;
+static int Open(vlc_object_t *object)
+{
+    filter_t *filter = (filter_t *)object;
+    const video_format_t *src = &filter->fmt_in.video;
+    video_format_t       *dst = &filter->fmt_out.video;
 
-                for( ; p_out < p_out_end ; )
-                {
-                    uint8_t *p_line_end;
+    const vlc_chroma_description_t *chroma =
+        vlc_fourcc_GetChromaDescription(src->i_chroma);
+    if (chroma == NULL)
+        return VLC_EGENERIC;
 
-                    p_out_end -= p_outpic->p[i_index].i_pitch
-                                  - p_outpic->p[i_index].i_visible_pitch;
-                    p_line_end = p_in + p_pic->p[i_index].i_visible_lines *
-                        i_pitch;
+    filter_sys_t *sys = malloc(sizeof(*sys));
+    if (!sys)
+        return VLC_ENOMEM;
 
-                    for( ; p_in < p_line_end ; )
-                    {
-                        p_line_end -= i_pitch;
-                        *(--p_out_end) = *p_line_end;
-                    }
+    sys->chroma = chroma;
 
-                    p_in++;
-                }
-            }
-            break;
+    static const char *const ppsz_filter_options[] = {
+        "type", NULL
+    };
 
-        case TRANSFORM_MODE_180:
-            for( i_index = 0 ; i_index < p_pic->i_planes ; i_index++ )
-            {
-                uint8_t *p_in = p_pic->p[i_index].p_pixels;
-                uint8_t *p_in_end = p_in + p_pic->p[i_index].i_visible_lines
-                                            * p_pic->p[i_index].i_pitch;
-
-                uint8_t *p_out = p_outpic->p[i_index].p_pixels;
-
-                for( ; p_in < p_in_end ; )
-                {
-                    uint8_t *p_line_start = p_in_end
-                                             - p_pic->p[i_index].i_pitch;
-                    p_in_end -= p_pic->p[i_index].i_pitch
-                                 - p_pic->p[i_index].i_visible_pitch;
-
-                    for( ; p_line_start < p_in_end ; )
-                    {
-                        *p_out++ = *(--p_in_end);
-                    }
+    config_ChainParse(filter, CFG_PREFIX, ppsz_filter_options,
+                      filter->p_cfg);
+    char *type_name = var_InheritString(filter, CFG_PREFIX"type");
+    const transform_description_t *dsc = NULL;
 
-                    p_out += p_outpic->p[i_index].i_pitch
-                              - p_outpic->p[i_index].i_visible_pitch;
-                }
-            }
+    for (size_t i = 0; i < n_transforms; i++)
+        if (type_name && !strcmp(descriptions[i].name, type_name)) {
+            dsc = &descriptions[i];
             break;
+        }
+    if (dsc == NULL) {
+        dsc = &descriptions[0];
+        msg_Warn(filter, "No valid transform mode provided, using '%s'",
+                 dsc->name);
+    }
 
-        case TRANSFORM_MODE_270:
-            for( i_index = 0 ; i_index < p_pic->i_planes ; i_index++ )
-            {
-                int i_pitch = p_pic->p[i_index].i_pitch;
-
-                uint8_t *p_in = p_pic->p[i_index].p_pixels;
-
-                uint8_t *p_out = p_outpic->p[i_index].p_pixels;
-                uint8_t *p_out_end = p_out +
-                    p_outpic->p[i_index].i_visible_lines *
-                    p_outpic->p[i_index].i_pitch;
-
-                for( ; p_out < p_out_end ; )
-                {
-                    uint8_t *p_in_end;
-
-                    p_in_end = p_in + p_pic->p[i_index].i_visible_lines *
-                        i_pitch;
-
-                    for( ; p_in < p_in_end ; )
-                    {
-                        p_in_end -= i_pitch;
-                        *p_out++ = *p_in_end;
-                    }
+    free(type_name);
 
-                    p_out += p_outpic->p[i_index].i_pitch
-                              - p_outpic->p[i_index].i_visible_pitch;
-                    p_in++;
-                }
-            }
+    switch (chroma->pixel_size) {
+        case 1:
+            sys->plane[0] = dsc->plane8;
             break;
-
-        case TRANSFORM_MODE_HFLIP:
-            for( i_index = 0 ; i_index < p_pic->i_planes ; i_index++ )
-            {
-                uint8_t *p_in = p_pic->p[i_index].p_pixels;
-                uint8_t *p_in_end = p_in + p_pic->p[i_index].i_visible_lines
-                                            * p_pic->p[i_index].i_pitch;
-
-                uint8_t *p_out = p_outpic->p[i_index].p_pixels;
-
-                for( ; p_in < p_in_end ; )
-                {
-                    p_in_end -= p_pic->p[i_index].i_pitch;
-                    p_vout->p_vlc->pf_memcpy( p_out, p_in_end,
-                                           p_pic->p[i_index].i_visible_pitch );
-                    p_out += p_pic->p[i_index].i_pitch;
-                }
-            }
+        case 2:
+            sys->plane[0] = dsc->plane16;
             break;
-
-        case TRANSFORM_MODE_VFLIP:
-            for( i_index = 0 ; i_index < p_pic->i_planes ; i_index++ )
-            {
-                uint8_t *p_in = p_pic->p[i_index].p_pixels;
-                uint8_t *p_in_end = p_in + p_pic->p[i_index].i_visible_lines
-                                            * p_pic->p[i_index].i_pitch;
-
-                uint8_t *p_out = p_outpic->p[i_index].p_pixels;
-
-                for( ; p_in < p_in_end ; )
-                {
-                    uint8_t *p_line_end = p_in
-                                           + p_pic->p[i_index].i_visible_pitch;
-
-                    for( ; p_in < p_line_end ; )
-                    {
-                        *p_out++ = *(--p_line_end);
-                    }
-
-                    p_in += p_pic->p[i_index].i_pitch;
-                }
-            }
+        case 4:
+            sys->plane[0] = dsc->plane32;
             break;
-
         default:
-            break;
+            msg_Err(filter, "Unsupported pixel size %u (chroma %4.4s)",
+                    chroma->pixel_size, (char *)&src->i_chroma);
+            goto error;
     }
 
-    vout_UnlinkPicture( p_vout->p_sys->p_vout, p_outpic );
-
-    vout_DisplayPicture( p_vout->p_sys->p_vout, p_outpic );
-}
-
-/*****************************************************************************
- * SendEvents: forward mouse and keyboard events to the parent p_vout
- *****************************************************************************/
-static int SendEvents( vlc_object_t *p_this, char const *psz_var,
-                       vlc_value_t oldval, vlc_value_t newval, void *_p_vout )
-{
-    vout_thread_t *p_vout = (vout_thread_t *)_p_vout;
-    vlc_value_t sentval = newval;
-
-    /* Translate the mouse coordinates */
-    if( !strcmp( psz_var, "mouse-x" ) )
-    {
-        switch( p_vout->p_sys->i_mode )
-        {
-        case TRANSFORM_MODE_270:
-            sentval.i_int = p_vout->p_sys->p_vout->output.i_width
-                             - sentval.i_int;
-        case TRANSFORM_MODE_90:
-            var_Set( p_vout, "mouse-y", sentval );
-            return VLC_SUCCESS;
-
-        case TRANSFORM_MODE_180:
-        case TRANSFORM_MODE_HFLIP:
-            sentval.i_int = p_vout->p_sys->p_vout->output.i_width
-                             - sentval.i_int;
-            break;
-
-        case TRANSFORM_MODE_VFLIP:
-        default:
-            break;
+    for (unsigned i = 1; i < PICTURE_PLANE_MAX; i++)
+        sys->plane[i] = sys->plane[0];
+    sys->convert = dsc->convert;
+
+    if (dsc_is_rotated(dsc)) {
+        switch (src->i_chroma) {
+            case VLC_CODEC_I422:
+            case VLC_CODEC_J422:
+                sys->plane[2] = sys->plane[1] = dsc->i422;
+                break;
+            default:
+                for (unsigned i = 0; i < chroma->plane_count; i++) {
+                    if (chroma->p[i].w.num * chroma->p[i].h.den
+                     != chroma->p[i].h.num * chroma->p[i].w.den) {
+                        msg_Err(filter, "Format rotation not possible "
+                                "(chroma %4.4s)", (char *)&src->i_chroma);
+                        goto error;
+                    }
+            }
         }
     }
-    else if( !strcmp( psz_var, "mouse-y" ) )
-    {
-        switch( p_vout->p_sys->i_mode )
-        {
-        case TRANSFORM_MODE_90:
-            sentval.i_int = p_vout->p_sys->p_vout->output.i_height
-                             - sentval.i_int;
-        case TRANSFORM_MODE_270:
-            var_Set( p_vout, "mouse-x", sentval );
-            return VLC_SUCCESS;
-
-        case TRANSFORM_MODE_180:
-        case TRANSFORM_MODE_VFLIP:
-            sentval.i_int = p_vout->p_sys->p_vout->output.i_height
-                             - sentval.i_int;
-            break;
 
-        case TRANSFORM_MODE_HFLIP:
-        default:
-            break;
-        }
+    /*
+     * Note: we neither compare nor set dst->orientation,
+     * the caller needs to do it manually (user might want
+     * to transform video without changing the orientation).
+     */
+
+    video_format_t src_trans = *src;
+    video_format_TransformBy(&src_trans, dsc->operation);
+
+    if (!filter->b_allow_fmt_out_change &&
+        (dst->i_width          != src_trans.i_width ||
+         dst->i_visible_width  != src_trans.i_visible_width ||
+         dst->i_height         != src_trans.i_height ||
+         dst->i_visible_height != src_trans.i_visible_height ||
+         dst->i_sar_num        != src_trans.i_sar_num ||
+         dst->i_sar_den        != src_trans.i_sar_den ||
+         dst->i_x_offset       != src_trans.i_x_offset ||
+         dst->i_y_offset       != src_trans.i_y_offset)) {
+
+            msg_Err(filter, "Format change is not allowed");
+            goto error;
+    }
+    else if(filter->b_allow_fmt_out_change) {
+
+        dst->i_width          = src_trans.i_width;
+        dst->i_visible_width  = src_trans.i_visible_width;
+        dst->i_height         = src_trans.i_height;
+        dst->i_visible_height = src_trans.i_visible_height;
+        dst->i_sar_num        = src_trans.i_sar_num;
+        dst->i_sar_den        = src_trans.i_sar_den;
+        dst->i_x_offset       = src_trans.i_x_offset;
+        dst->i_y_offset       = src_trans.i_y_offset;
     }
 
-    var_Set( p_vout, psz_var, sentval );
+    /* Deal with weird packed formats */
+    switch (src->i_chroma) {
+        case VLC_CODEC_UYVY:
+        case VLC_CODEC_VYUY:
+            if (dsc_is_rotated(dsc)) {
+                msg_Err(filter, "Format rotation not possible (chroma %4.4s)",
+                        (char *)&src->i_chroma);
+                goto error;
+            }
+            /* fallthrough */
+        case VLC_CODEC_YUYV:
+        case VLC_CODEC_YVYU:
+            sys->plane[0] = dsc->yuyv; /* 32-bits, not 16-bits! */
+            break;
+        case VLC_CODEC_NV12:
+        case VLC_CODEC_NV21:
+            goto error;
+    }
 
+    filter->p_sys           = sys;
+    filter->pf_video_filter = Filter;
+    filter->pf_video_mouse  = Mouse;
     return VLC_SUCCESS;
+error:
+    free(sys);
+    return VLC_EGENERIC;
 }
 
-/*****************************************************************************
- * SendEventsToChild: forward events to the child/children vout
- *****************************************************************************/
-static int SendEventsToChild( vlc_object_t *p_this, char const *psz_var,
-                       vlc_value_t oldval, vlc_value_t newval, void *p_data )
+static void Close(vlc_object_t *object)
 {
-    vout_thread_t *p_vout = (vout_thread_t *)p_this;
-    var_Set( p_vout->p_sys->p_vout, psz_var, newval );
-    return VLC_SUCCESS;
+    filter_t     *filter = (filter_t *)object;
+    filter_sys_t *sys    = filter->p_sys;
+
+    free(sys);
 }