Prefs: repair category system for some lost options.
[vlc.git] / modules / control / motion.c
1 /*****************************************************************************
2  * motion.c: control VLC with laptop built-in motion sensors
3  *****************************************************************************
4  * Copyright (C) 2006 - 2007 the VideoLAN team
5  * $Id$
6  *
7  * Author: Sam Hocevar <sam@zoy.org>
8  *         Jérôme Decoodt <djc@videolan.org> (unimotion integration)
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>
34
35 #include <vlc_common.h>
36 #include <vlc_plugin.h>
37 #include <vlc_interface.h>
38 #include <vlc_vout.h>
39
40 #ifdef HAVE_UNISTD_H
41 #    include <unistd.h>
42 #endif
43
44 #ifdef __APPLE__
45 #include "unimotion.h"
46 #endif
47
48 /*****************************************************************************
49  * intf_sys_t: description and status of interface
50  *****************************************************************************/
51 struct intf_sys_t
52 {
53     enum { NO_SENSOR, HDAPS_SENSOR, AMS_SENSOR, APPLESMC_SENSOR,
54            UNIMOTION_SENSOR } sensor;
55 #ifdef __APPLE__
56     enum sms_hardware unimotion_hw;
57 #endif
58     int i_calibrate;
59
60     bool b_use_rotate;
61 };
62
63 /*****************************************************************************
64  * Local prototypes.
65  *****************************************************************************/
66 static int  Open   ( vlc_object_t * );
67 static void Close  ( vlc_object_t * );
68
69 static void RunIntf( intf_thread_t *p_intf );
70 static int GetOrientation( intf_thread_t *p_intf );
71
72 #define USE_ROTATE_TEXT N_("Use the rotate video filter instead of transform")
73
74 /*****************************************************************************
75  * Module descriptor
76  *****************************************************************************/
77 vlc_module_begin ()
78     set_shortname( N_("motion"))
79     set_category( CAT_INTERFACE )
80     set_subcategory( SUBCAT_INTERFACE_CONTROL )
81     set_description( N_("motion control interface") )
82     set_help( N_("Use HDAPS, AMS, APPLESMC or UNIMOTION motion sensors " \
83                  "to rotate the video") )
84
85     add_bool( "motion-use-rotate", 0, NULL,
86               USE_ROTATE_TEXT, USE_ROTATE_TEXT, false )
87
88     set_capability( "interface", 0 )
89     set_callbacks( Open, Close )
90 vlc_module_end ()
91
92 /*****************************************************************************
93  * OpenIntf: initialise interface
94  *****************************************************************************/
95 int Open ( vlc_object_t *p_this )
96 {
97     intf_thread_t *p_intf = (intf_thread_t *)p_this;
98     FILE *f;
99     int i_x, i_y;
100
101     p_intf->p_sys = malloc( sizeof( intf_sys_t ) );
102     if( p_intf->p_sys == NULL )
103     {
104         return VLC_ENOMEM;
105     }
106
107     if( access( "/sys/devices/platform/hdaps/position", R_OK ) == 0 )
108     {
109         /* IBM HDAPS support */
110         f = fopen( "/sys/devices/platform/hdaps/calibrate", "r" );
111         if( f )
112         {
113             i_x = i_y = 0;
114             fscanf( f, "(%d,%d)", &i_x, &i_y );
115             fclose( f );
116             p_intf->p_sys->i_calibrate = i_x;
117             p_intf->p_sys->sensor = HDAPS_SENSOR;
118         }
119         else
120         {
121             p_intf->p_sys->sensor = NO_SENSOR;
122         }
123     }
124     else if( access( "/sys/devices/ams/x", R_OK ) == 0 )
125     {
126         /* Apple Motion Sensor support */
127         p_intf->p_sys->sensor = AMS_SENSOR;
128     }
129     else if( access( "/sys/devices/applesmc.768/position", R_OK ) == 0 )
130     {
131         /* Apple SMC (newer macbooks) */
132         /* Should be factorised with HDAPS */
133         f = fopen( "/sys/devices/applesmc.768/calibrate", "r" );
134         if( f )
135         {
136             i_x = i_y = 0;
137             fscanf( f, "(%d,%d)", &i_x, &i_y );
138             fclose( f );
139             p_intf->p_sys->i_calibrate = i_x;
140             p_intf->p_sys->sensor = APPLESMC_SENSOR;
141         }
142         else
143         {
144             p_intf->p_sys->sensor = NO_SENSOR;
145         }
146     }
147 #ifdef __APPLE__
148     else if( p_intf->p_sys->unimotion_hw = detect_sms() )
149         p_intf->p_sys->sensor = UNIMOTION_SENSOR;
150 #endif
151     else
152     {
153         /* No motion sensor support */
154         p_intf->p_sys->sensor = NO_SENSOR;
155     }
156
157     p_intf->pf_run = RunIntf;
158
159     p_intf->p_sys->b_use_rotate = config_GetInt( p_intf, "motion-use-rotate" );
160
161     return VLC_SUCCESS;
162 }
163
164 /*****************************************************************************
165  * CloseIntf: destroy interface
166  *****************************************************************************/
167 void Close ( vlc_object_t *p_this )
168 {
169     intf_thread_t *p_intf = (intf_thread_t *)p_this;
170
171     free( p_intf->p_sys );
172 }
173
174 /*****************************************************************************
175  * RunIntf: main loop
176  *****************************************************************************/
177 #define FILTER_LENGTH 16
178 #define LOW_THRESHOLD 800
179 #define HIGH_THRESHOLD 1000
180 static void RunIntf( intf_thread_t *p_intf )
181 {
182     int i_x, i_oldx = 0, i_sum = 0, i = 0;
183     int p_oldx[FILTER_LENGTH];
184     memset( p_oldx, 0, FILTER_LENGTH * sizeof( int ) );
185
186     for( ;; )
187     {
188         vout_thread_t *p_vout;
189         const char *psz_filter, *psz_type;
190         bool b_change = false;
191
192         /* Wait a bit, get orientation, change filter if necessary */
193         msleep( INTF_IDLE_SLEEP );
194
195         int canc = vlc_savecancel();
196         i_x = GetOrientation( p_intf );
197         i_sum += i_x - p_oldx[i];
198         p_oldx[i++] = i_x;
199         if( i == FILTER_LENGTH ) i = 0;
200         i_x = i_sum / FILTER_LENGTH;
201
202         if( p_intf->p_sys->b_use_rotate )
203         {
204             if( i_oldx != i_x )
205             {
206                 /* TODO: cache object pointer */
207                 vlc_object_t *p_obj =
208                 vlc_object_find_name( p_intf->p_libvlc, "rotate", FIND_CHILD );
209                 if( p_obj )
210                 {
211                     var_SetInteger( p_obj, "rotate-deciangle",
212                             ((3600+i_x/2)%3600) );
213                     i_oldx = i_x;
214                     vlc_object_release( p_obj );
215                 }
216             }
217             goto loop;
218         }
219
220         if( i_x < -HIGH_THRESHOLD && i_oldx > -LOW_THRESHOLD )
221         {
222             b_change = true;
223             psz_filter = "transform";
224             psz_type = "270";
225         }
226         else if( ( i_x > -LOW_THRESHOLD && i_oldx < -HIGH_THRESHOLD )
227                  || ( i_x < LOW_THRESHOLD && i_oldx > HIGH_THRESHOLD ) )
228         {
229             b_change = true;
230             psz_filter = "";
231             psz_type = "";
232         }
233         else if( i_x > HIGH_THRESHOLD && i_oldx < LOW_THRESHOLD )
234         {
235             b_change = true;
236             psz_filter = "transform";
237             psz_type = "90";
238         }
239
240         if( b_change )
241         {
242             p_vout = (vout_thread_t *)
243                 vlc_object_find( p_intf, VLC_OBJECT_VOUT, FIND_ANYWHERE );
244             if( p_vout )
245             {
246                 config_PutPsz( p_vout, "transform-type", psz_type );
247                 var_SetString( p_vout, "vout-filter", psz_filter );
248                 vlc_object_release( p_vout );
249
250                 i_oldx = i_x;
251             }
252         }
253 loop:
254         vlc_restorecancel( canc );
255     }
256 }
257 #undef FILTER_LENGTH
258 #undef LOW_THRESHOLD
259 #undef HIGH_THRESHOLD
260
261 /*****************************************************************************
262  * GetOrientation: get laptop orientation, range -1800 / +1800
263  *****************************************************************************/
264 static int GetOrientation( intf_thread_t *p_intf )
265 {
266     FILE *f;
267     int i_x, i_y, i_z = 0;
268
269     switch( p_intf->p_sys->sensor )
270     {
271     case HDAPS_SENSOR:
272         f = fopen( "/sys/devices/platform/hdaps/position", "r" );
273         if( !f )
274         {
275             return 0;
276         }
277
278         i_x = i_y = 0;
279         fscanf( f, "(%d,%d)", &i_x, &i_y );
280         fclose( f );
281
282         return ( i_x - p_intf->p_sys->i_calibrate ) * 10;
283
284     case AMS_SENSOR:
285         f = fopen( "/sys/devices/ams/x", "r" );
286         if( !f )
287         {
288             return 0;
289         }
290
291         fscanf( f, "%d", &i_x);
292         fclose( f );
293
294         return - i_x * 30; /* FIXME: arbitrary */
295
296     case APPLESMC_SENSOR:
297         f = fopen( "/sys/devices/applesmc.768/position", "r" );
298         if( !f )
299         {
300             return 0;
301         }
302
303         i_x = i_y = i_z = 0;
304         fscanf( f, "(%d,%d,%d)", &i_x, &i_y, &i_z );
305         fclose( f );
306
307         return ( i_x - p_intf->p_sys->i_calibrate ) * 10;
308
309 #ifdef __APPLE__
310     case UNIMOTION_SENSOR:
311         if( read_sms_raw( p_intf->p_sys->unimotion_hw, &i_x, &i_y, &i_z ) )
312         {
313             double d_norm = sqrt( i_x*i_x+i_z*i_z );
314             if( d_norm < 100 )
315                 return 0;
316             double d_x = i_x / d_norm;
317             if( i_z > 0 )
318                 return -asin(d_x)*3600/3.141;
319             else
320                 return 3600 + asin(d_x)*3600/3.141;
321         }
322         else
323             return 0;
324 #endif
325     default:
326         return 0;
327     }
328 }
329