git.sesse.net Git - vlc/blob - src/control/mediacontrol_util.c

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