]> git.sesse.net Git - vlc/blob - modules/video_filter/invert.c
Use vlc_memset/vlc_memcpy
[vlc] / modules / video_filter / invert.c
1 /*****************************************************************************
2  * invert.c : Invert video plugin for vlc
3  *****************************************************************************
4  * Copyright (C) 2000-2006 the VideoLAN team
5  * $Id$
6  *
7  * Authors: Samuel Hocevar <sam@zoy.org>
8  *
9  * This program is free software; you can redistribute it and/or modify
10  * it under the terms of the GNU General Public License as published by
11  * the Free Software Foundation; either version 2 of the License, or
12  * (at your option) any later version.
13  *
14  * This program is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17  * GNU General Public License for more details.
18  *
19  * You should have received a copy of the GNU General Public License
20  * along with this program; if not, write to the Free Software
21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
22  *****************************************************************************/
23
24 /*****************************************************************************
25  * Preamble
26  *****************************************************************************/
27
28 #ifdef HAVE_CONFIG_H
29 # include "config.h"
30 #endif
31
32 #include <vlc/vlc.h>
33 #include <vlc_vout.h>
34
35 #include "vlc_filter.h"
36
37 /*****************************************************************************
38  * Local prototypes
39  *****************************************************************************/
40 static int  Create      ( vlc_object_t * );
41 static void Destroy     ( vlc_object_t * );
42
43 static picture_t *Filter( filter_t *, picture_t * );
44
45 /*****************************************************************************
46  * Module descriptor
47  *****************************************************************************/
48 vlc_module_begin();
49     set_description( _("Invert video filter") );
50     set_shortname( _("Color inversion" ));
51     set_category( CAT_VIDEO );
52     set_subcategory( SUBCAT_VIDEO_VFILTER );
53     set_capability( "video filter2", 0 );
54     add_shortcut( "invert" );
55     set_callbacks( Create, Destroy );
56 vlc_module_end();
57
58 /*****************************************************************************
59  * vout_sys_t: Invert video output method descriptor
60  *****************************************************************************
61  * This structure is part of the video output thread descriptor.
62  * It describes the Invert specific properties of an output thread.
63  *****************************************************************************/
64 struct filter_sys_t
65 {
66 };
67
68 /*****************************************************************************
69  * Create: allocates Invert video thread output method
70  *****************************************************************************
71  * This function allocates and initializes a Invert vout method.
72  *****************************************************************************/
73 static int Create( vlc_object_t *p_this )
74 {
75     filter_t *p_filter = (filter_t *)p_this;
76
77     /* Allocate structure */
78     p_filter->p_sys = malloc( sizeof( filter_sys_t ) );
79     if( p_filter->p_sys == NULL )
80     {
81         msg_Err( p_filter, "out of memory" );
82         return VLC_ENOMEM;
83     }
84
85     p_filter->pf_video_filter = Filter;
86
87     return VLC_SUCCESS;
88 }
89
90 /*****************************************************************************
91  * Destroy: destroy Invert video thread output method
92  *****************************************************************************
93  * Terminate an output method created by InvertCreateOutputMethod
94  *****************************************************************************/
95 static void Destroy( vlc_object_t *p_this )
96 {
97     filter_t *p_filter = (filter_t *)p_this;
98
99     free( p_filter->p_sys );
100 }
101
102 /*****************************************************************************
103  * Render: displays previously rendered output
104  *****************************************************************************
105  * This function send the currently rendered image to Invert image, waits
106  * until it is displayed and switch the two rendering buffers, preparing next
107  * frame.
108  *****************************************************************************/
109 static picture_t *Filter( filter_t *p_filter, picture_t *p_pic )
110 {
111     picture_t *p_outpic;
112     int i_index;
113     int i_planes;
114
115     if( !p_pic ) return NULL;
116
117     p_outpic = p_filter->pf_vout_buffer_new( p_filter );
118     if( !p_outpic )
119     {
120         msg_Warn( p_filter, "can't get output picture" );
121         if( p_pic->pf_release )
122             p_pic->pf_release( p_pic );
123         return NULL;
124     }
125
126     if( p_pic->format.i_chroma == VLC_FOURCC('Y','U','V','A') )
127     {
128         /* We don't want to invert the alpha plane */
129         i_planes = p_pic->i_planes - 1;
130         vlc_memcpy(
131             p_outpic->p[A_PLANE].p_pixels, p_pic->p[A_PLANE].p_pixels,
132             p_pic->p[A_PLANE].i_pitch *  p_pic->p[A_PLANE].i_lines );
133     }
134     else
135     {
136         i_planes = p_pic->i_planes;
137     }
138
139     for( i_index = 0 ; i_index < i_planes ; i_index++ )
140     {
141         uint8_t *p_in, *p_in_end, *p_line_end, *p_out;
142
143         p_in = p_pic->p[i_index].p_pixels;
144         p_in_end = p_in + p_pic->p[i_index].i_visible_lines
145                            * p_pic->p[i_index].i_pitch;
146
147         p_out = p_outpic->p[i_index].p_pixels;
148
149         for( ; p_in < p_in_end ; )
150         {
151             uint64_t *p_in64, *p_out64;
152
153             p_line_end = p_in + p_pic->p[i_index].i_visible_pitch - 64;
154
155             p_in64 = (uint64_t*)p_in;
156             p_out64 = (uint64_t*)p_out;
157
158             while( p_in64 < (uint64_t *)p_line_end )
159             {
160                 /* Do 64 pixels at a time */
161                 *p_out64++ = ~*p_in64++; *p_out64++ = ~*p_in64++;
162                 *p_out64++ = ~*p_in64++; *p_out64++ = ~*p_in64++;
163                 *p_out64++ = ~*p_in64++; *p_out64++ = ~*p_in64++;
164                 *p_out64++ = ~*p_in64++; *p_out64++ = ~*p_in64++;
165             }
166
167             p_in = (uint8_t*)p_in64;
168             p_out = (uint8_t*)p_out64;
169             p_line_end += 64;
170
171             for( ; p_in < p_line_end ; )
172             {
173                 *p_out++ = ~( *p_in++ );
174             }
175
176             p_in += p_pic->p[i_index].i_pitch
177                      - p_pic->p[i_index].i_visible_pitch;
178             p_out += p_outpic->p[i_index].i_pitch
179                      - p_outpic->p[i_index].i_visible_pitch;
180         }
181     }
182
183     p_outpic->date = p_pic->date;
184     p_outpic->b_force = p_pic->b_force;
185     p_outpic->i_nb_fields = p_pic->i_nb_fields;
186     p_outpic->b_progressive = p_pic->b_progressive;
187     p_outpic->b_top_field_first = p_pic->b_top_field_first;
188
189     if( p_pic->pf_release )
190         p_pic->pf_release( p_pic );
191
192     return p_outpic;
193 }