← Back to branch summary

~ubuntu-branches/ubuntu/maverick/vlc/maverick

« back to all changes in this revision

Viewing changes to modules/video_filter/psychedelic.c

  • Committer: Bazaar Package Importer
  • Author(s): Reinhard Tartler
  • Date: 2008-09-17 21:56:14 UTC
  • mfrom: (1.1.17 upstream)
  • Revision ID: james.westby@ubuntu.com-20080917215614-tj0vx8xzd57e52t8
Tags: 0.9.2-1ubuntu1
https://launchpad.net/bugs/270404
https://launchpad.net/bugs/210354
https://launchpad.net/bugs/199870
https://launchpad.net/bugs/261567
* New Upstream Release, exception granted by
    - dktrkranz, norsetto, Hobbsee (via irc). LP: #270404

Changes done in ubuntu:

* add libxul-dev to build-depends
* make sure that vlc is build against libxul in configure. This doesn't
  change anything in the package, but makes it more robust if building
  in an 'unclean' chroot or when modifying the package.
* debian/control: make Vcs-* fields point to the motumedia branch
* add libx264-dev and libass-dev to build-depends
  LP: #210354, #199870
* actually enable libass support by passing --enable-libass to configure
* enable libdca: add libdca-dev to build depends and --enable-libdca
* install the x264 plugin.

Changes already in the pkg-multimedia branch in debian:

* don't install usr/share/vlc/mozilla in debian/mozilla-plugin-vlc.install  
* new upstream .desktop file now registers flash video mimetype LP: #261567
* add Xb-Npp-Applications to mozilla-plugin-vlc
* remove duplicate entries in debian/vlc-nox.install

Show diffs side-by-side

added added

removed removed

Lines of Context:
modules/video_filter/psychedelic.c
 
1
/*****************************************************************************
 
2
 * Psychedelic.c : Psychedelic video effect plugin for vlc
 
3
 *****************************************************************************
 
4
 * Copyright (C) 2000-2006 the VideoLAN team
 
5
 * $Id$
 
6
 *
 
7
 * Authors: Samuel Hocevar <sam@zoy.org>
 
8
 *          Antoine Cellerier <dionoea -at- videolan -dot- org>
 
9
 *
 
10
 * This program is free software; you can redistribute it and/or modify
 
11
 * it under the terms of the GNU General Public License as published by
 
12
 * the Free Software Foundation; either version 2 of the License, or
 
13
 * (at your option) any later version.
 
14
 *
 
15
 * This program is distributed in the hope that it will be useful,
 
16
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 
17
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
18
 * GNU General Public License for more details.
 
19
 *
 
20
 * You should have received a copy of the GNU General Public License
 
21
 * along with this program; if not, write to the Free Software
 
22
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
 
23
 *****************************************************************************/
 
24
 
 
25
/*****************************************************************************
 
26
 * Preamble
 
27
 *****************************************************************************/
 
28
 
 
29
#ifdef HAVE_CONFIG_H
 
30
# include "config.h"
 
31
#endif
 
32
 
 
33
#include <math.h>                                            /* sin(), cos() */
 
34
 
 
35
#include <vlc_common.h>
 
36
#include <vlc_plugin.h>
 
37
 
 
38
#include "vlc_filter.h"
 
39
#include "vlc_image.h"
 
40
#include "filter_picture.h"
 
41
 
 
42
/*****************************************************************************
 
43
 * Local prototypes
 
44
 *****************************************************************************/
 
45
static int  Create    ( vlc_object_t * );
 
46
static void Destroy   ( vlc_object_t * );
 
47
 
 
48
static picture_t *Filter( filter_t *, picture_t * );
 
49
 
 
50
/*****************************************************************************
 
51
 * Module descriptor
 
52
 *****************************************************************************/
 
53
vlc_module_begin();
 
54
    set_description( N_("Psychedelic video filter") );
 
55
    set_shortname( N_( "Psychedelic" ));
 
56
    set_capability( "video filter2", 0 );
 
57
    set_category( CAT_VIDEO );
 
58
    set_subcategory( SUBCAT_VIDEO_VFILTER );
 
59
 
 
60
    add_shortcut( "psychedelic" );
 
61
    set_callbacks( Create, Destroy );
 
62
vlc_module_end();
 
63
 
 
64
/*****************************************************************************
 
65
 * vout_sys_t: Distort video output method descriptor
 
66
 *****************************************************************************
 
67
 * This structure is part of the video output thread descriptor.
 
68
 * It describes the Distort specific properties of an output thread.
 
69
 *****************************************************************************/
 
70
struct filter_sys_t
 
71
{
 
72
    image_handler_t *p_image;
 
73
    unsigned int x, y, scale;
 
74
    int xinc, yinc, scaleinc;
 
75
    uint8_t u,v;
 
76
};
 
77
 
 
78
/*****************************************************************************
 
79
 * Create: allocates Distort video thread output method
 
80
 *****************************************************************************
 
81
 * This function allocates and initializes a Distort vout method.
 
82
 *****************************************************************************/
 
83
static int Create( vlc_object_t *p_this )
 
84
{
 
85
    filter_t *p_filter = (filter_t *)p_this;
 
86
 
 
87
    /* Allocate structure */
 
88
    p_filter->p_sys = malloc( sizeof( filter_sys_t ) );
 
89
    if( p_filter->p_sys == NULL )
 
90
        return VLC_ENOMEM;
 
91
 
 
92
    p_filter->pf_video_filter = Filter;
 
93
 
 
94
    p_filter->p_sys->x = 10;
 
95
    p_filter->p_sys->y = 10;
 
96
    p_filter->p_sys->scale = 1;
 
97
    p_filter->p_sys->xinc = 1;
 
98
    p_filter->p_sys->yinc = 1;
 
99
    p_filter->p_sys->scaleinc = 1;
 
100
    p_filter->p_sys->u = 0;
 
101
    p_filter->p_sys->v = 0;
 
102
    p_filter->p_sys->p_image = NULL;
 
103
 
 
104
    return VLC_SUCCESS;
 
105
}
 
106
 
 
107
/*****************************************************************************
 
108
 * Destroy: destroy Distort video thread output method
 
109
 *****************************************************************************
 
110
 * Terminate an output method created by DistortCreateOutputMethod
 
111
 *****************************************************************************/
 
112
static void Destroy( vlc_object_t *p_this )
 
113
{
 
114
    filter_t *p_filter = (filter_t *)p_this;
 
115
 
 
116
    if( p_filter->p_sys->p_image )
 
117
        image_HandlerDelete( p_filter->p_sys->p_image );
 
118
    p_filter->p_sys->p_image = NULL;
 
119
 
 
120
    free( p_filter->p_sys );
 
121
}
 
122
 
 
123
/*****************************************************************************
 
124
 * Render: displays previously rendered output
 
125
 *****************************************************************************
 
126
 * This function send the currently rendered image to Distort image, waits
 
127
 * until it is displayed and switch the two rendering buffers, preparing next
 
128
 * frame.
 
129
 *****************************************************************************/
 
130
static picture_t *Filter( filter_t *p_filter, picture_t *p_pic )
 
131
{
 
132
    picture_t *p_outpic;
 
133
 
 
134
    unsigned int w, h;
 
135
    int x,y;
 
136
    uint8_t u,v;
 
137
 
 
138
    picture_t *p_converted;
 
139
    video_format_t fmt_out;
 
140
    memset( &fmt_out, 0, sizeof(video_format_t) );
 
141
    fmt_out.p_palette = NULL;
 
142
 
 
143
    if( !p_pic ) return NULL;
 
144
 
 
145
    p_outpic = filter_NewPicture( p_filter );
 
146
    if( !p_outpic )
 
147
    {
 
148
        picture_Release( p_pic );
 
149
        return NULL;
 
150
    }
 
151
 
 
152
    if( !p_filter->p_sys->p_image )
 
153
        p_filter->p_sys->p_image = image_HandlerCreate( p_filter );
 
154
 
 
155
    /* chrominance */
 
156
    u = p_filter->p_sys->u;
 
157
    v = p_filter->p_sys->v;
 
158
    for( y = 0; y<p_outpic->p[U_PLANE].i_lines; y++)
 
159
    {
 
160
        vlc_memset(
 
161
                p_outpic->p[U_PLANE].p_pixels+y*p_outpic->p[U_PLANE].i_pitch,
 
162
                u, p_outpic->p[U_PLANE].i_pitch );
 
163
        vlc_memset(
 
164
                p_outpic->p[V_PLANE].p_pixels+y*p_outpic->p[V_PLANE].i_pitch,
 
165
                v, p_outpic->p[V_PLANE].i_pitch );
 
166
        if( v == 0 && u != 0 )
 
167
            u --;
 
168
        else if( u == 0xff )
 
169
            v --;
 
170
        else if( v == 0xff )
 
171
            u ++;
 
172
        else if( u == 0 )
 
173
            v ++;
 
174
    }
 
175
 
 
176
    /* luminance */
 
177
    vlc_memcpy( p_outpic->p[Y_PLANE].p_pixels, p_pic->p[Y_PLANE].p_pixels,
 
178
                p_outpic->p[Y_PLANE].i_lines * p_outpic->p[Y_PLANE].i_pitch );
 
179
 
 
180
    /* image visualization */
 
181
    fmt_out = p_filter->fmt_out.video;
 
182
    fmt_out.i_width = p_filter->fmt_out.video.i_width*p_filter->p_sys->scale/150;
 
183
    fmt_out.i_height = p_filter->fmt_out.video.i_height*p_filter->p_sys->scale/150;
 
184
    p_converted = image_Convert( p_filter->p_sys->p_image, p_pic,
 
185
                                 &(p_pic->format), &fmt_out );
 
186
 
 
187
    if( p_converted )
 
188
    {
 
189
#define copyimage( plane, b ) \
 
190
        for( y=0; y<p_converted->p[plane].i_visible_lines; y++) { \
 
191
        for( x=0; x<p_converted->p[plane].i_visible_pitch; x++) { \
 
192
            int nx, ny; \
 
193
            if( p_filter->p_sys->yinc == 1 ) \
 
194
                ny= y; \
 
195
            else \
 
196
                ny = p_converted->p[plane].i_visible_lines-y; \
 
197
            if( p_filter->p_sys->xinc == 1 ) \
 
198
                nx = x; \
 
199
            else \
 
200
                nx = p_converted->p[plane].i_visible_pitch-x; \
 
201
            p_outpic->p[plane].p_pixels[(p_filter->p_sys->x*b+nx)+(ny+p_filter->p_sys->y*b)*p_outpic->p[plane].i_pitch ] = p_converted->p[plane].p_pixels[y*p_converted->p[plane].i_pitch+x]; \
 
202
        } }
 
203
        copyimage( Y_PLANE, 2 );
 
204
        copyimage( U_PLANE, 1 );
 
205
        copyimage( V_PLANE, 1 );
 
206
#undef copyimage
 
207
 
 
208
        picture_Release( p_converted );
 
209
    }
 
210
    else
 
211
    {
 
212
        msg_Err( p_filter, "Image scaling failed miserably." );
 
213
    }
 
214
 
 
215
    p_filter->p_sys->x += p_filter->p_sys->xinc;
 
216
    p_filter->p_sys->y += p_filter->p_sys->yinc;
 
217
 
 
218
    p_filter->p_sys->scale += p_filter->p_sys->scaleinc;
 
219
    if( p_filter->p_sys->scale >= 50 ) p_filter->p_sys->scaleinc = -1;
 
220
    if( p_filter->p_sys->scale <= 1 ) p_filter->p_sys->scaleinc = 1;
 
221
 
 
222
    w = p_filter->fmt_out.video.i_width*p_filter->p_sys->scale/150;
 
223
    h = p_filter->fmt_out.video.i_height*p_filter->p_sys->scale/150;
 
224
    if( p_filter->p_sys->x*2 + w >= p_filter->fmt_out.video.i_width )
 
225
        p_filter->p_sys->xinc = -1;
 
226
    if( p_filter->p_sys->x <= 0 )
 
227
        p_filter->p_sys->xinc = 1;
 
228
 
 
229
    if( p_filter->p_sys->x*2 + w >= p_filter->fmt_out.video.i_width )
 
230
        p_filter->p_sys->x = (p_filter->fmt_out.video.i_width-w)/2;
 
231
    if( p_filter->p_sys->y*2 + h >= p_filter->fmt_out.video.i_height )
 
232
        p_filter->p_sys->y = (p_filter->fmt_out.video.i_height-h)/2;
 
233
 
 
234
    if( p_filter->p_sys->y*2 + h >= p_filter->fmt_out.video.i_height )
 
235
        p_filter->p_sys->yinc = -1;
 
236
    if( p_filter->p_sys->y <= 0 )
 
237
        p_filter->p_sys->yinc = 1;
 
238
 
 
239
    for( y = 0; y< 16; y++ )
 
240
    {
 
241
        if( p_filter->p_sys->v == 0 && p_filter->p_sys->u != 0 )
 
242
            p_filter->p_sys->u -= 1;
 
243
        else if( p_filter->p_sys->u == 0xff )
 
244
            p_filter->p_sys->v -= 1;
 
245
        else if( p_filter->p_sys->v == 0xff )
 
246
            p_filter->p_sys->u += 1;
 
247
        else if( p_filter->p_sys->u == 0 )
 
248
            p_filter->p_sys->v += 1;
 
249
    }
 
250
 
 
251
    return CopyInfoAndRelease( p_outpic, p_pic );
 
252
}