1 /*****************************************************************************
2 * rotate.c : video rotation filter
3 *****************************************************************************
4 * Copyright (C) 2000-2008 VLC authors and VideoLAN
7 * Authors: Antoine Cellerier <dionoea -at- videolan -dot- org>
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.
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.
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 *****************************************************************************/
24 /*****************************************************************************
26 *****************************************************************************/
32 #include <math.h> /* sin(), cos() */
34 #define VLC_MODULE_LICENSE VLC_LICENSE_GPL_2_PLUS
35 #include <vlc_common.h>
36 #include <vlc_plugin.h>
37 #include <vlc_atomic.h>
38 #include <vlc_filter.h>
39 #include <vlc_picture.h>
40 #include "filter_picture.h"
41 #include "../control/motionlib.h"
43 /*****************************************************************************
45 *****************************************************************************/
46 static int Create ( vlc_object_t
* );
47 static void Destroy ( vlc_object_t
* );
49 static picture_t
*Filter( filter_t
*, picture_t
* );
50 static picture_t
*FilterPacked( filter_t
*, picture_t
* );
52 static int RotateCallback( vlc_object_t
*p_this
, char const *psz_var
,
53 vlc_value_t oldval
, vlc_value_t newval
,
56 #define ANGLE_TEXT N_("Angle in degrees")
57 #define ANGLE_LONGTEXT N_("Angle in degrees (0 to 359)")
58 #define MOTION_TEXT N_("Use motion sensors")
59 #define MOTION_LONGTEXT N_("Use HDAPS, AMS, APPLESMC or UNIMOTION motion " \
60 "sensors to rotate the video")
62 #define FILTER_PREFIX "rotate-"
64 /*****************************************************************************
66 *****************************************************************************/
68 set_description( N_("Rotate video filter") )
69 set_shortname( N_( "Rotate" ))
70 set_capability( "video filter", 0 )
71 set_category( CAT_VIDEO
)
72 set_subcategory( SUBCAT_VIDEO_VFILTER
)
74 add_float( FILTER_PREFIX
"angle", 30., ANGLE_TEXT
, ANGLE_LONGTEXT
, false )
75 add_bool( FILTER_PREFIX
"use-motion", false, MOTION_TEXT
,
76 MOTION_LONGTEXT
, false )
78 add_shortcut( "rotate" )
79 set_callbacks( Create
, Destroy
)
82 static const char *const ppsz_filter_options
[] = {
83 "angle", "use-motion", NULL
86 /*****************************************************************************
88 *****************************************************************************/
91 atomic_uint_fast32_t sincos
;
92 motion_sensors_t
*p_motion
;
103 static void store_trigo( struct filter_sys_t
*sys
, float f_angle
)
107 f_angle
*= (float)(M_PI
/ 180.); /* degrees -> radians */
109 sincos
.sin
= lroundf(sinf(f_angle
) * 4096.f
);
110 sincos
.cos
= lroundf(cosf(f_angle
) * 4096.f
);
111 atomic_store(&sys
->sincos
, sincos
.u
);
114 static void fetch_trigo( struct filter_sys_t
*sys
, int *i_sin
, int *i_cos
)
116 sincos_t sincos
= { .u
= atomic_load(&sys
->sincos
) };
122 /*****************************************************************************
123 * Create: allocates Distort video filter
124 *****************************************************************************/
125 static int Create( vlc_object_t
*p_this
)
127 filter_t
*p_filter
= (filter_t
*)p_this
;
130 if( p_filter
->fmt_in
.video
.i_chroma
!= p_filter
->fmt_out
.video
.i_chroma
)
132 msg_Err( p_filter
, "Input and output chromas don't match" );
136 switch( p_filter
->fmt_in
.video
.i_chroma
)
139 p_filter
->pf_video_filter
= Filter
;
143 p_filter
->pf_video_filter
= FilterPacked
;
147 msg_Err( p_filter
, "Unsupported input chroma (%4.4s)",
148 (char*)&(p_filter
->fmt_in
.video
.i_chroma
) );
152 /* Allocate structure */
153 p_filter
->p_sys
= malloc( sizeof( filter_sys_t
) );
154 if( p_filter
->p_sys
== NULL
)
156 p_sys
= p_filter
->p_sys
;
158 config_ChainParse( p_filter
, FILTER_PREFIX
, ppsz_filter_options
,
161 if( var_InheritBool( p_filter
, FILTER_PREFIX
"use-motion" ) )
163 p_sys
->p_motion
= motion_create( VLC_OBJECT( p_filter
) );
164 if( p_sys
->p_motion
== NULL
)
172 float f_angle
= var_CreateGetFloatCommand( p_filter
,
173 FILTER_PREFIX
"angle" );
174 store_trigo( p_sys
, f_angle
);
175 var_AddCallback( p_filter
, FILTER_PREFIX
"angle",
176 RotateCallback
, p_sys
);
177 p_sys
->p_motion
= NULL
;
183 /*****************************************************************************
184 * Destroy: destroy Distort filter
185 *****************************************************************************/
186 static void Destroy( vlc_object_t
*p_this
)
188 filter_t
*p_filter
= (filter_t
*)p_this
;
189 filter_sys_t
*p_sys
= p_filter
->p_sys
;
191 if( p_sys
->p_motion
!= NULL
)
192 motion_destroy( p_sys
->p_motion
);
195 var_DelCallback( p_filter
, FILTER_PREFIX
"angle",
196 RotateCallback
, p_sys
);
201 /*****************************************************************************
203 *****************************************************************************/
204 static picture_t
*Filter( filter_t
*p_filter
, picture_t
*p_pic
)
207 filter_sys_t
*p_sys
= p_filter
->p_sys
;
209 if( !p_pic
) return NULL
;
211 p_outpic
= filter_NewPicture( p_filter
);
214 picture_Release( p_pic
);
218 if( p_sys
->p_motion
!= NULL
)
220 int i_angle
= motion_get_angle( p_sys
->p_motion
);
221 store_trigo( p_sys
, i_angle
/ 20.f
);
225 fetch_trigo( p_sys
, &i_sin
, &i_cos
);
227 for( int i_plane
= 0 ; i_plane
< p_pic
->i_planes
; i_plane
++ )
229 plane_t
*p_srcp
= &p_pic
->p
[i_plane
];
230 plane_t
*p_dstp
= &p_outpic
->p
[i_plane
];
232 const int i_visible_lines
= p_srcp
->i_visible_lines
;
233 const int i_visible_pitch
= p_srcp
->i_visible_pitch
;
235 const int i_aspect
= __MAX( 1, ( i_visible_lines
* p_pic
->p
[Y_PLANE
].i_visible_pitch
) / ( p_pic
->p
[Y_PLANE
].i_visible_lines
* i_visible_pitch
));
236 /* = 2 for U and V planes in YUV 4:2:2, = 1 otherwise */
238 const int i_line_center
= i_visible_lines
>>1;
239 const int i_col_center
= i_visible_pitch
>>1;
241 const uint8_t black_pixel
= ( i_plane
== Y_PLANE
) ? 0x00 : 0x80;
243 const int i_line_next
= i_cos
/ i_aspect
-i_sin
*i_visible_pitch
;
244 const int i_col_next
= -i_sin
/ i_aspect
-i_cos
*i_visible_pitch
;
245 int i_line_orig0
= ( - i_cos
* i_line_center
/ i_aspect
246 - i_sin
* i_col_center
+ (1<<11) );
247 int i_col_orig0
= i_sin
* i_line_center
/ i_aspect
248 - i_cos
* i_col_center
+ (1<<11);
249 for( int y
= 0; y
< i_visible_lines
; y
++)
251 uint8_t *p_out
= &p_dstp
->p_pixels
[y
* p_dstp
->i_pitch
];
253 for( int x
= 0; x
< i_visible_pitch
; x
++, p_out
++ )
255 const int i_line_orig
= (i_line_orig0
>>12)*i_aspect
+ i_line_center
;
256 const int i_col_orig
= (i_col_orig0
>>12) + i_col_center
;
257 const uint8_t *p_orig_offset
= &p_srcp
->p_pixels
[i_line_orig
* p_srcp
->i_pitch
+ i_col_orig
];
258 const uint8_t i_line_percent
= (i_line_orig0
>>4) & 255;
259 const uint8_t i_col_percent
= (i_col_orig0
>>4) & 255;
261 if( -1 <= i_line_orig
&& i_line_orig
< i_visible_lines
262 && -1 <= i_col_orig
&& i_col_orig
< i_visible_pitch
)
267 if( ( i_col_orig
> i_visible_pitch
/2 ) )
270 uint8_t i_curpix
= black_pixel
;
271 uint8_t i_colpix
= black_pixel
;
272 uint8_t i_linpix
= black_pixel
;
273 uint8_t i_nexpix
= black_pixel
;
274 if( ( 0 <= i_line_orig
) && ( 0 <= i_col_orig
) )
275 i_curpix
= *p_orig_offset
;
278 if( ( i_col_orig
< i_visible_pitch
- 1)
279 && ( i_line_orig
>= 0 ) )
280 i_colpix
= *p_orig_offset
;
282 p_orig_offset
+= p_srcp
->i_pitch
;
283 if( ( i_line_orig
< i_visible_lines
- 1)
284 && ( i_col_orig
< i_visible_pitch
- 1) )
285 i_nexpix
= *p_orig_offset
;
288 if( ( i_line_orig
< i_visible_lines
- 1)
289 && ( i_col_orig
>= 0 ) )
290 i_linpix
= *p_orig_offset
;
292 unsigned int temp
= 0;
294 (256 - i_line_percent
) * ( 256 - i_col_percent
);
296 i_line_percent
* (256 - i_col_percent
);
298 ( i_col_percent
) * ( i_line_percent
);
300 i_col_percent
* (256 - i_line_percent
);
304 else if (i_col_orig
== i_visible_pitch
/2 )
305 { *p_out
= black_pixel
;
308 *p_out
= *p_orig_offset
;
314 *p_out
= black_pixel
;
317 i_line_orig0
+= i_sin
;
318 i_col_orig0
+= i_cos
;
321 i_line_orig0
+= i_line_next
;
322 i_col_orig0
+= i_col_next
;
326 return CopyInfoAndRelease( p_outpic
, p_pic
);
329 /*****************************************************************************
331 *****************************************************************************/
332 static picture_t
*FilterPacked( filter_t
*p_filter
, picture_t
*p_pic
)
335 filter_sys_t
*p_sys
= p_filter
->p_sys
;
337 if( !p_pic
) return NULL
;
339 int i_u_offset
, i_v_offset
, i_y_offset
;
341 if( GetPackedYuvOffsets( p_pic
->format
.i_chroma
, &i_y_offset
,
342 &i_u_offset
, &i_v_offset
) != VLC_SUCCESS
)
344 msg_Warn( p_filter
, "Unsupported input chroma (%4.4s)",
345 (char*)&(p_pic
->format
.i_chroma
) );
346 picture_Release( p_pic
);
350 p_outpic
= filter_NewPicture( p_filter
);
353 picture_Release( p_pic
);
357 const int i_visible_pitch
= p_pic
->p
->i_visible_pitch
>>1; /* In fact it's i_visible_pixels */
358 const int i_visible_lines
= p_pic
->p
->i_visible_lines
;
360 const uint8_t *p_in
= p_pic
->p
->p_pixels
+i_y_offset
;
361 const uint8_t *p_in_u
= p_pic
->p
->p_pixels
+i_u_offset
;
362 const uint8_t *p_in_v
= p_pic
->p
->p_pixels
+i_v_offset
;
363 const int i_in_pitch
= p_pic
->p
->i_pitch
;
365 uint8_t *p_out
= p_outpic
->p
->p_pixels
+i_y_offset
;
366 uint8_t *p_out_u
= p_outpic
->p
->p_pixels
+i_u_offset
;
367 uint8_t *p_out_v
= p_outpic
->p
->p_pixels
+i_v_offset
;
368 const int i_out_pitch
= p_outpic
->p
->i_pitch
;
370 const int i_line_center
= i_visible_lines
>>1;
371 const int i_col_center
= i_visible_pitch
>>1;
373 if( p_sys
->p_motion
!= NULL
)
375 int i_angle
= motion_get_angle( p_sys
->p_motion
);
376 store_trigo( p_sys
, i_angle
/ 20.f
);
380 fetch_trigo( p_sys
, &i_sin
, &i_cos
);
382 for( int i_line
= 0; i_line
< i_visible_lines
; i_line
++ )
384 for( int i_col
= 0; i_col
< i_visible_pitch
; i_col
++ )
388 /* Handle "1st Y", U and V */
389 i_line_orig
= i_line_center
+
390 ( ( i_sin
* ( i_col
- i_col_center
)
391 + i_cos
* ( i_line
- i_line_center
) )>>12 );
392 i_col_orig
= i_col_center
+
393 ( ( i_cos
* ( i_col
- i_col_center
)
394 - i_sin
* ( i_line
- i_line_center
) )>>12 );
395 if( 0 <= i_col_orig
&& i_col_orig
< i_visible_pitch
396 && 0 <= i_line_orig
&& i_line_orig
< i_visible_lines
)
398 p_out
[i_line
*i_out_pitch
+2*i_col
] = p_in
[i_line_orig
*i_in_pitch
+2*i_col_orig
];
400 p_out_u
[i_line
*i_out_pitch
+2*i_col
] = p_in_u
[i_line_orig
*i_in_pitch
+4*i_col_orig
];
401 p_out_v
[i_line
*i_out_pitch
+2*i_col
] = p_in_v
[i_line_orig
*i_in_pitch
+4*i_col_orig
];
405 p_out
[i_line
*i_out_pitch
+2*i_col
] = 0x00;
406 p_out_u
[i_line
*i_out_pitch
+2*i_col
] = 0x80;
407 p_out_v
[i_line
*i_out_pitch
+2*i_col
] = 0x80;
412 if( i_col
>= i_visible_pitch
)
415 i_line_orig
= i_line_center
+
416 ( ( i_sin
* ( i_col
- i_col_center
)
417 + i_cos
* ( i_line
- i_line_center
) )>>12 );
418 i_col_orig
= i_col_center
+
419 ( ( i_cos
* ( i_col
- i_col_center
)
420 - i_sin
* ( i_line
- i_line_center
) )>>12 );
421 if( 0 <= i_col_orig
&& i_col_orig
< i_visible_pitch
422 && 0 <= i_line_orig
&& i_line_orig
< i_visible_lines
)
424 p_out
[i_line
*i_out_pitch
+2*i_col
] = p_in
[i_line_orig
*i_in_pitch
+2*i_col_orig
];
428 p_out
[i_line
*i_out_pitch
+2*i_col
] = 0x00;
433 return CopyInfoAndRelease( p_outpic
, p_pic
);
436 /*****************************************************************************
437 * Angle modification callback.
438 *****************************************************************************/
439 static int RotateCallback( vlc_object_t
*p_this
, char const *psz_var
,
440 vlc_value_t oldval
, vlc_value_t newval
, void *data
)
442 filter_sys_t
*p_sys
= data
;
444 store_trigo( p_sys
, newval
.f_float
);
445 (void) p_this
; (void) psz_var
; (void) oldval
;