postproc.c 13.2 KB
Newer Older
1 2 3
/*****************************************************************************
 * postproc.c: video postprocessing using libpostproc
 *****************************************************************************
Jean-Baptiste Kempf's avatar
Jean-Baptiste Kempf committed
4
 * Copyright (C) 1999-2009 VLC authors and VideoLAN
5 6 7 8 9 10
 * $Id$
 *
 * Authors: Laurent Aimar <fenrir@via.ecp.fr>
 *          Gildas Bazin <gbazin@netcourrier.com>
 *          Antoine Cellerier <dionoea at videolan dot org>
 *
Jean-Baptiste Kempf's avatar
Jean-Baptiste Kempf committed
11 12 13
 * 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
14 15 16 17
 * (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
Jean-Baptiste Kempf's avatar
Jean-Baptiste Kempf committed
18 19
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU Lesser General Public License for more details.
20
 *
Jean-Baptiste Kempf's avatar
Jean-Baptiste Kempf committed
21 22 23
 * 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.
24 25
 *****************************************************************************/

Jean-Baptiste Kempf's avatar
Jean-Baptiste Kempf committed
26 27 28 29 30 31 32 33
/*****************************************************************************
 * NOTA BENE: this module requires the linking against a library which is
 * known to require licensing under the GNU General Public License version 2
 * (or later). Therefore, the result of compiling this module will normally
 * be subject to the terms of that later license.
 *****************************************************************************/


34 35 36 37 38 39
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif

#include <vlc_common.h>
#include <vlc_plugin.h>
40
#include <vlc_filter.h>
Rémi Denis-Courmont's avatar
Rémi Denis-Courmont committed
41
#include <vlc_cpu.h>
42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69

#include "filter_picture.h"

#ifdef HAVE_POSTPROC_POSTPROCESS_H
#   include <postproc/postprocess.h>
#else
#   include <libpostproc/postprocess.h>
#endif

#ifndef PP_CPU_CAPS_ALTIVEC
#   define PP_CPU_CAPS_ALTIVEC 0
#endif

/*****************************************************************************
 * Local prototypes
 *****************************************************************************/
static int OpenPostproc( vlc_object_t * );
static void ClosePostproc( vlc_object_t * );

static picture_t *PostprocPict( filter_t *, picture_t * );

static int PPQCallback( vlc_object_t *, char const *,
                        vlc_value_t, vlc_value_t, void * );
static int PPNameCallback( vlc_object_t *, char const *,
                           vlc_value_t, vlc_value_t, void * );

#define Q_TEXT N_("Post processing quality")
#define Q_LONGTEXT N_( \
70 71 72 73
    "Quality of post processing. Valid range is 0 (disabled) to 6 (highest)\n"     \
    "Higher levels require more CPU power, but produce higher quality pictures.\n" \
    "With default filter chain, the values map to the following filters:\n"        \
    "1: hb, 2-4: hb+vb, 5-6: hb+vb+dr" )
74 75

#define NAME_TEXT N_("FFmpeg post processing filter chains")
76
#define NAME_LONGTEXT NAME_TEXT
77 78 79 80 81 82

#define FILTER_PREFIX "postproc-"

/*****************************************************************************
 * Module descriptor
 *****************************************************************************/
83 84
vlc_module_begin ()
    set_description( N_("Video post processing filter") )
85
    set_shortname( N_("Postproc" ) )
86
    add_shortcut( "postprocess", "pp" ) /* name is "postproc" */
87 88
    set_category( CAT_VIDEO )
    set_subcategory( SUBCAT_VIDEO_VFILTER )
89

90
    set_capability( "video filter", 0 )
91

92
    set_callbacks( OpenPostproc, ClosePostproc )
93 94

    add_integer_with_range( FILTER_PREFIX "q", PP_QUALITY_MAX, 0,
95
                            PP_QUALITY_MAX, Q_TEXT, Q_LONGTEXT, false )
96
        change_safe()
97
    add_string( FILTER_PREFIX "name", "default", NAME_TEXT,
Rémi Denis-Courmont's avatar
Rémi Denis-Courmont committed
98
                NAME_LONGTEXT, true )
99
vlc_module_end ()
100 101 102 103 104 105 106 107 108 109

static const char *const ppsz_filter_options[] = {
    "q", "name", NULL
};

/*****************************************************************************
 * filter_sys_t : libpostproc video postprocessing descriptor
 *****************************************************************************/
struct filter_sys_t
{
110
    /* Never changes after init */
111
    pp_context *pp_context;
112

113
    /* Set to NULL if post processing is disabled */
114
    pp_mode *pp_mode;
115

116 117
    /* Lock when using or changing pp_mode */
    vlc_mutex_t lock;
118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139
};


/*****************************************************************************
 * OpenPostproc: probe and open the postproc
 *****************************************************************************/
static int OpenPostproc( vlc_object_t *p_this )
{
    filter_t *p_filter = (filter_t *)p_this;
    filter_sys_t *p_sys;
    vlc_value_t val, val_orig, text;
    int i_flags = 0;

    if( p_filter->fmt_in.video.i_chroma != p_filter->fmt_out.video.i_chroma ||
        p_filter->fmt_in.video.i_height != p_filter->fmt_out.video.i_height ||
        p_filter->fmt_in.video.i_width != p_filter->fmt_out.video.i_width )
    {
        msg_Err( p_filter, "Filter input and output formats must be identical" );
        return VLC_EGENERIC;
    }

    /* Set CPU capabilities */
140
#if defined(__i386__) || defined(__x86_64__)
141
    if( vlc_CPU_MMX() )
142
        i_flags |= PP_CPU_CAPS_MMX;
143
    if( vlc_CPU_MMXEXT() )
144
        i_flags |= PP_CPU_CAPS_MMX2;
145
    if( vlc_CPU_3dNOW() )
146
        i_flags |= PP_CPU_CAPS_3DNOW;
147
#elif defined(__ppc__) || defined(__ppc64__) || defined(__powerpc__)
148
    if( vlc_CPU_ALTIVEC() )
149
        i_flags |= PP_CPU_CAPS_ALTIVEC;
150
#endif
151 152 153

    switch( p_filter->fmt_in.video.i_chroma )
    {
154 155
        case VLC_CODEC_I444:
        case VLC_CODEC_J444:
156 157 158 159
        /* case VLC_CODEC_YUVA:
           FIXME: Should work but alpha plane needs to be copied manually and
                  I'm kind of feeling too lazy to write the code to do that ATM
                  (i_pitch vs i_visible_pitch...). */
160 161
            i_flags |= PP_FORMAT_444;
            break;
162 163
        case VLC_CODEC_I422:
        case VLC_CODEC_J422:
164 165
            i_flags |= PP_FORMAT_422;
            break;
166
        case VLC_CODEC_I411:
167 168
            i_flags |= PP_FORMAT_411;
            break;
169 170 171
        case VLC_CODEC_I420:
        case VLC_CODEC_J420:
        case VLC_CODEC_YV12:
172 173 174
            i_flags |= PP_FORMAT_420;
            break;
        default:
175
            msg_Err( p_filter, "Unsupported input chroma (%4.4s)",
176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196
                      (char*)&p_filter->fmt_in.video.i_chroma );
            return VLC_EGENERIC;
    }

    p_sys = malloc( sizeof( filter_sys_t ) );
    if( !p_sys ) return VLC_ENOMEM;
    p_filter->p_sys = p_sys;

    p_sys->pp_context = pp_get_context( p_filter->fmt_in.video.i_width,
                                        p_filter->fmt_in.video.i_height,
                                        i_flags );
    if( !p_sys->pp_context )
    {
        msg_Err( p_filter, "Error while creating post processing context." );
        free( p_sys );
        return VLC_EGENERIC;
    }

    config_ChainParse( p_filter, FILTER_PREFIX, ppsz_filter_options,
                       p_filter->p_cfg );

197 198
    var_Create( p_filter, FILTER_PREFIX "q", VLC_VAR_INTEGER |
                VLC_VAR_HASCHOICE | VLC_VAR_DOINHERIT | VLC_VAR_ISCOMMAND );
199

200 201 202 203 204 205
    text.psz_string = _("Post processing");
    var_Change( p_filter, FILTER_PREFIX "q", VLC_VAR_SETTEXT, &text, NULL );

    var_Get( p_filter, FILTER_PREFIX "q", &val_orig );
    var_Change( p_filter, FILTER_PREFIX "q", VLC_VAR_DELCHOICE, &val_orig, NULL );

206
    val.psz_string = var_GetNonEmptyString( p_filter, FILTER_PREFIX "name" );
207 208
    if( val_orig.i_int )
    {
Rémi Denis-Courmont's avatar
Rémi Denis-Courmont committed
209 210
        p_sys->pp_mode = pp_get_mode_by_name_and_quality( val.psz_string ?
                                                          val.psz_string :
211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249
                                                          "default",
                                                          val_orig.i_int );

        if( !p_sys->pp_mode )
        {
            msg_Err( p_filter, "Error while creating post processing mode." );
            free( val.psz_string );
            pp_free_context( p_sys->pp_context );
            free( p_sys );
            return VLC_EGENERIC;
        }
    }
    else
    {
        p_sys->pp_mode = NULL;
    }
    free( val.psz_string );

    for( val.i_int = 0; val.i_int <= PP_QUALITY_MAX; val.i_int++ )
    {
        switch( val.i_int )
        {
            case 0:
                text.psz_string = _("Disable");
                break;
            case 1:
                text.psz_string = _("Lowest");
                break;
            case PP_QUALITY_MAX:
                text.psz_string = _("Highest");
                break;
            default:
                text.psz_string = NULL;
                break;
        }
        var_Change( p_filter, FILTER_PREFIX "q", VLC_VAR_ADDCHOICE,
                    &val, text.psz_string?&text:NULL );
    }

250 251 252 253 254
    vlc_mutex_init( &p_sys->lock );

    /* Add the callback at the end to prevent crashes */
    var_AddCallback( p_filter, FILTER_PREFIX "q", PPQCallback, NULL );
    var_AddCallback( p_filter, FILTER_PREFIX "name", PPNameCallback, NULL );
255 256 257

    p_filter->pf_video_filter = PostprocPict;

258 259
    msg_Warn( p_filter, "Quantification table was not set by video decoder. "
                        "Postprocessing won't look good." );
260 261 262 263 264 265 266 267 268 269
    return VLC_SUCCESS;
}

/*****************************************************************************
 * ClosePostproc
 *****************************************************************************/
static void ClosePostproc( vlc_object_t *p_this )
{
    filter_t *p_filter = (filter_t *)p_this;
    filter_sys_t *p_sys = p_filter->p_sys;
270

271 272 273 274 275
    /* delete the callback before destroying the mutex */
    var_DelCallback( p_filter, FILTER_PREFIX "q", PPQCallback, NULL );
    var_DelCallback( p_filter, FILTER_PREFIX "name", PPNameCallback, NULL );

    /* Destroy the resources */
276 277
    vlc_mutex_destroy( &p_sys->lock );
    pp_free_context( p_sys->pp_context );
278
    pp_free_mode( p_sys->pp_mode );
279 280 281 282 283 284 285 286 287 288
    free( p_sys );
}

/*****************************************************************************
 * PostprocPict
 *****************************************************************************/
static picture_t *PostprocPict( filter_t *p_filter, picture_t *p_pic )
{
    filter_sys_t *p_sys = p_filter->p_sys;

289 290 291 292 293 294 295
    picture_t *p_outpic = filter_NewPicture( p_filter );
    if( !p_outpic )
    {
        picture_Release( p_pic );
        return NULL;
    }

296 297
    /* Lock to prevent issues if pp_mode is changed */
    vlc_mutex_lock( &p_sys->lock );
298
    if( p_sys->pp_mode != NULL )
299
    {
300 301 302
        const uint8_t *src[3];
        uint8_t *dst[3];
        int i_src_stride[3], i_dst_stride[3];
303

304 305 306 307
        for( int i_plane = 0; i_plane < p_pic->i_planes; i_plane++ )
        {
            src[i_plane] = p_pic->p[i_plane].p_pixels;
            dst[i_plane] = p_outpic->p[i_plane].p_pixels;
308

309 310 311 312 313
            /* I'm not sure what happens if i_pitch != i_visible_pitch ...
             * at least it shouldn't crash. */
            i_src_stride[i_plane] = p_pic->p[i_plane].i_pitch;
            i_dst_stride[i_plane] = p_outpic->p[i_plane].i_pitch;
        }
314

315 316 317 318
        pp_postprocess( src, i_src_stride, dst, i_dst_stride,
                        p_filter->fmt_in.video.i_width,
                        p_filter->fmt_in.video.i_height, NULL, 0,
                        p_sys->pp_mode, p_sys->pp_context, 0 );
319
    }
320 321
    else
        picture_CopyPixels( p_outpic, p_pic );
322 323 324 325 326 327
    vlc_mutex_unlock( &p_sys->lock );

    return CopyInfoAndRelease( p_outpic, p_pic );
}

/*****************************************************************************
328
 * PPChangeMode: change the current mode and quality
329 330 331 332 333
 *****************************************************************************/
static void PPChangeMode( filter_t *p_filter, const char *psz_name,
                          int i_quality )
{
    filter_sys_t *p_sys = p_filter->p_sys;
334 335
    pp_mode *newmode = NULL, *oldmode;

336 337
    if( i_quality > 0 )
    {
338 339 340 341 342 343 344
         newmode = pp_get_mode_by_name_and_quality( psz_name ? psz_name :
                                                    "default", i_quality );
         if( newmode == NULL )
         {
             msg_Warn( p_filter, "Error while changing post processing mode. "
                       "Keeping previous mode." );
             return;
345 346
        }
    }
347 348 349 350

    vlc_mutex_lock( &p_sys->lock );
    oldmode = p_sys->pp_mode;
    p_sys->pp_mode = newmode;
351
    vlc_mutex_unlock( &p_sys->lock );
352 353

    pp_free_mode( oldmode );
354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374
}

static int PPQCallback( vlc_object_t *p_this, const char *psz_var,
                        vlc_value_t oldval, vlc_value_t newval, void *p_data )
{
    VLC_UNUSED(psz_var); VLC_UNUSED(oldval); VLC_UNUSED(p_data);
    filter_t *p_filter = (filter_t *)p_this;

    char *psz_name = var_GetNonEmptyString( p_filter, FILTER_PREFIX "name" );
    PPChangeMode( p_filter, psz_name, newval.i_int );
    free( psz_name );
    return VLC_SUCCESS;
}

static int PPNameCallback( vlc_object_t *p_this, const char *psz_var,
                           vlc_value_t oldval, vlc_value_t newval, void *p_data )
{
    VLC_UNUSED(psz_var); VLC_UNUSED(oldval); VLC_UNUSED(p_data);
    filter_t *p_filter = (filter_t *)p_this;

    int i_quality = var_GetInteger( p_filter, FILTER_PREFIX "q" );
375 376
    PPChangeMode( p_filter, *newval.psz_string ? newval.psz_string : NULL,
                  i_quality );
377 378
    return VLC_SUCCESS;
}