* ALL: WinCE EVC compilation fixes.
[vlc.git] / src / control / util.c
1 /*****************************************************************************
2  * util.c: Utility functions and exceptions management
3  *****************************************************************************
4  * Copyright (C) 2005 the VideoLAN team
5  * $Id: vlc.c 10786 2005-04-23 23:19:17Z zorglub $
6  *
7  * Authors: Olivier Aubert <olivier.aubert@liris.univ-lyon1.fr>
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., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
22  *****************************************************************************/
23
24 #include <vlc/control.h>
25
26 #include <vlc/intf.h>
27 #include <vlc/vout.h>
28 #include <vlc/aout.h>
29 #include <vlc_demux.h>
30
31 #include <vlc_osd.h>
32
33 #define HAS_SNAPSHOT 1
34
35 #ifdef HAS_SNAPSHOT
36 #include <snapshot.h>
37 #endif
38
39 #include <stdlib.h>                                      /* malloc(), free() */
40 #include <string.h>
41
42 #include <errno.h>                                                 /* ENOMEM */
43 #include <stdio.h>
44 #include <ctype.h>
45
46 #ifdef HAVE_UNISTD_H
47 #    include <unistd.h>
48 #endif
49 #ifdef HAVE_SYS_TIME_H
50 #    include <sys/time.h>
51 #endif
52 #ifdef HAVE_SYS_TYPES_H
53 #    include <sys/types.h>
54 #endif
55
56 #define RAISE( c, m )  exception->code = c; \
57                        exception->message = strdup(m);
58
59 vlc_int64_t mediacontrol_unit_convert( input_thread_t *p_input,
60                                        mediacontrol_PositionKey from,
61                                        mediacontrol_PositionKey to,
62                                        vlc_int64_t value )
63 {
64     if( to == from )
65         return value;
66
67     /* For all conversions, we need data from p_input */
68     if( !p_input )
69         return 0;
70
71     switch( from )
72     {
73     case mediacontrol_MediaTime:
74         if( to == mediacontrol_ByteCount )
75         {
76             /* FIXME */
77             /* vlc < 0.8 API */
78             /* return value * 50 * p_input->stream.i_mux_rate / 1000; */
79             return 0;
80         }
81         if( to == mediacontrol_SampleCount )
82         {
83             double f_fps;
84
85             if( demux2_Control( p_input->input.p_demux, DEMUX_GET_FPS, &f_fps ) || f_fps < 0.1 )
86                 return 0;
87             else
88                 return( value * f_fps / 1000.0 );
89         }
90         /* Cannot happen */
91         /* See http://catb.org/~esr/jargon/html/entry/can't-happen.html */
92         break;
93
94     case mediacontrol_SampleCount:
95     {
96         double f_fps;
97
98         if( demux2_Control( p_input->input.p_demux, DEMUX_GET_FPS, &f_fps ) || f_fps < 0.1 )
99             return 0;
100
101         if( to == mediacontrol_ByteCount )
102         {
103             /* FIXME */
104             /* vlc < 0.8 API */
105 /*             return ( vlc_int64_t )( value * 50 * p_input->stream.i_mux_rate / f_fps ); */
106             return 0;
107         }
108
109         if( to == mediacontrol_MediaTime )
110             return( vlc_int64_t )( value * 1000.0 / ( double )f_fps );
111
112         /* Cannot happen */
113         break;
114     }
115     case mediacontrol_ByteCount:
116         /* FIXME */
117         return 0;
118 /* vlc < 0.8 API: */
119
120 //         if( p_input->stream.i_mux_rate == 0 )
121 //             return 0;
122 // 
123 //         /* Convert an offset into milliseconds. Taken from input_ext-intf.c.
124 //            The 50 hardcoded constant comes from the definition of i_mux_rate :
125 //            i_mux_rate : the rate we read the stream (in units of 50 bytes/s) ;
126 //            0 if undef */
127 //         if( to == mediacontrol_MediaTime )
128 //             return ( vlc_int64_t )( 1000 * value / 50 / p_input->stream.i_mux_rate );
129 // 
130 //         if( to == mediacontrol_SampleCount )
131 //         {
132 //             double f_fps;
133 //             if( demux2_Control( p_input->input.p_demux, DEMUX_GET_FPS, &f_fps ) || f_fps < 0.1 )
134 //                 return 0;
135 //             else
136 //                 return ( vlc_int64_t )( value * f_fps / 50 / p_input->stream.i_mux_rate );
137 //         }
138         /* Cannot happen */
139         break;
140     }
141     /* Cannot happen */
142     return 0;
143 }
144
145 /* Converts a mediacontrol_Position into a time in microseconds in
146    movie clock time */
147 vlc_int64_t
148 mediacontrol_position2microsecond( input_thread_t* p_input, const mediacontrol_Position * pos )
149 {
150     switch( pos->origin )
151     {
152     case mediacontrol_AbsolutePosition:
153         return ( 1000 * mediacontrol_unit_convert( p_input,
154                                                    pos->key, /* from */
155                                                    mediacontrol_MediaTime,  /* to */
156                                                    pos->value ) );
157         break;
158     case mediacontrol_RelativePosition:
159     {
160         vlc_int64_t l_pos;
161         vlc_value_t val;
162
163         val.i_time = 0;
164         if( p_input )
165         {
166             var_Get( p_input, "time", &val );
167         }
168
169         l_pos = 1000 * mediacontrol_unit_convert( p_input,
170                                                   pos->key,
171                                                   mediacontrol_MediaTime,
172                                                   pos->value );
173         return val.i_time + l_pos;
174         break;
175     }
176     case mediacontrol_ModuloPosition:
177     {
178         vlc_int64_t l_pos;
179         vlc_value_t val;
180
181         val.i_time = 0;
182         if( p_input )
183         {
184             var_Get( p_input, "length", &val );
185         }
186
187         if( val.i_time > 0)
188         {
189             l_pos = ( 1000 * mediacontrol_unit_convert( p_input,
190                                                         pos->key,
191                                                         mediacontrol_MediaTime,
192                                                         pos->value ) );
193         }
194         else
195             l_pos = 0;
196
197         return l_pos % val.i_time;
198         break;
199     }
200     }
201     return 0;
202 }
203
204 mediacontrol_RGBPicture*
205 mediacontrol_RGBPicture__alloc( int datasize )
206 {
207     mediacontrol_RGBPicture* pic;
208
209     pic = ( mediacontrol_RGBPicture * )malloc( sizeof( mediacontrol_RGBPicture ) );
210     if( ! pic )
211         return NULL;
212
213     pic->size = datasize;
214     pic->data = ( char* )malloc( datasize );
215     return pic;
216 }
217
218 void
219 mediacontrol_RGBPicture__free( mediacontrol_RGBPicture* pic )
220 {
221     if( pic )
222         free( pic->data );
223     free( pic );
224 }
225
226 mediacontrol_PlaylistSeq*
227 mediacontrol_PlaylistSeq__alloc( int size )
228 {
229     mediacontrol_PlaylistSeq* ps;
230
231     ps =( mediacontrol_PlaylistSeq* )malloc( sizeof( mediacontrol_PlaylistSeq ) );
232     if( ! ps )
233         return NULL;
234
235     ps->size = size;
236     ps->data = ( char** )malloc( size * sizeof( char* ) );
237     return ps;
238 }
239
240 void
241 mediacontrol_PlaylistSeq__free( mediacontrol_PlaylistSeq* ps )
242 {
243     if( ps )
244     {
245         int i;
246         for( i = 0 ; i < ps->size ; i++ )
247             free( ps->data[i] );
248     }
249     free( ps->data );
250     free( ps );
251 }
252
253 mediacontrol_Exception*
254 mediacontrol_exception_init( mediacontrol_Exception *exception )
255 {
256     if( exception == NULL )
257     {
258         exception = ( mediacontrol_Exception* )malloc( sizeof( mediacontrol_Exception ) );
259     }
260
261     exception->code = 0;
262     exception->message = NULL;
263     return exception;
264 }
265
266 void
267 mediacontrol_exception_free( mediacontrol_Exception *exception )
268 {
269     if( ! exception )
270         return;
271
272     free( exception->message );
273     free( exception );
274 }
275
276 mediacontrol_RGBPicture*
277 _mediacontrol_createRGBPicture( int i_width, int i_height, long i_chroma, vlc_int64_t l_date,
278                                 char* p_data, int i_datasize )
279 {
280     mediacontrol_RGBPicture *retval;
281
282     retval = mediacontrol_RGBPicture__alloc( i_datasize );
283     if( retval )
284     {
285         retval->width  = i_width;
286         retval->height = i_height;
287         retval->type   = i_chroma;
288         retval->date   = l_date;
289         retval->size   = i_datasize;
290         memcpy( retval->data, p_data, i_datasize );
291     }
292     return retval;
293 }