[MPlayer-dev-eng] stereo3d filter

taxy443 at gmail.com taxy443 at gmail.com
Mon Oct 18 16:27:05 CEST 2010


The requested version.

---

Index: libmpcodecs/vf_stereo3d.c
===================================================================
--- libmpcodecs/vf_stereo3d.c	(revision 0)
+++ libmpcodecs/vf_stereo3d.c	(revision 0)
@@ -0,0 +1,572 @@
+/*
+ * Copyright (C) 2010 Gordon Schmidt <gordon.schmidt <at> s2000.tu-chemnitz.de>
+ *
+ * This file is part of MPlayer.
+ *
+ * MPlayer is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * MPlayer is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with MPlayer; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+//==includes==//
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "config.h"
+#include "mp_msg.h"
+#include "help_mp.h"
+
+#include "img_format.h"
+#include "mp_image.h"
+#include "vf.h"
+#include "m_struct.h"
+
+#include "libavutil/common.h"
+#include "libvo/fastmemcpy.h"
+
+//==types==//
+typedef enum stereo_code {
+    ANAGLYPH_RC_GRAY,   //anaglyph red/cyan gray
+    ANAGLYPH_RC_HALF,   //anaglyph red/cyan half colored
+    ANAGLYPH_RC_COLOR,  //anaglyph red/cyan colored
+    ANAGLYPH_RC_DUBOIS, //anaglyph red/cyan dubois
+    ANAGLYPH_GM_GRAY,   //anaglyph green/magenta gray
+    ANAGLYPH_GM_HALF,   //anaglyph green/magenta half colored
+    ANAGLYPH_GM_COLOR,  //anaglyph green/magenta colored
+    ANAGLYPH_YB_GRAY,   //anaglyph yellow/blue gray
+    ANAGLYPH_YB_HALF,   //anaglyph yellow/blue half colored
+    ANAGLYPH_YB_COLOR,  //anaglyph yellow/blue colored
+    MONO_L,             //mono output for debugging (left eye only)
+    MONO_R,             //mono output for debugging (right eye only)
+    SIDE_BY_SIDE_LR,    //side by side parallel (left eye left, right eye right)
+    SIDE_BY_SIDE_RL,    //side by side crosseye (right eye left, left eye right)
+    ABOVE_BELOW_LR,     //above-below (left eye above, right eye below)
+    ABOVE_BELOW_RL,     //above-below (right eye above, left eye below)
+    ABOVE_BELOW_2_LR,   //above-below with half height resolution
+    ABOVE_BELOW_2_RL,   //above-below with half height resolution
+    STEREO_CODE_COUNT   //no value set - TODO: needs autodetection
+} stereo_code;
+
+static const unsigned int outfmt_list[]={
+// RGB
+    IMGFMT_RGB24,
+    IMGFMT_BGR24,
+    IMGFMT_BGR32,
+    IMGFMT_RGB32,
+    0
+};
+
+typedef struct component {
+    stereo_code  fmt;
+    unsigned int width;
+    unsigned int height;
+    unsigned int bypp;
+    unsigned int pixelfmt;
+    unsigned int red;
+    unsigned int blue;
+    unsigned int off_left;
+    unsigned int off_right;
+    unsigned int stride;
+    unsigned int hres;
+} component;
+
+//==global variables==//
+static const int ana_coeff[10][3][6] = {
+    {{19595, 38470,  7471,     0,     0,     0},    //ANAGLYPH_RC_GRAY
+     {    0,     0,     0, 19595, 38470,  7471},
+     {    0,     0,     0, 19595, 38470,  7471}},
+    {{19595, 38470,  7471,     0,     0,     0},    //ANAGLYPH_RC_HALF
+     {    0,     0,     0,     0, 65536,     0},
+     {    0,     0,     0,     0,     0, 65536}},
+    {{65536,     0,     0,     0,     0,     0},    //ANAGLYPH_RC_COLOR
+     {    0,     0,     0,     0, 65536,     0},
+     {    0,     0,     0,     0,     0, 65536}},
+    {{29891, 32800, 11559, -2849, -5763,  -102},    //ANAGLYPH_RC_DUBOIS
+     {-2627, -2479, -1033, 24804, 48080, -1209},
+     { -997, -1350,  -358, -4729, -7403, 80373}},
+    {{    0,     0,     0, 19595, 38470,  7471},    //ANAGLYPH_GM_GRAY
+     {19595, 38470,  7471,     0,     0,     0},
+     {    0,     0,     0, 19595, 38470,  7471}},
+    {{    0,     0,     0, 65536,     0,     0},    //ANAGLYPH_GM_HALF
+     {19595, 38470,  7471,     0,     0,     0},
+     {    0,     0,     0,     0,     0, 65536}},
+    {{    0,     0,     0, 65536,     0,     0},    //ANAGLYPH_GM_COLOR
+     {    0, 65536,     0,     0,     0,     0},
+     {    0,     0,     0,     0,     0, 65536}},
+    {{    0,     0,     0, 19595, 38470,  7471},    //ANAGLYPH_YB_GRAY
+     {    0,     0,     0, 19595, 38470,  7471},
+     {19595, 38470,  7471,     0,     0,     0}},
+    {{    0,     0,     0, 65536,     0,     0},    //ANAGLYPH_YB_HALF
+     {    0,     0,     0,     0, 65536,     0},
+     {19595, 38470,  7471,     0,     0,     0}},
+    {{    0,     0,     0, 65536,     0,     0},    //ANAGLYPH_YB_COLOR
+     {    0,     0,     0,     0, 65536,     0},
+     {    0,     0, 65536,     0,     0,     0}}
+};
+
+struct vf_priv_s {
+    component in;
+    component out;
+    int ana_matrix[3][6];
+    unsigned int width;
+    unsigned int height;
+} const vf_priv_default = {
+  {SIDE_BY_SIDE_LR},
+  {ANAGLYPH_RC_DUBOIS}
+};
+
+extern int opt_screen_size_x;
+extern int opt_screen_size_y;
+
+//==functions==//
+static inline uint8_t ana_convert(int coeff[6], int rl, int gl, int bl,
+                                                int rr, int gr, int br)
+{
+    int sum;
+
+    sum  = coeff[0] * rl;
+    sum += coeff[1] * gl;
+    sum += coeff[2] * bl;
+    sum += coeff[3] * rr;
+    sum += coeff[4] * gr;
+    sum += coeff[5] * br;
+    return av_clip_uint8(sum >> 16);
+}
+
+static unsigned int find_best_out(vf_instance_t *vf)
+{
+unsigned int ret = 0;
+int i;
+unsigned int format = 0;
+
+    for(i=0; outfmt_list[i] != 0; i++){
+        format=outfmt_list[i];
+        ret = vf_next_query_format(vf, format);
+        mp_msg(MSGT_VFILTER,MSGL_DBG2,"[stereo3D]: query(%s) -> %d\n",vo_format_name(format),ret&3);
+
+        if(ret&VFCAP_CSP_SUPPORTED_BY_HW)
+            break;
+    }
+    if(ret&VFCAP_CSP_SUPPORTED_BY_HW){
+        switch (vf->priv->out.fmt) {
+            case ANAGLYPH_RC_GRAY:
+            case ANAGLYPH_RC_HALF:
+            case ANAGLYPH_RC_COLOR:
+            case ANAGLYPH_RC_DUBOIS:
+            case ANAGLYPH_GM_GRAY:
+            case ANAGLYPH_GM_HALF:
+            case ANAGLYPH_GM_COLOR:
+            case ANAGLYPH_YB_GRAY:
+            case ANAGLYPH_YB_HALF:
+            case ANAGLYPH_YB_COLOR:
+                return format;
+                break;
+            default:
+                return IMGFMT_RGB24;
+                break;
+        }
+    }else
+        return IMGFMT_RGB24;
+
+}
+
+
+static int config(struct vf_instance *vf, int width, int height, int d_width,
+                  int d_height, unsigned int flags, unsigned int outfmt)
+{
+    unsigned int best=find_best_out(vf);
+
+    if (outfmt != IMGFMT_RGB24) {
+        mp_msg(MSGT_VFILTER, MSGL_WARN, "[stereo3d] input format is not supported\n");
+        return 0;
+    }
+
+    if ((width & 1) || (height & 1)) {
+        mp_msg(MSGT_VFILTER, MSGL_WARN, "[stereo3d] invalid height or width\n");
+        return 0;
+    }
+    //default input values
+    vf->priv->width             = width;
+    vf->priv->height            = height;
+    vf->priv->in.width          = width;
+    vf->priv->in.height         = height;
+    vf->priv->in.hres           = 1;
+    vf->priv->in.off_left       = 0;
+    vf->priv->in.off_right      = 0;
+    vf->priv->in.stride         = vf->priv->width * 3;
+
+    //check input format
+    switch (vf->priv->in.fmt) {
+    case SIDE_BY_SIDE_LR:
+        vf->priv->width         = width / 2;
+        vf->priv->in.off_right  = vf->priv->width * 3;
+        vf->priv->in.stride     = vf->priv->width * 6;
+        break;
+    case SIDE_BY_SIDE_RL:
+        vf->priv->width         = width / 2;
+        vf->priv->in.off_left   = vf->priv->width * 3;
+        vf->priv->in.stride     = vf->priv->width * 6;
+        break;
+    case ABOVE_BELOW_LR:
+        vf->priv->height        = height / 2;
+        vf->priv->in.off_right  = vf->priv->width * vf->priv->height * 3;
+        break;
+    case ABOVE_BELOW_RL:
+        vf->priv->height        = height / 2;
+        vf->priv->in.off_left   = vf->priv->width * vf->priv->height * 3;
+        break;
+    case ABOVE_BELOW_2_LR:
+        vf->priv->in.hres       = 2;
+        vf->priv->in.off_right  = vf->priv->width * vf->priv->height / 2 * 3;
+        break;
+    case ABOVE_BELOW_2_RL:
+        vf->priv->in.hres       = 2;
+        vf->priv->in.off_left   = vf->priv->width * vf->priv->height / 2 * 3;
+        break;
+    default:
+        mp_msg(MSGT_VFILTER, MSGL_WARN,
+               "[stereo3d] stereo format of input is not supported\n");
+        return 0;
+        break;
+    }
+    //default output values
+    vf->priv->out.pixelfmt = best;
+    switch (best) {
+        case IMGFMT_RGB24:
+            vf->priv->out.bypp = 3;
+            vf->priv->out.red = 0;
+            vf->priv->out.blue = 2;
+            break;
+        case IMGFMT_BGR24:
+            vf->priv->out.bypp = 3;
+            vf->priv->out.red = 2;
+            vf->priv->out.blue = 0;
+            break;
+        case IMGFMT_RGB32:
+            vf->priv->out.bypp = 4;
+            vf->priv->out.red = 0;
+            vf->priv->out.blue = 2;
+            break;
+        case IMGFMT_BGR32:
+            vf->priv->out.bypp = 4;
+            vf->priv->out.red = 2;
+            vf->priv->out.blue = 0;
+            break;
+        default:
+            mp_msg(MSGT_VFILTER, MSGL_WARN, "[stereo3d] output format is not supported\n");
+            return 0;
+            break;
+    }
+    mp_msg(MSGT_VFILTER,MSGL_V,"[stereo3D]: %s output format\n",vo_format_name(best));
+
+    vf->priv->out.width         = vf->priv->width;
+    vf->priv->out.height        = vf->priv->height;
+    vf->priv->out.hres          = 1;
+    vf->priv->out.off_left      = 0;
+    vf->priv->out.off_right     = 0;
+    vf->priv->out.stride        = vf->priv->width * vf->priv->out.bypp;
+
+    //check output format
+    switch (vf->priv->out.fmt) {
+    case ANAGLYPH_RC_GRAY:
+    case ANAGLYPH_RC_HALF:
+    case ANAGLYPH_RC_COLOR:
+    case ANAGLYPH_RC_DUBOIS:
+    case ANAGLYPH_GM_GRAY:
+    case ANAGLYPH_GM_HALF:
+    case ANAGLYPH_GM_COLOR:
+    case ANAGLYPH_YB_GRAY:
+    case ANAGLYPH_YB_HALF:
+    case ANAGLYPH_YB_COLOR:
+        memcpy(vf->priv->ana_matrix, ana_coeff[vf->priv->out.fmt],
+               sizeof(vf->priv->ana_matrix));
+        break;
+    case SIDE_BY_SIDE_LR:
+        vf->priv->out.width     = vf->priv->width * 2;
+        vf->priv->out.off_right = vf->priv->out.stride;
+        vf->priv->out.stride    = vf->priv->out.stride * 2;
+        break;
+    case SIDE_BY_SIDE_RL:
+        vf->priv->out.width     = vf->priv->width * 2;
+        vf->priv->out.off_left  = vf->priv->out.stride;
+        vf->priv->out.stride    = vf->priv->out.stride * 2;
+        break;
+    case ABOVE_BELOW_LR:
+        vf->priv->out.height    = vf->priv->height * 2;
+        vf->priv->out.off_right = vf->priv->out.stride * vf->priv->height;
+        break;
+    case ABOVE_BELOW_RL:
+        vf->priv->out.height    = vf->priv->height * 2;
+        vf->priv->out.off_left = vf->priv->out.stride * vf->priv->height;
+        break;
+    case ABOVE_BELOW_2_LR:
+        vf->priv->out.hres      = 2;
+        vf->priv->out.off_right = vf->priv->out.stride * vf->priv->height / 2;
+        break;
+    case ABOVE_BELOW_2_RL:
+        vf->priv->out.hres      = 2;
+        vf->priv->out.off_left  = vf->priv->out.stride * vf->priv->height / 2;
+        break;
+    case MONO_R:
+        //same as MONO_L only needs switching of input offsets
+        vf->priv->in.off_left   = vf->priv->in.off_right;
+        //nobreak;
+    case MONO_L:
+        //use default settings
+        break;
+    default:
+        mp_msg(MSGT_VFILTER, MSGL_WARN,
+            "[stereo3d] stereo format of output is not supported\n");
+        return 0;
+        break;
+    }
+    if (!opt_screen_size_x && !opt_screen_size_y) {
+        d_width     = d_width  * vf->priv->out.width  / width;
+        d_height    = d_height * vf->priv->out.height / height;
+    }
+    return vf_next_config(vf, vf->priv->out.width, vf->priv->out.height,
+                          d_width, d_height, flags, best);
+}
+
+static int put_image(struct vf_instance *vf, mp_image_t *mpi, double pts)
+{
+    mp_image_t *dmpi;
+    if (vf->priv->in.fmt == vf->priv->out.fmt) { //nothing to do
+        dmpi = mpi;
+    } else {
+        dmpi = vf_get_image(vf->next, vf->priv->out.pixelfmt, MP_IMGTYPE_TEMP,
+                            0, vf->priv->out.width, vf->priv->out.height);
+        dmpi->h = vf->priv->out.height;
+        dmpi->width = vf->priv->out.width;
+        switch (vf->priv->out.fmt) {
+        case SIDE_BY_SIDE_LR:
+        case SIDE_BY_SIDE_RL:
+        case ABOVE_BELOW_LR:
+        case ABOVE_BELOW_RL:
+        case ABOVE_BELOW_2_LR:
+        case ABOVE_BELOW_2_RL:
+            for (int i = 0; i < vf->priv->in.hres; i++) {
+                memcpy_pic(dmpi->planes[0] + vf->priv->out.off_left +
+                           (i * vf->priv->out.stride), mpi->planes[0] +
+                           vf->priv->in.off_left, 3 * vf->priv->width,
+                           vf->priv->height / (vf->priv->in.hres *
+                           vf->priv->out.hres), vf->priv->out.stride *
+                           vf->priv->in.hres, vf->priv->in.stride *
+                           vf->priv->out.hres);
+                memcpy_pic(dmpi->planes[0] + vf->priv->out.off_right +
+                           (i * vf->priv->out.stride), mpi->planes[0] +
+                           vf->priv->in.off_right, 3 * vf->priv->width,
+                           vf->priv->height / (vf->priv->in.hres *
+                           vf->priv->out.hres), vf->priv->out.stride *
+                           vf->priv->in.hres, vf->priv->in.stride *
+                           vf->priv->out.hres);
+            }
+            break;
+        case MONO_L:
+        case MONO_R:
+            for (int i = 0; i < vf->priv->in.hres; i++) {
+                memcpy_pic(dmpi->planes[0] + (i * vf->priv->out.stride),
+                           mpi->planes[0] + vf->priv->in.off_left, 3 *
+                           vf->priv->width, vf->priv->height /
+                           vf->priv->in.hres, vf->priv->out.stride *
+                           vf->priv->in.hres, vf->priv->in.stride);
+            }
+            break;
+        case ANAGLYPH_RC_GRAY:
+        case ANAGLYPH_RC_HALF:
+        case ANAGLYPH_RC_COLOR:
+        case ANAGLYPH_RC_DUBOIS:
+        case ANAGLYPH_GM_GRAY:
+        case ANAGLYPH_GM_HALF:
+        case ANAGLYPH_GM_COLOR:
+        case ANAGLYPH_YB_GRAY:
+        case ANAGLYPH_YB_HALF:
+        case ANAGLYPH_YB_COLOR: {
+            int x,y,rl,gl,bl,rr,gr,br,il,ir,o;
+            unsigned int out_bypp = vf->priv->out.bypp;
+            unsigned int out_red = vf->priv->out.red;
+            unsigned int out_blue = vf->priv->out.blue;
+            unsigned int out_has_a = (out_bypp == 4);
+
+            for (y = 0; y < vf->priv->out.height; y++) {
+                o   = vf->priv->out.stride * y;
+                il  = vf->priv->in.off_left  + (y / vf->priv->in.hres) *
+                      vf->priv->in.stride;
+                ir  = vf->priv->in.off_right + (y / vf->priv->in.hres) *
+                      vf->priv->in.stride;
+                for (x = 0; x < vf->priv->out.width; x++) {
+                    rl  = mpi->planes[0][il    ];
+                    gl  = mpi->planes[0][il + 1];
+                    bl  = mpi->planes[0][il + 2];
+                    rr  = mpi->planes[0][ir    ];
+                    gr  = mpi->planes[0][ir + 1];
+                    br  = mpi->planes[0][ir + 2];
+                    dmpi->planes[0][o + out_red ]  = ana_convert(
+                        vf->priv->ana_matrix[0], rl, gl, bl, rr, gr, br);
+                    dmpi->planes[0][o + 1       ]  = ana_convert(
+                        vf->priv->ana_matrix[1], rl, gl, bl, rr, gr, br);
+                    dmpi->planes[0][o + out_blue]  = ana_convert(
+                        vf->priv->ana_matrix[2], rl, gl, bl, rr, gr, br);
+                    if(out_has_a) dmpi->planes[0][o + 3]  = 0;
+                    il += 3;
+                    ir += 3;
+                    o  += out_bypp;
+                }
+            }
+            break;
+        }
+        default:
+            mp_msg(MSGT_VFILTER, MSGL_WARN,
+                   "[stereo3d] stereo format of output is not supported\n");
+            return 0;
+            break;
+        }
+    }
+    return vf_next_put_image(vf, dmpi, pts);
+}
+
+static int query_format(struct vf_instance *vf, unsigned int fmt)
+{
+    if (fmt == IMGFMT_RGB24)
+        return vf_next_query_format(vf, find_best_out(vf));
+    return 0;
+}
+
+static void uninit(vf_instance_t *vf)
+{
+    free(vf->priv);
+}
+
+static int vf_open(vf_instance_t *vf, char *args)
+{
+    vf->config          = config;
+    vf->uninit          = uninit;
+    vf->put_image       = put_image;
+    vf->query_format    = query_format;
+    vf->default_reqs    = VFCAP_ACCEPT_STRIDE;
+
+    return 1;
+}
+
+///Presets usage
+static const struct format_preset {
+  char* name;
+  stereo_code scode;
+} vf_format_presets_defs[] = {
+    {"arcg",                             ANAGLYPH_RC_GRAY},
+    {"anaglyph_red_cyan_gray",           ANAGLYPH_RC_GRAY},
+    {"arch",                             ANAGLYPH_RC_HALF},
+    {"anaglyph_red_cyan_half_color",     ANAGLYPH_RC_HALF},
+    {"arcc",                             ANAGLYPH_RC_COLOR},
+    {"anaglyph_red_cyan_color",          ANAGLYPH_RC_COLOR},
+    {"arcd",                             ANAGLYPH_RC_DUBOIS},
+    {"anaglyph_red_cyan_dubios",         ANAGLYPH_RC_DUBOIS},
+    {"agmg",                             ANAGLYPH_GM_GRAY},
+    {"anaglyph_green_magenta_gray",      ANAGLYPH_GM_GRAY},
+    {"agmh",                             ANAGLYPH_GM_HALF},
+    {"anaglyph_green_magenta_half_color",ANAGLYPH_GM_HALF},
+    {"agmc",                             ANAGLYPH_GM_COLOR},
+    {"anaglyph_green_magenta_color",     ANAGLYPH_GM_COLOR},
+    {"aybg",                             ANAGLYPH_YB_GRAY},
+    {"anaglyph_yellow_blue_gray",        ANAGLYPH_YB_GRAY},
+    {"aybh",                             ANAGLYPH_YB_HALF},
+    {"anaglyph_yellow_blue_half_color",  ANAGLYPH_YB_HALF},
+    {"aybc",                             ANAGLYPH_YB_COLOR},
+    {"anaglyph_yellow_blue_color",       ANAGLYPH_YB_COLOR},
+    {"ml",                               MONO_L},
+    {"mono_left",                        MONO_L},
+    {"mr",                               MONO_R},
+    {"mono_right",                       MONO_R},
+    {"sbsl",                             SIDE_BY_SIDE_LR},
+    {"side_by_side_left_first",          SIDE_BY_SIDE_LR},
+    {"sbsr",                             SIDE_BY_SIDE_RL},
+    {"side_by_side_right_first",         SIDE_BY_SIDE_RL},
+    {"abl",                              ABOVE_BELOW_LR},
+    {"above_below_left_first",           ABOVE_BELOW_LR},
+    {"abr",                              ABOVE_BELOW_RL},
+    {"above_below_right_first",          ABOVE_BELOW_RL},
+    {"ab2l",                               ABOVE_BELOW_2_LR},
+    {"above_below_half_height_left_first", ABOVE_BELOW_2_LR},
+    {"ab2r",                               ABOVE_BELOW_2_RL},
+    {"above_below_half_height_right_first",ABOVE_BELOW_2_RL},
+    { NULL, 0}
+};
+
+#define ST_OFF(f) M_ST_OFF(struct format_preset,f)
+static const m_option_t vf_format_preset_fields_in[] = {
+  {"in", ST_OFF(scode), CONF_TYPE_INT, 0,0,0, NULL},
+  { NULL, NULL, 0, 0, 0, 0,  NULL }
+};
+static const m_option_t vf_format_preset_fields_out[] = {
+  {"out", ST_OFF(scode), CONF_TYPE_INT, 0,0,0, NULL},
+  { NULL, NULL, 0, 0, 0, 0,  NULL }
+};
+
+static const m_struct_t vf_format_preset_in = {
+  "stereo_format_preset_in",
+  sizeof(struct format_preset),
+  NULL,
+  vf_format_preset_fields_in
+};
+static const m_struct_t vf_format_preset_out = {
+  "stereo_format_preset_out",
+  sizeof(struct format_preset),
+  NULL,
+  vf_format_preset_fields_out
+};
+
+static const m_struct_t vf_opts;
+static const m_obj_presets_t format_preset_in = {
+  (struct m_struct_st*)&vf_format_preset_in,
+  (struct m_struct_st*)&vf_opts,
+  (struct format_preset*)vf_format_presets_defs,
+  ST_OFF(name)
+};
+static const m_obj_presets_t format_preset_out = {
+  (struct m_struct_st*)&vf_format_preset_out,
+  (struct m_struct_st*)&vf_opts,
+  (struct format_preset*)vf_format_presets_defs,
+  ST_OFF(name)
+};
+
+/// Now the options
+#undef ST_OFF
+#define ST_OFF(f) M_ST_OFF(struct vf_priv_s,f)
+static const m_option_t vf_opts_fields[] = {
+  {"stereo_in", 0, CONF_TYPE_OBJ_PRESETS, 0, 0, 0,
+                   (m_obj_presets_t*)&format_preset_in},
+  {"stereo_out", 0, CONF_TYPE_OBJ_PRESETS, 0, 0, 0,
+                   (m_obj_presets_t*)&format_preset_out},
+  {"in", ST_OFF(in.fmt), CONF_TYPE_INT, 0,0,0, NULL},
+  {"out", ST_OFF(out.fmt), CONF_TYPE_INT, 0,0,0, NULL},
+  { NULL, NULL, 0, 0, 0, 0,  NULL }
+};
+
+static const m_struct_t vf_opts = {
+  "stereo3d",
+  sizeof(struct vf_priv_s),
+  &vf_priv_default,
+  vf_opts_fields
+};
+
+
+//==info struct==//
+const vf_info_t vf_info_stereo3d = {
+    "stereoscopic 3d view",
+    "stereo3d",
+    "Gordon Schmidt",
+    "view stereoscopic videos",
+    vf_open,
+    &vf_opts
+};
Index: libmpcodecs/vf.c
===================================================================
--- libmpcodecs/vf.c	(revision 32510)
+++ libmpcodecs/vf.c	(working copy)
@@ -118,6 +118,7 @@
 extern const vf_info_t vf_info_geq;
 extern const vf_info_t vf_info_ow;
 extern const vf_info_t vf_info_fixpts;
+extern const vf_info_t vf_info_stereo3d;
 
 // list of available filters:
 static const vf_info_t* const filter_list[]={
@@ -208,6 +209,7 @@
     &vf_info_blackframe,
     &vf_info_ow,
     &vf_info_fixpts,
+    &vf_info_stereo3d,
     NULL
 };
 
Index: Makefile
===================================================================
--- Makefile	(revision 32510)
+++ Makefile	(working copy)
@@ -454,6 +454,7 @@
               libmpcodecs/vf_scale.c \
               libmpcodecs/vf_smartblur.c \
               libmpcodecs/vf_softpulldown.c \
+              libmpcodecs/vf_stereo3d.c \
               libmpcodecs/vf_softskip.c \
               libmpcodecs/vf_swapuv.c \
               libmpcodecs/vf_telecine.c \
Index: DOCS/man/en/mplayer.1
===================================================================
--- DOCS/man/en/mplayer.1	(revision 32510)
+++ DOCS/man/en/mplayer.1	(working copy)
@@ -7599,8 +7599,104 @@
 .IPs <threshold>
 Threshold below which a pixel value is considered black (default: 32).
 .RE
+.PD 1
 .
 .TP
+.B stereo3d[=in:out]
+Stereo3d converts between different stereoscopic image formats.
+.RSs
+.IPs <in>
+Stereoscopic image format of input. Possible values:
+.RS
+.B sbsl or side_by_side_left_first
+.RS
+side by side parallel (left eye left, right eye right)
+.RE
+.B sbsr or side_by_side_right_first
+.RS
+side by side crosseye (right eye left, left eye right)
+.RE
+.B abl or above_below_left_first
+.RS
+above-below (left eye above, right eye below)
+.RE
+.B abl or above_below_right_first
+.RS
+above-below (right eye above, left eye below)
+.RE
+.B ab2l or above_below_half_height_left_first
+.RS
+above-below with half height resolution (left eye above, right eye below)
+.RE
+.B ab2r or above_below_half_height_right_first
+.RS
+above-below with half height resolution (right eye above, left eye below)
+.RE
+.RE
+.IPs <out>
+Stereoscopic image format of output. Possible values are all the input formats
+as well as:
+.RS
+.B arcg or anaglyph_red_cyan_gray
+.RS
+anaglyph red/cyan gray (red filter on left eye, cyan filter on right eye)
+.RE
+.B arch or anaglyph_red_cyan_half_color
+.RS
+anaglyph red/cyan half colored (red filter on left eye, cyan filter on right
+eye)
+.RE
+.B arcc or anaglyph_red_cyan_color
+.RS
+anaglyph red/cyan color (red filter on left eye, cyan filter on right eye)
+.RE
+.B arcd or anaglyph_red_cyan_dubois
+.RS
+anaglyph red/cyan color optimized with the least squares projection of dubois
+(red filter on left eye, cyan filter on right eye)
+.RE
+.B agmg or anaglyph_green_magenta_gray
+.RS
+anaglyph green/magenta gray (green filter on left eye, magenta filter on right
+eye)
+.RE
+.B agmh or anaglyph_green_magenta_half_color
+.RS
+anaglyph green/magenta half colored (green filter on left eye, magenta filter on
+right eye)
+.RE
+.B agmc or anaglyph_green_magenta_color
+.RS
+anaglyph green/magenta colored (green filter on left eye, magenta filter on
+right eye)
+.RE
+.B aybg or anaglyph_yellow_blue_gray
+.RS
+anaglyph yellow/blue gray (yellow filter on left eye, blue filter on right eye)
+.RE
+.B aybh or anaglyph_yellow_blue_half_color
+.RS
+anaglyph yellow/blue half colored (yellow filter on left eye, blue filter on
+right eye)
+.RE
+.B aybc or anaglyph_yellow_blue_color
+.RS
+anaglyph yellow/blue colored (yellow filter on left eye, blue filter on right
+eye)
+.RE
+.B ml or mono_left
+.RS
+mono output (left eye only)
+.RE
+.B mr or mono_right
+.RS
+mono output (right eye only)
+.RE
+.RE
+.RE
+.PD 1
+.
+.TP
 .B gradfun[=strength[:radius]]
 Fix the banding artifacts that are sometimes introduced into nearly flat
 regions by truncation to 8bit colordepth.
Index: DOCS/man/de/mplayer.1
===================================================================
--- DOCS/man/de/mplayer.1	(revision 32510)
+++ DOCS/man/de/mplayer.1	(working copy)
@@ -7547,9 +7547,106 @@
 Schwellenwert, unter dem ein Pixelwert als schwarz angenommen wird
 (Standard: 32).
 .RE
+.PD 1
 .
+.TP
+.B stereo3d[=in:out]
+Stereo3d wandelt zwischen verschiedenen stereoskopischen Bildformaten um.
+.RSs
+.IPs <in>
+Stereoskopisches Eingabeformat. Mögliche Werte:
+.RS
+.B sbsl oder side_by_side_left_first
+.RS
+nebeneinander parallel (linkes Auge links, rechtes Auge rechts)
+.RE
+.B sbsr oder side_by_side_right_first
+.RS
+nebeneinander gekreuzt (rechtes Auge links, linkes Auge rechts)
+.RE
+.B abl oder above_below_left_first
+.RS
+oben-unten (linkes Auge oben, rechtes Auge unten)
+.RE
+.B abl oder above_below_right_first
+.RS
+oben-unten (rechtes Auge oben, linkes Auge unten)
+.RE
+.B ab2l oder above_below_half_height_left_first
+.RS
+oben-unten mit halber Höhenauflösung (linkes Auge oben, rechtes Auge unten)
+.RE
+.B ab2r oder above_below_half_height_right_first
+.RS
+oben-unten mit halber Höhenauflösung (rechtes Auge oben, linkes Auge unten)
+.RE
+.RE
+.IPs <out>
+Stereoskopisches Ausgabeformat. Mögliche Werte sind alle Eingabeformate, sowie:
+.RS
+.B arcg oder anaglyph_red_cyan_gray
+.RS
+anaglyph rot/cyan grau (roter Filter auf dem linken Auge, cyan Filter auf dem
+rechten Auge)
+.RE
+.B arch oder anaglyph_red_cyan_half_color
+.RS
+anaglyph rot/cyan halbfarbig (roter Filter auf dem linken Auge, cyan Filter auf
+dem rechten Auge)
+.RE
+.B arcc oder anaglyph_red_cyan_color
+.RS
+anaglyph rot/cyan farbig (roter Filter auf dem linken Auge, cyan Filter auf dem
+rechten Auge)
+.RE
+.B arcd oder anaglyph_red_cyan_dubios
+.RS
+anaglyph red/cyan farbig optimiert mit der Least-Squares-Projektion von Dubois
+(roter Filter auf dem linken Auge, cyan Filter auf dem rechten Auge)
+.RE
+.B agmg oder anaglyph_green_magenta_gray
+.RS
+anaglyph grün/magenta grau (grüner Filter auf dem linken Auge, magenta Filter
+auf dem rechten Auge)
+.RE
+.B agmh oder anaglyph_green_magenta_half_color
+.RS
+anaglyph grün/magenta halbfarbig (grüner Filter auf dem linken Auge, magenta
+Filter auf dem rechten Auge)
+.RE
+.B agmc oder anaglyph_green_magenta_color
+.RS
+anaglyph grün/magenta farbig (grüner Filter auf dem linken Auge, magenta Filter
+auf dem rechten Auge)
+.RE
+.B aybg oder anaglyph_yellow_blue_gray
+.RS
+anaglyph gelb/blau grau (gelber Filter auf dem linken Auge, blauer Filter auf
+dem rechten Auge)
+.RE
+.B aybh oder anaglyph_yellow_blue_half_color
+.RS
+anaglyph gelb/blau halbfarbig (gelber Filter auf dem linken Auge, blauer Filter
+auf dem rechten Auge)
+.RE
+.B aybc oder anaglyph_yellow_blue_color
+.RS
+anaglyph gelb/blau farbig (gelber Filter auf dem linken Auge, blauer Filter auf
+dem rechten Auge)
+.RE
+.B ml oder mono_left
+.RS
+mono Ausgabe (nur linkes Auge)
+.RE
+.B mr oder mono_right
+.RS
+mono Ausgabe (nur rechtes Auge)
+.RE
+.RE
+.RE
 .
 .
+.
 .SH "ALLGEMEINE ENCODING-OPTIONEN (NUR BEI MENCODER)"
 .
 .TP


More information about the MPlayer-dev-eng mailing list