开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > 查看源码
vlm.c
资源名称：vlc-0.8.1.tar.gz　[点击查看]
上传用户：riyaled888
上传日期：2009-03-27
资源大小：7338k
文件大小：66k
源码类别：

多媒体

开发平台：

MultiPlatform

vlm.c：源码内容
  1. /*****************************************************************************
  2.  * vlm.c: VLM interface plugin
  3.  *****************************************************************************
  4.  * Copyright (C) 2000, 2001 VideoLAN
  5.  * $Id: vlm.c 9083 2004-10-30 10:36:07Z gbazin $
  6.  *
  7.  * Authors: Simon Latapie <garf@videolan.org>
  8.  *          Laurent Aimar <fenrir@videolan.org>
  9.  *          Gildas Bazin <gbazin@videolan.org>
  10.  *
  11.  * This program is free software; you can redistribute it and/or modify
  12.  * it under the terms of the GNU General Public License as published by
  13.  * the Free Software Foundation; either version 2 of the License, or
  14.  * (at your option) any later version.
  15.  *
  16.  * This program is distributed in the hope that it will be useful,
  17.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19.  * GNU General Public License for more details.
  20.  *
  21.  * You should have received a copy of the GNU General Public License
  22.  * along with this program; if not, write to the Free Software
  23.  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
  24.  *****************************************************************************/
  26. /*****************************************************************************
  27.  * Preamble
  28.  *****************************************************************************/
  29. #include <stdlib.h>                                      /* malloc(), free() */
  30. #include <ctype.h>                                              /* tolower() */
  32. #include <vlc/vlc.h>
  34. #ifdef ENABLE_VLM
  36. #include <vlc/intf.h>
  37. #include <vlc/input.h>
  39. #ifdef HAVE_TIME_H
  40. #   include <time.h>                                              /* ctime() */
  41. #endif
  43. #include "vlc_vlm.h"
  44. #include "vlc_vod.h"
  46. /*****************************************************************************
  47.  * Local prototypes.
  48.  *****************************************************************************/
  49. static char          *vlm_Save( vlm_t * );
  50. static int            vlm_Load( vlm_t *, char *);
  51. static vlm_message_t *vlm_Show( vlm_t *, vlm_media_t *, vlm_schedule_t *, char * );
  52. static vlm_message_t *vlm_Help( vlm_t *, char * );
  54. static vlm_media_t *vlm_MediaNew    ( vlm_t *, char *, int );
  55. static void         vlm_MediaDelete ( vlm_t *, vlm_media_t *, char * );
  56. static vlm_media_t *vlm_MediaSearch ( vlm_t *, char * );
  57. static int          vlm_MediaSetup  ( vlm_t *, vlm_media_t *, char *, char * );
  58. static int          vlm_MediaControl( vlm_t *, vlm_media_t *, char *, char *, char * );
  59. static vlm_media_instance_t *vlm_MediaInstanceSearch( vlm_t *, vlm_media_t *, char * );
  61. static vlm_message_t *vlm_MessageNew( char *, const char *, ... );
  62. static vlm_message_t *vlm_MessageAdd( vlm_message_t*, vlm_message_t* );
  64. static vlm_schedule_t *vlm_ScheduleNew( vlm_t *, char *);
  65. static void            vlm_ScheduleDelete( vlm_t *, vlm_schedule_t *, char *);
  66. static int             vlm_ScheduleSetup( vlm_schedule_t *, char *, char *);
  67. static vlm_schedule_t *vlm_ScheduleSearch( vlm_t *, char *);
  69. static int vlm_MediaVodControl( void *, vod_media_t *, char *, int, va_list );
  71. static int ExecuteCommand( vlm_t *, char *, vlm_message_t **);
  72. static int Manage( vlc_object_t* );
  74. /*****************************************************************************
  75.  * vlm_New:
  76.  *****************************************************************************/
  77. vlm_t *__vlm_New ( vlc_object_t *p_this )
  78. {
  79.     vlc_value_t lockval;
  80.     vlm_t *vlm = NULL;
  82.     /* to be sure to avoid multiple creation */
  83.     var_Create( p_this->p_libvlc, "vlm_mutex", VLC_VAR_MUTEX );
  84.     var_Get( p_this->p_libvlc, "vlm_mutex", &lockval );
  85.     vlc_mutex_lock( lockval.p_address );
  87.     if( !(vlm = vlc_object_find( p_this, VLC_OBJECT_VLM, FIND_ANYWHERE )) )
  88.     {
  89.         msg_Info( p_this, "creating vlm" );
  90.         if( ( vlm = vlc_object_create( p_this, VLC_OBJECT_VLM ) ) == NULL )
  91.         {
  92.             vlc_mutex_unlock( lockval.p_address );
  93.             return NULL;
  94.         }
  96.         vlc_mutex_init( p_this->p_vlc, &vlm->lock );
  97.         vlm->i_media      = 0;
  98.         vlm->media        = NULL;
  99.         vlm->i_vod        = 0;
  100.         vlm->i_schedule   = 0;
  101.         vlm->schedule     = NULL;
  103.         vlc_object_yield( vlm );
  104.         vlc_object_attach( vlm, p_this->p_vlc );
  105.     }
  106.     vlc_mutex_unlock( lockval.p_address );
  108.     if( vlc_thread_create( vlm, "vlm thread",
  109.                            Manage, VLC_THREAD_PRIORITY_LOW, VLC_FALSE ) )
  110.     {
  111.         vlc_mutex_destroy( &vlm->lock );
  112.         vlc_object_destroy( vlm );
  113.         return NULL;
  114.     }
  116.     return vlm;
  117. }
  119. /*****************************************************************************
  120.  * vlm_Delete:
  121.  *****************************************************************************/
  122. void vlm_Delete( vlm_t *vlm )
  123. {
  124.     vlc_value_t lockval;
  126.     var_Get( vlm->p_libvlc, "vlm_mutex", &lockval );
  127.     vlc_mutex_lock( lockval.p_address );
  129.     vlc_object_release( vlm );
  131.     if( vlm->i_refcount > 0 )
  132.     {
  133.         vlc_mutex_unlock( lockval.p_address );
  134.         return;
  135.     }
  137.     vlm->b_die = VLC_TRUE;
  138.     vlc_thread_join( vlm );
  140.     vlc_mutex_destroy( &vlm->lock );
  142.     while( vlm->i_media ) vlm_MediaDelete( vlm, vlm->media[0], NULL );
  143.     if( vlm->media ) free( vlm->media );
  145.     while( vlm->i_schedule ) vlm_ScheduleDelete( vlm, vlm->schedule[0], NULL );
  146.     if( vlm->schedule ) free( vlm->schedule );
  148.     vlc_object_detach( vlm );
  149.     vlc_object_destroy( vlm );
  150.     vlc_mutex_unlock( lockval.p_address );
  151. }
  153. /*****************************************************************************
  154.  * vlm_ExecuteCommand:
  155.  *****************************************************************************/
  156. int vlm_ExecuteCommand( vlm_t *vlm, char *command, vlm_message_t **message)
  157. {
  158.     int result;
  160.     vlc_mutex_lock( &vlm->lock );
  161.     result = ExecuteCommand( vlm, command, message );
  162.     vlc_mutex_unlock( &vlm->lock );
  164.     return result;
  165. }
  167. /*****************************************************************************
  168.  * FindEndCommand
  169.  *****************************************************************************/
  170. static char *FindEndCommand( char *psz )
  171. {
  172.     char *psz_sent = psz;
  174.     switch( *psz_sent )
  175.     {
  176.     case '"':
  177.         psz_sent++;
  179.         while( ( *psz_sent != '"' ) && ( *psz_sent != '' ) )
  180.         {
  181.             if( *psz_sent == ''' )
  182.             {
  183.                 psz_sent = FindEndCommand( psz_sent );
  184.                 if( psz_sent == NULL ) return NULL;
  185.             }
  186.             else psz_sent++;
  187.         }
  189.         if( *psz_sent == '"' )
  190.         {
  191.             psz_sent++;
  192.             return psz_sent;
  193.         }
  195.         /* *psz_sent == '' -> number of " is incorrect */
  196.         else return NULL;
  198.         break;
  200.     case ''':
  201.         psz_sent++;
  203.         while( ( *psz_sent != ''' ) && ( *psz_sent != '' ) )
  204.         {
  205.             if( *psz_sent == '"' )
  206.             {
  207.                 psz_sent = FindEndCommand( psz_sent );
  208.                 if( psz_sent == NULL ) return NULL;
  209.             }
  210.             else psz_sent++;
  211.         }
  213.         if( *psz_sent == ''' )
  214.         {
  215.             psz_sent++;
  216.             return psz_sent;
  217.         }
  219.         /* *psz_sent == '' -> number of " is incorrect */
  220.         else return NULL;
  222.         break;
  224.     default: /* now we can look for spaces */
  225.         while( ( *psz_sent != ' ' ) && ( *psz_sent != '' ) )
  226.         {
  227.             if( ( *psz_sent == ''' ) || ( *psz_sent == '"' ) )
  228.             {
  229.                 psz_sent = FindEndCommand( psz_sent );
  230.             }
  231.             else psz_sent++;
  232.         }
  234.         return psz_sent;
  235.     }
  236. }
  238. /*****************************************************************************
  239.  * ExecuteCommand: The main state machine
  240.  *****************************************************************************
  241.  * Execute a command which ends with '' (string)
  242.  *****************************************************************************/
  243. static int ExecuteCommand(vlm_t *vlm, char *command, vlm_message_t **p_message)
  244. {
  245.     int i_command = 0;
  246.     char **p_command = NULL;
  247.     char *cmd = command;
  248.     vlm_message_t *message = NULL;
  249.     int i, j;
  251.     /* First, parse the line and cut it */
  252.     while( *cmd != '' )
  253.     {
  255.         if( *cmd == ' ' )
  256.         {
  257.             cmd++;
  258.         }
  259.         else
  260.         {
  261.             char *p_temp;
  262.             int   i_temp;
  264.             p_temp = FindEndCommand( cmd );
  266.             if( p_temp == NULL ) goto error;
  268.             i_temp = p_temp - cmd;
  270.             p_command = realloc( p_command, (i_command + 1) * sizeof(char*) );
  271.             p_command[ i_command ] = malloc( (i_temp + 1) * sizeof(char) );
  272.             strncpy( p_command[ i_command ], cmd, i_temp );
  273.             p_command[ i_command ][ i_temp ] = '';
  275.             i_command++;
  276.             cmd = p_temp;
  277.         }
  278.     }
  280.     /*
  281.      * And then Interpret it
  282.      */
  284.     if( i_command == 0 )
  285.     {
  286.         message = vlm_MessageNew( "", NULL );
  287.         goto success;
  288.     }
  290.     if( strcmp(p_command[0], "new") == 0 )
  291.     {
  292.         int i_type;
  294.         /* Check the number of arguments */
  295.         if( i_command < 3 ) goto syntax_error;
  297.         /* Get type */
  298.         if( strcmp(p_command[2], "vod") == 0 )
  299.         {
  300.             i_type = VOD_TYPE;
  301.         }
  302.         else if( strcmp(p_command[2], "broadcast") == 0 )
  303.         {
  304.             i_type = BROADCAST_TYPE;
  305.         }
  306.         else if( strcmp(p_command[2], "schedule") == 0 )
  307.         {
  308.             i_type = SCHEDULE_TYPE;
  309.         }
  310.         else
  311.         {
  312.             message = vlm_MessageNew( "new", "%s: Choose between vod, "
  313.                                       "broadcast or schedule", p_command[1] );
  314.             goto error;
  315.         }
  317.         /* Check for forbidden media names */
  318.         if( strcmp(p_command[1], "all") == 0 ||
  319.             strcmp(p_command[1], "media") == 0 ||
  320.             strcmp(p_command[1], "schedule") == 0 )
  321.         {
  322.             message = vlm_MessageNew( "new", ""all", "media" and "
  323.                                       ""schedule" are reserved names" );
  324.             goto error;
  325.         }
  327.         /* Check the name is not already in use */
  328.         if( vlm_ScheduleSearch( vlm, p_command[1] ) ||
  329.             vlm_MediaSearch( vlm, p_command[1] ) )
  330.         {
  331.             message = vlm_MessageNew( "new", "%s: Name already in use",
  332.                                       p_command[1] );
  333.             goto error;
  334.         }
  336.         /* Schedule */
  337.         if( i_type == SCHEDULE_TYPE )
  338.         {
  339.             vlm_schedule_t *schedule;
  340.             schedule = vlm_ScheduleNew( vlm, p_command[1] );
  341.             if( !schedule )
  342.             {
  343.                 message = vlm_MessageNew( "new", "could not create schedule" );
  344.                 goto error;
  345.             }
  346.         }
  348.         /* Media */
  349.         else
  350.         {
  351.             vlm_media_t *media;
  352.             media = vlm_MediaNew( vlm, p_command[1], i_type );
  353.             if( !media )
  354.             {
  355.                 message = vlm_MessageNew( "new", "could not create media" );
  356.                 goto error;
  357.             }
  358.         }
  360.         if( i_command <= 3 )
  361.         {
  362.             message = vlm_MessageNew( "new", NULL );
  363.             goto success;
  364.         }
  366.         /* Properties will be dealt with later on */
  367.     }
  369.     else if( strcmp(p_command[0], "setup") == 0 )
  370.     {
  371.         if( i_command < 2 ) goto syntax_error;
  373.         /* Properties will be dealt with later on */
  374.     }
  375.  
  376.     else if( strcmp(p_command[0], "del") == 0 )
  377.     {
  378.         vlm_media_t *media;
  379.         vlm_schedule_t *schedule;
  381.         if( i_command < 2 ) goto syntax_error;
  383.         media = vlm_MediaSearch( vlm, p_command[1] );
  384.         schedule = vlm_ScheduleSearch( vlm, p_command[1] );
  386.         if( schedule != NULL )
  387.         {
  388.             vlm_ScheduleDelete( vlm, schedule, NULL );
  389.         }
  390.         else if( media != NULL )
  391.         {
  392.             vlm_MediaDelete( vlm, media, NULL );
  393.         }
  394.         else if( strcmp(p_command[1], "media") == 0 )
  395.         {
  396.             while( vlm->i_media ) vlm_MediaDelete( vlm, vlm->media[0], NULL );
  397.         }
  398.         else if( strcmp(p_command[1], "schedule") == 0 )
  399.         {
  400.             while( vlm->i_schedule )
  401.                 vlm_ScheduleDelete( vlm, vlm->schedule[0], NULL );
  402.         }
  403.         else if( strcmp(p_command[1], "all") == 0 )
  404.         {
  405.             while( vlm->i_media ) vlm_MediaDelete( vlm, vlm->media[0], NULL );
  407.             while( vlm->i_schedule )
  408.                 vlm_ScheduleDelete( vlm, vlm->schedule[0], NULL );
  409.         }
  410.         else
  411.         {
  412.             message = vlm_MessageNew( "del", "%s: media unknown",
  413.                                       p_command[1] );
  414.             goto error;
  415.         }
  417.         message = vlm_MessageNew( "del", NULL );
  418.         goto success;
  419.     }
  421.     else if( strcmp(p_command[0], "show") == 0 )
  422.     {
  423.         vlm_media_t *media;
  424.         vlm_schedule_t *schedule;
  426.         if( i_command == 1 )
  427.         {
  428.             message = vlm_Show( vlm, NULL, NULL, NULL );
  429.             goto success;
  430.         }
  431.         else if( i_command > 2 ) goto syntax_error;
  433.         media = vlm_MediaSearch( vlm, p_command[1] );
  434.         schedule = vlm_ScheduleSearch( vlm, p_command[1] );
  436.         if( schedule != NULL )
  437.         {
  438.             message = vlm_Show( vlm, NULL, schedule, NULL );
  439.         }
  440.         else if( media != NULL )
  441.         {
  442.             message = vlm_Show( vlm, media, NULL, NULL );
  443.         }
  444.         else
  445.         {
  446.             message = vlm_Show( vlm, NULL, NULL, p_command[1] );
  447.         }
  449.         goto success;
  450.     }
  452.     else if( strcmp(p_command[0], "help") == 0 )
  453.     {
  454.         if( i_command != 1 ) goto syntax_error;
  456.         message = vlm_Help( vlm, NULL );
  457.         goto success;
  458.     }
  460.     else if( strcmp(p_command[0], "control") == 0 )
  461.     {
  462.         vlm_media_t *media;
  464.         if( i_command < 3 ) goto syntax_error;
  466.         if( !(media = vlm_MediaSearch( vlm, p_command[1] ) ) )
  467.         {
  468.             message = vlm_MessageNew( "control", "%s: media unknown",
  469.                                       p_command[1] );
  470.             goto error;
  471.         }
  472.         else
  473.         {
  474.             char *psz_command, *psz_arg = 0, *psz_instance = 0;
  475.             int i_index = 2;
  477.             if( strcmp(p_command[2], "play") && strcmp(p_command[2], "stop") &&
  478.                 strcmp(p_command[2], "pause") && strcmp(p_command[2], "seek") )
  479.             {
  480.                 i_index++;
  481.                 psz_instance = p_command[2];
  483.                 if( i_command < 4 ) goto syntax_error;
  484.             }
  486.             psz_command = p_command[i_index];
  488.             if( i_command >= i_index + 2 ) psz_arg = p_command[i_index + 1];
  490.             vlm_MediaControl( vlm, media, psz_instance, psz_command, psz_arg );
  491.             message = vlm_MessageNew( "control", NULL );
  492.             goto success;
  493.         }
  494.     }
  496.     else if( strcmp(p_command[0], "save") == 0 )
  497.     {
  498.         FILE *file;
  500.         if( i_command != 2 ) goto syntax_error;
  502.         file = fopen( p_command[1], "w" );
  503.         if( file == NULL )
  504.         {
  505.             message = vlm_MessageNew( "save", "Unable to save file" );
  506.             goto error;
  507.         }
  508.         else
  509.         {
  510.             char *save = vlm_Save( vlm );
  511.             fwrite( save, strlen( save ), 1, file );
  512.             fclose( file );
  513.             free( save );
  514.             message = vlm_MessageNew( "save", NULL );
  515.             goto success;
  516.         }
  517.     }
  519.     else if( strcmp(p_command[0], "load") == 0 )
  520.     {
  521.         FILE *file;
  523.         if( i_command != 2 ) goto syntax_error;
  525.         file = fopen( p_command[1], "r" );
  527.         if( file == NULL )
  528.         {
  529.             message = vlm_MessageNew( "load", "Unable to load file" );
  530.             goto error;
  531.         }
  532.         else
  533.         {
  534.             int64_t size;
  535.             char *buffer;
  537.             if( fseek( file, 0, SEEK_END) == 0 )
  538.             {
  539.                 size = ftell( file );
  540.                 fseek( file, 0, SEEK_SET);
  541.                 buffer = malloc( size + 1 );
  542.                 fread( buffer, 1, size, file);
  543.                 buffer[ size ] = '';
  544.                 if( vlm_Load( vlm, buffer ) )
  545.                 {
  546.                     free( buffer );
  547.                     message = vlm_MessageNew( "load", "error while loading "
  548.                                               "file" );
  549.                     goto error;
  550.                 }
  551.                 free( buffer );
  552.             }
  553.             else
  554.             {
  555.                 message = vlm_MessageNew( "load", "read file error" );
  556.                 goto error;
  557.             }
  559.             fclose( file );
  560.             message = vlm_MessageNew( "load", NULL );
  561.             goto success;
  562.         }
  563.     }
  565.     else
  566.     {
  567.         message = vlm_MessageNew( p_command[0], "Unknown command" );
  568.         goto error;
  569.     }
  571.     /* Common code between "new" and "setup" */
  572.     if( strcmp(p_command[0], "new") == 0 ||
  573.         strcmp(p_command[0], "setup") == 0 )
  574.     {
  575.         int i_command_start = strcmp(p_command[0], "new") ? 2 : 3;
  576.         vlm_media_t *media;
  577.         vlm_schedule_t *schedule;
  579.         if( i_command < i_command_start ) goto syntax_error;
  581.         media = vlm_MediaSearch( vlm, p_command[1] );
  582.         schedule = vlm_ScheduleSearch( vlm, p_command[1] );
  584.         if( !media && !schedule )
  585.         {
  586.             message = vlm_MessageNew( p_command[0], "%s unknown",
  587.                                       p_command[1] );
  588.             goto error;
  589.         }
  591.         if( schedule != NULL )
  592.         {
  593.             for( i = i_command_start ; i < i_command ; i++ )
  594.             {
  595.                 if( strcmp( p_command[i], "enabled" ) == 0 ||
  596.                     strcmp( p_command[i], "disabled" ) == 0 )
  597.                 {
  598.                     vlm_ScheduleSetup( schedule, p_command[i], NULL );
  599.                 }
  601.                 /* Beware: everything behind append is considered as 
  602.                  * command line */
  603.                 else if( strcmp( p_command[i], "append" ) == 0 )
  604.                 {
  605.                     if( ++i >= i_command ) break;
  607.                     for( j = i + 1; j < i_command; j++ )
  608.                     {
  609.                         p_command[i] =
  610.                             realloc( p_command[i], strlen(p_command[i]) +
  611.                                      strlen(p_command[j]) + 1 + 1 );
  612.                         strcat( p_command[i], " " );
  613.                         strcat( p_command[i], p_command[j] );
  614.                     }
  616.                     vlm_ScheduleSetup( schedule, p_command[i - 1],
  617.                                        p_command[i] );
  618.                     break;
  619.                 }
  620.                 else
  621.                 {
  622.                     if( i + 1 >= i_command && !strcmp(p_command[0], "new") )
  623.                     {
  624.                         vlm_ScheduleDelete( vlm, schedule, NULL );
  625.                         message = vlm_MessageNew( p_command[0],
  626.                                                   "Wrong properties syntax" );
  627.                         goto error;
  628.                     }
  629.                     else if( i + 1 >= i_command )
  630.                     {
  631.                         message = vlm_MessageNew( p_command[0],
  632.                                                   "Wrong properties syntax" );
  633.                         goto error;
  634.                     }
  636.                     vlm_ScheduleSetup( schedule, p_command[i],
  637.                                        p_command[i+1] );
  638.                     i++;
  639.                 }
  640.             }
  641.         }
  643.         else if( media != NULL )
  644.         {
  645.             for( i = i_command_start ; i < i_command ; i++ )
  646.             {
  647.                 if( strcmp( p_command[i], "enabled" ) == 0 ||
  648.                     strcmp( p_command[i], "disabled" ) == 0 )
  649.                 {
  650.                     vlm_MediaSetup( vlm, media, p_command[i], NULL );
  651.                 }
  652.                 else if( i + 1 >= i_command && !strcmp( p_command[i], "mux" ) )
  653.                 {
  654.                     if( media->i_type != VOD_TYPE )
  655.                     {
  656.                         message = vlm_MessageNew( p_command[0],
  657.                                   "mux only available for broadcast" );
  658.                     }
  659.                     else
  660.                     {
  661.                         vlm_MediaSetup( vlm, media, p_command[i],
  662.                                         p_command[i+1] );
  663.                         i++;
  664.                     }
  665.                 }
  666.                 else if( strcmp( p_command[i], "loop" ) == 0 ||
  667.                          strcmp( p_command[i], "unloop" ) == 0 )
  668.                 {
  669.                     if( media->i_type != BROADCAST_TYPE )
  670.                     {
  671.                         message = vlm_MessageNew( p_command[0],
  672.                                   "loop only available for broadcast" );
  673.                     }
  674.                     else
  675.                     {
  676.                         vlm_MediaSetup( vlm, media, p_command[i], NULL );
  677.                     }
  678.                 }
  679.                 else
  680.                 {
  681.                     if( i + 1 >= i_command && !strcmp(p_command[0], "new") )
  682.                     {
  683.                         vlm_MediaDelete( vlm, media, NULL );
  684.                         message = vlm_MessageNew( p_command[0],
  685.                                                   "Wrong properties syntax" );
  686.                         goto error;
  687.                     }
  688.                     else if( i + 1 >= i_command )
  689.                     {
  690.                         message = vlm_MessageNew( p_command[0],
  691.                                                   "Wrong properties syntax" );
  692.                         goto error;
  693.                     }
  695.                     vlm_MediaSetup( vlm, media, p_command[i], p_command[i+1] );
  696.                     i++;
  697.                 }
  698.             }
  699.         }
  701.         message = vlm_MessageNew( p_command[0], NULL );
  702.         goto success;
  703.     }
  705. success:
  706.     for( i = 0 ; i < i_command ; i++ ) free( p_command[i] );
  707.     if( p_command ) free( p_command );
  708.     *p_message = message;
  710.     return VLC_SUCCESS;
  712. syntax_error:
  713.     message = vlm_MessageNew( p_command[0], "Wrong command syntax" );
  715. error:
  716.     for( i = 0 ; i < i_command ; i++ ) free( p_command[i] );
  717.     if( p_command ) free( p_command );
  718.     *p_message = message;
  720.     return VLC_EGENERIC;
  721. }
  723. static vlm_media_t *vlm_MediaSearch( vlm_t *vlm, char *psz_name )
  724. {
  725.     int i;
  727.     for( i = 0; i < vlm->i_media; i++ )
  728.     {
  729.         if( strcmp( psz_name, vlm->media[i]->psz_name ) == 0 )
  730.         {
  731.             return vlm->media[i];
  732.         }
  733.     }
  735.     return NULL;
  736. }
  738. /*****************************************************************************
  739.  * Media handling
  740.  *****************************************************************************/
  741. static vlm_media_instance_t *
  742. vlm_MediaInstanceSearch( vlm_t *vlm, vlm_media_t *media, char *psz_name )
  743. {
  744.     int i;
  746.     for( i = 0; i < media->i_instance; i++ )
  747.     {
  748.         if( ( !psz_name && !media->instance[i]->psz_name ) ||
  749.             ( psz_name && media->instance[i]->psz_name &&
  750.               !strcmp( psz_name, media->instance[i]->psz_name ) ) )
  751.         {
  752.             return media->instance[i];
  753.         }
  754.     }
  756.     return NULL;
  757. }
  759. static vlm_media_t *vlm_MediaNew( vlm_t *vlm, char *psz_name, int i_type )
  760. {
  761.     vlm_media_t *media = malloc( sizeof( vlm_media_t ) );
  763.     /* Check if we need to load the VOD server */
  764.     if( i_type == VOD_TYPE && !vlm->i_vod )
  765.     {
  766.         vlm->vod = vlc_object_create( vlm, VLC_OBJECT_VOD );
  767.         vlc_object_attach( vlm->vod, vlm );
  768.         vlm->vod->p_module = module_Need( vlm->vod, "vod server", 0, 0 );
  769.         if( !vlm->vod->p_module )
  770.         {
  771.             msg_Err( vlm, "cannot find vod server" );
  772.             vlc_object_detach( vlm->vod );
  773.             vlc_object_destroy( vlm->vod );
  774.             vlm->vod = 0;
  775.             free( media );
  776.             return NULL;
  777.         }
  779.         vlm->vod->p_data = vlm;
  780.         vlm->vod->pf_media_control = vlm_MediaVodControl;
  781.     }
  782.     if( i_type == VOD_TYPE ) vlm->i_vod++;
  784.     media->psz_name = strdup( psz_name );
  785.     media->b_enabled = VLC_FALSE;
  786.     media->b_loop = VLC_FALSE;
  787.     media->vod_media = NULL;
  788.     media->psz_vod_output = NULL;
  789.     media->psz_mux = NULL;
  790.     media->i_input = 0;
  791.     media->input = NULL;
  792.     media->psz_output = NULL;
  793.     media->i_option = 0;
  794.     media->option = NULL;
  795.     media->i_type = i_type;
  796.     media->i_instance = 0;
  797.     media->instance = NULL;
  799.     media->item.psz_uri = strdup( psz_name );
  800.     vlc_input_item_Init( VLC_OBJECT(vlm), &media->item );
  802.     TAB_APPEND( vlm->i_media, vlm->media, media );
  804.     return media;
  805. }
  807. /* for now, simple delete. After, del with options (last arg) */
  808. static void vlm_MediaDelete( vlm_t *vlm, vlm_media_t *media, char *psz_name )
  809. {
  810.     if( media == NULL ) return;
  812.     while( media->i_instance )
  813.     {
  814.         vlm_media_instance_t *p_instance = media->instance[0];
  815.         vlm_MediaControl( vlm, media, p_instance->psz_name, "stop", 0 );
  816.     }
  818.     TAB_REMOVE( vlm->i_media, vlm->media, media );
  820.     if( media->i_type == VOD_TYPE )
  821.     {
  822.         vlm_MediaSetup( vlm, media, "disabled", 0 );
  823.         vlm->i_vod--;
  824.     }
  826.     /* Check if we need to unload the VOD server */
  827.     if( media->i_type == VOD_TYPE && !vlm->i_vod )
  828.     {
  829.         module_Unneed( vlm->vod, vlm->vod->p_module );
  830.         vlc_object_detach( vlm->vod );
  831.         vlc_object_destroy( vlm->vod );
  832.         vlm->vod = 0;
  833.     }
  835.     if( vlm->i_media == 0 && vlm->media ) free( vlm->media );
  837.     free( media->psz_name );
  839.     while( media->i_input-- ) free( media->input[media->i_input] );
  840.     if( media->input ) free( media->input );
  842.     if( media->psz_output ) free( media->psz_output );
  843.     if( media->psz_mux ) free( media->psz_mux );
  845.     while( media->i_option-- ) free( media->option[media->i_option] );
  846.     if( media->option ) free( media->option );
  848.     vlc_input_item_Clean( &media->item );
  850.     free( media );
  851. }
  853. static int vlm_MediaSetup( vlm_t *vlm, vlm_media_t *media, char *psz_cmd,
  854.                            char *psz_value )
  855. {
  856.     if( strcmp( psz_cmd, "loop" ) == 0 )
  857.     {
  858.         media->b_loop = VLC_TRUE;
  859.     }
  860.     else if( strcmp( psz_cmd, "unloop" ) == 0 )
  861.     {
  862.         media->b_loop = VLC_FALSE;
  863.     }
  864.     else if( strcmp( psz_cmd, "enabled" ) == 0 )
  865.     {
  866.         media->b_enabled = VLC_TRUE;
  867.     }
  868.     else if( strcmp( psz_cmd, "disabled" ) == 0 )
  869.     {
  870.         media->b_enabled = VLC_FALSE;
  871.     }
  872.     else if( strcmp( psz_cmd, "mux" ) == 0 )
  873.     {
  874.         if( media->psz_mux ) free( media->psz_mux );
  875.         media->psz_mux = NULL;
  876.         if( psz_value ) media->psz_mux = strdup( psz_value );
  877.     }
  878.     else if( strcmp( psz_cmd, "input" ) == 0 )
  879.     {
  880.         char *input;
  882.         if( psz_value != NULL && strlen(psz_value) > 1 &&
  883.             ( psz_value[0] == ''' || psz_value[0] == '"' ) &&
  884.             ( psz_value[ strlen(psz_value) - 1 ] == ''' ||
  885.               psz_value[ strlen(psz_value) - 1 ] == '"' )  )
  886.         {
  887.             input = malloc( strlen(psz_value) - 1 );
  889.             memcpy( input, psz_value + 1, strlen(psz_value) - 2 );
  890.             input[ strlen(psz_value) - 2 ] = '';
  891.         }
  892.         else
  893.         {
  894.             input = strdup( psz_value );
  895.         }
  897.         TAB_APPEND( media->i_input, media->input, input );
  898.     }
  899.     else if( strcmp( psz_cmd, "output" ) == 0 )
  900.     {
  901.         if( media->psz_output != NULL )
  902.         {
  903.             free( media->psz_output );
  904.         }
  905.         media->psz_output = strdup( psz_value );
  906.     }
  907.     else if( strcmp( psz_cmd, "option" ) == 0 )
  908.     {
  909.         char *option;
  910.         option = strdup( psz_value );
  912.         TAB_APPEND( media->i_option, media->option, option );
  913.     }
  914.     else
  915.     {
  916.         return VLC_EGENERIC;
  917.     }
  919.     /* Check if we need to create/delete a vod media */
  920.     if( media->i_type == VOD_TYPE )
  921.     {
  922.         if( !media->b_enabled && media->vod_media )
  923.         {
  924.             vlm->vod->pf_media_del( vlm->vod, media->vod_media );
  925.             media->vod_media = 0;
  926.         }
  927.         else if( media->b_enabled && !media->vod_media && media->i_input )
  928.         {
  929.             /* Pre-parse the input */
  930.             input_thread_t *p_input;
  931.             char *psz_output;
  932.             int i;
  934.             vlc_input_item_Clean( &media->item );
  935.             vlc_input_item_Init( VLC_OBJECT(vlm), &media->item );
  937.             if( media->psz_output )
  938.                 asprintf( &psz_output, "%s:description", media->psz_output );
  939.             else
  940.                 asprintf( &psz_output, "#description" );
  942.             media->item.psz_uri = strdup( media->input[0] );
  943.             media->item.ppsz_options = malloc( sizeof( char* ) );
  944.             asprintf( &media->item.ppsz_options[0], "sout=%s", psz_output);
  945.             media->item.i_options = 1;
  946.             for( i = 0; i < media->i_option; i++ )
  947.             {
  948.                 media->item.i_options++;
  949.                 media->item.ppsz_options =
  950.                     realloc( media->item.ppsz_options,
  951.                              media->item.i_options * sizeof( char* ) );
  952.                 media->item.ppsz_options[ media->item.i_options - 1 ] =
  953.                     strdup( media->option[i] );
  954.             }
  956.             if( (p_input = input_CreateThread( vlm, &media->item ) ) )
  957.             {
  958.                 while( !p_input->b_eof && !p_input->b_error ) msleep( 100000 );
  960.                 input_StopThread( p_input );
  961.                 input_DestroyThread( p_input );
  962.                 vlc_object_detach( p_input );
  963.                 vlc_object_destroy( p_input );
  964.             }
  965.             free( psz_output );
  967.             if( media->psz_mux )
  968.             {
  969.                 input_item_t item;
  970.                 es_format_t es, *p_es = &es;
  971.                 char fourcc[5];
  973.                 sprintf( fourcc, "%4.4s", media->psz_mux );
  974.                 fourcc[0] = tolower(fourcc[0]); fourcc[1] = tolower(fourcc[1]);
  975.                 fourcc[2] = tolower(fourcc[2]); fourcc[3] = tolower(fourcc[3]);
  977.                 item = media->item;
  978.                 item.i_es = 1;
  979.                 item.es = &p_es;
  980.                 es_format_Init( &es, VIDEO_ES, *((int *)fourcc) );
  982.                 media->vod_media =
  983.                   vlm->vod->pf_media_new( vlm->vod, media->psz_name, &item );
  984.                 return VLC_SUCCESS;
  985.             }
  987.             media->vod_media =
  988.                 vlm->vod->pf_media_new( vlm->vod, media->psz_name,
  989.                                         &media->item );
  990.         }
  991.     }
  993.     return VLC_SUCCESS;
  994. }
  996. static int vlm_MediaControl( vlm_t *vlm, vlm_media_t *media, char *psz_id,
  997.                              char *psz_command, char *psz_args )
  998. {
  999.     vlm_media_instance_t *p_instance;
  1000.     int i;
  1002.     p_instance = vlm_MediaInstanceSearch( vlm, media, psz_id );
  1004.     if( strcmp( psz_command, "play" ) == 0 && !p_instance )
  1005.     {
  1006.         if( !media->b_enabled || media->i_input == 0 ) return 0;
  1008.         if( !p_instance )
  1009.         {
  1010.             p_instance = malloc( sizeof(vlm_media_instance_t) );
  1011.             memset( p_instance, 0, sizeof(vlm_media_instance_t) );
  1012.             vlc_input_item_Init( VLC_OBJECT(vlm), &p_instance->item );
  1013.             p_instance->p_input = 0;
  1015.             if( media->psz_output != NULL || media->psz_vod_output != NULL )
  1016.             {
  1017.                 p_instance->item.ppsz_options = malloc( sizeof( char* ) );
  1018.                 asprintf( &p_instance->item.ppsz_options[0], "sout=%s%s%s",
  1019.                           media->psz_output ? media->psz_output : "",
  1020.                           (media->psz_output && media->psz_vod_output) ?
  1021.                           ":" : media->psz_vod_output ? "#" : "",
  1022.                           media->psz_vod_output ? media->psz_vod_output : "" );
  1023.                 p_instance->item.i_options = 1;
  1024.             }
  1026.             for( i = 0; i < media->i_option; i++ )
  1027.             {
  1028.                 p_instance->item.i_options++;
  1029.                 p_instance->item.ppsz_options =
  1030.                     realloc( p_instance->item.ppsz_options,
  1031.                              p_instance->item.i_options * sizeof( char* ) );
  1032.                 p_instance->item.ppsz_options[p_instance->item.i_options - 1] =
  1033.                     strdup( media->option[i] );
  1034.             }
  1036.             p_instance->psz_name = psz_id ? strdup(psz_id) : 0;
  1037.             TAB_APPEND( media->i_instance, media->instance, p_instance );
  1038.         }
  1040.         if( psz_args && sscanf(psz_args, "%d", &i) == 1 && i < media->i_input )
  1041.         {
  1042.             p_instance->i_index = i;
  1043.         }
  1045.         if( p_instance->item.psz_uri ) free( p_instance->item.psz_uri );
  1046.         p_instance->item.psz_uri =
  1047.             strdup( media->input[p_instance->i_index] );
  1049.         if( p_instance->p_input )
  1050.         {
  1051.             input_StopThread( p_instance->p_input );
  1052.             input_DestroyThread( p_instance->p_input );
  1053.             vlc_object_detach( p_instance->p_input );
  1054.             vlc_object_destroy( p_instance->p_input );
  1055.         }
  1057.         p_instance->p_input = input_CreateThread( vlm, &p_instance->item );
  1058.         if( !p_instance->p_input )
  1059.         {
  1060.             TAB_REMOVE( media->i_instance, media->instance, p_instance );
  1061.             vlc_input_item_Clean( &p_instance->item );
  1062.             if( p_instance->psz_name ) free( p_instance->psz_name );
  1063.         }
  1065.         return VLC_SUCCESS;
  1066.     }
  1068.     if( !p_instance ) return VLC_EGENERIC;
  1070.     if( strcmp( psz_command, "seek" ) == 0 )
  1071.     {
  1072.         vlc_value_t val;
  1073.         float f_percentage;
  1075.         if( psz_args && sscanf( psz_args, "%f", &f_percentage ) == 1 )
  1076.         {
  1077.             val.f_float = f_percentage / 100.0 ;
  1078.             var_Set( p_instance->p_input, "position", val );
  1079.             return VLC_SUCCESS;
  1080.         }
  1081.     }
  1082.     else if( strcmp( psz_command, "stop" ) == 0 )
  1083.     {
  1084.         TAB_REMOVE( media->i_instance, media->instance, p_instance );
  1086.         if( p_instance->p_input )
  1087.         {
  1088.             input_StopThread( p_instance->p_input );
  1089.             input_DestroyThread( p_instance->p_input );
  1090.             vlc_object_detach( p_instance->p_input );
  1091.             vlc_object_destroy( p_instance->p_input );
  1092.         }
  1094.         vlc_input_item_Clean( &p_instance->item );
  1095.         if( p_instance->psz_name ) free( p_instance->psz_name );
  1096.         free( p_instance );
  1098.         return VLC_SUCCESS;
  1099.     }
  1100.     else if( strcmp( psz_command, "pause" ) == 0 )
  1101.     {
  1102.         vlc_value_t val;
  1104.         if( !p_instance->p_input ) return VLC_SUCCESS;
  1106.         var_Get( p_instance->p_input, "state", &val );
  1108.         if( val.i_int == PAUSE_S ) val.i_int = PLAYING_S;
  1109.         else val.i_int = PAUSE_S;
  1110.         var_Set( p_instance->p_input, "state", val );
  1112.         return VLC_SUCCESS;
  1113.     }
  1115.     return VLC_EGENERIC;
  1116. }
  1118. /*****************************************************************************
  1119.  * Schedule handling
  1120.  *****************************************************************************/
  1121. static vlm_schedule_t *vlm_ScheduleNew( vlm_t *vlm, char *psz_name )
  1122. {
  1123.     vlm_schedule_t *sched = malloc( sizeof( vlm_schedule_t ) );
  1125.     sched->psz_name = strdup( psz_name );
  1126.     sched->b_enabled = VLC_FALSE;
  1127.     sched->i_command = 0;
  1128.     sched->command = NULL;
  1129.     sched->i_date = 0;
  1130.     sched->i_period = 0;
  1131.     sched->i_repeat = -1;
  1133.     TAB_APPEND( vlm->i_schedule, vlm->schedule, sched );
  1135.     return sched;
  1136. }
  1138. /* for now, simple delete. After, del with options (last arg) */
  1139. static void vlm_ScheduleDelete( vlm_t *vlm, vlm_schedule_t *sched,
  1140.                                 char *psz_name )
  1141. {
  1142.     if( sched == NULL ) return;
  1144.     TAB_REMOVE( vlm->i_schedule, vlm->schedule, sched );
  1146.     if( vlm->i_schedule == 0 && vlm->schedule ) free( vlm->schedule );
  1147.     free( sched->psz_name );
  1148.     while( sched->i_command-- ) free( sched->command[sched->i_command] );
  1149.     free( sched );
  1150. }
  1152. static vlm_schedule_t *vlm_ScheduleSearch( vlm_t *vlm, char *psz_name )
  1153. {
  1154.     int i;
  1156.     for( i = 0; i < vlm->i_schedule; i++ )
  1157.     {
  1158.         if( strcmp( psz_name, vlm->schedule[i]->psz_name ) == 0 )
  1159.         {
  1160.             return vlm->schedule[i];
  1161.         }
  1162.     }
  1164.     return NULL;
  1165. }
  1167. /* Ok, setup schedule command will be able to support only one (argument value) at a time  */
  1168. static int vlm_ScheduleSetup( vlm_schedule_t *schedule, char *psz_cmd,
  1169.                               char *psz_value )
  1170. {
  1171.     if( strcmp( psz_cmd, "enabled" ) == 0 )
  1172.     {
  1173.         schedule->b_enabled = VLC_TRUE;
  1174.     }
  1175.     else if( strcmp( psz_cmd, "disabled" ) == 0 )
  1176.     {
  1177.         schedule->b_enabled = VLC_FALSE;
  1178.     }
  1179. #if !defined( UNDER_CE )
  1180.     else if( strcmp( psz_cmd, "date" ) == 0 )
  1181.     {
  1182.         struct tm time;
  1183.         char *p;
  1184.         time_t date;
  1186.         time.tm_sec = 0;         /* seconds */
  1187.         time.tm_min = 0;         /* minutes */
  1188.         time.tm_hour = 0;        /* hours */
  1189.         time.tm_mday = 0;        /* day of the month */
  1190.         time.tm_mon = 0;         /* month */
  1191.         time.tm_year = 0;        /* year */
  1192.         time.tm_wday = 0;        /* day of the week */
  1193.         time.tm_yday = 0;        /* day in the year */
  1194.         time.tm_isdst = 0;       /* daylight saving time */
  1196.         /* date should be year/month/day-hour:minutes:seconds */
  1197.         p = strchr( psz_value, '-' );
  1199.         if( strcmp( psz_value, "now" ) == 0 )
  1200.         {
  1201.             schedule->i_date = 0;
  1202.         }
  1203.         else if( p == NULL && sscanf( psz_value, "%d:%d:%d", &time.tm_hour, &time.tm_min, &time.tm_sec ) != 3 ) /* it must be a hour:minutes:seconds */
  1204.         {
  1205.             return 1;
  1206.         }
  1207.         else
  1208.         {
  1209.             int i,j,k;
  1211.             switch( sscanf( p + 1, "%d:%d:%d", &i, &j, &k ) )
  1212.             {
  1213.                 case 1:
  1214.                     time.tm_sec = i;
  1215.                     break;
  1216.                 case 2:
  1217.                     time.tm_min = i;
  1218.                     time.tm_sec = j;
  1219.                     break;
  1220.                 case 3:
  1221.                     time.tm_hour = i;
  1222.                     time.tm_min = j;
  1223.                     time.tm_sec = k;
  1224.                     break;
  1225.                 default:
  1226.                     return 1;
  1227.             }
  1229.             *p = '';
  1231.             switch( sscanf( psz_value, "%d/%d/%d", &i, &j, &k ) )
  1232.             {
  1233.                 case 1:
  1234.                     time.tm_mday = i;
  1235.                     break;
  1236.                 case 2:
  1237.                     time.tm_mon = i - 1;
  1238.                     time.tm_mday = j;
  1239.                     break;
  1240.                 case 3:
  1241.                     time.tm_year = i - 1900;
  1242.                     time.tm_mon = j - 1;
  1243.                     time.tm_mday = k;
  1244.                     break;
  1245.                 default:
  1246.                     return 1;
  1247.             }
  1249.             date = mktime( &time );
  1250.             schedule->i_date = ((mtime_t) date) * 1000000;
  1251.         }
  1252.     }
  1253.     else if( strcmp( psz_cmd, "period" ) == 0 )
  1254.     {
  1255.         struct tm time;
  1256.         char *p;
  1257.         char *psz_time = NULL, *psz_date = NULL;
  1258.         time_t date;
  1259.         int i,j,k;
  1261.         /* First, if date or period are modified, repeat should be equal to -1 */
  1262.         schedule->i_repeat = -1;
  1264.         time.tm_sec = 0;         /* seconds */
  1265.         time.tm_min = 0;         /* minutes */
  1266.         time.tm_hour = 0;        /* hours */
  1267.         time.tm_mday = 0;        /* day of the month */
  1268.         time.tm_mon = 0;         /* month */
  1269.         time.tm_year = 0;        /* year */
  1270.         time.tm_wday = 0;        /* day of the week */
  1271.         time.tm_yday = 0;        /* day in the year */
  1272.         time.tm_isdst = 0;       /* daylight saving time */
  1274.         /* date should be year/month/day-hour:minutes:seconds */
  1275.         p = strchr( psz_value, '-' );
  1276.         if( p )
  1277.         {
  1278.             psz_date = psz_value;
  1279.             psz_time = p + 1;
  1281.             *p = '';
  1282.         }
  1283.         else
  1284.         {
  1285.             psz_time = psz_value;
  1286.         }
  1289.         switch( sscanf( psz_time, "%d:%d:%d", &i, &j, &k ) )
  1290.         {
  1291.             case 1:
  1292.                 time.tm_sec = i;
  1293.                 break;
  1294.             case 2:
  1295.                 time.tm_min = i;
  1296.                 time.tm_sec = j;
  1297.                 break;
  1298.             case 3:
  1299.                 time.tm_hour = i;
  1300.                 time.tm_min = j;
  1301.                 time.tm_sec = k;
  1302.                 break;
  1303.             default:
  1304.                 return 1;
  1305.         }
  1306.         if( psz_date )
  1307.         {
  1308.             switch( sscanf( psz_date, "%d/%d/%d", &i, &j, &k ) )
  1309.             {
  1310.                 case 1:
  1311.                     time.tm_mday = i;
  1312.                     break;
  1313.                 case 2:
  1314.                     time.tm_mon = i;
  1315.                     time.tm_mday = j;
  1316.                     break;
  1317.                 case 3:
  1318.                     time.tm_year = i;
  1319.                     time.tm_mon = j;
  1320.                     time.tm_mday = k;
  1321.                     break;
  1322.                 default:
  1323.                     return 1;
  1324.             }
  1325.         }
  1327.         /* ok, that's stupid... who is going to schedule streams every 42 years ? */
  1328.         date = (((( time.tm_year * 12 + time.tm_mon ) * 30 + time.tm_mday ) * 24 + time.tm_hour ) * 60 + time.tm_min ) * 60 + time.tm_sec ;
  1329.         schedule->i_period = ((mtime_t) date) * 1000000;
  1330.     }
  1331. #endif /* UNDER_CE */
  1332.     else if( strcmp( psz_cmd, "repeat" ) == 0 )
  1333.     {
  1334.         int i;
  1336.         if( sscanf( psz_value, "%d", &i ) == 1 )
  1337.         {
  1338.             schedule->i_repeat = i;
  1339.         }
  1340.         else
  1341.         {
  1342.             return 1;
  1343.         }
  1344.     }
  1345.     else if( strcmp( psz_cmd, "append" ) == 0 )
  1346.     {
  1347.         char *command = strdup( psz_value );
  1349.         TAB_APPEND( schedule->i_command, schedule->command, command );
  1350.     }
  1351.     else
  1352.     {
  1353.         return 1;
  1354.     }
  1355.     return 0;
  1356. }
  1358. /*****************************************************************************
  1359.  * Message handling functions
  1360.  *****************************************************************************/
  1361. static vlm_message_t *vlm_MessageNew( char *psz_name,
  1362.                                       const char *psz_format, ... )
  1363. {
  1364.     vlm_message_t *p_message;
  1365.     va_list args;
  1367.     if( !psz_name ) return 0;
  1369.     p_message = malloc( sizeof(vlm_message_t) );
  1370.     p_message->psz_value = 0;
  1372.     if( psz_format )
  1373.     {
  1374.         va_start( args, psz_format );
  1375.         if( vasprintf( &p_message->psz_value, psz_format, args ) < 0 )
  1376.         {
  1377.             va_end( args );
  1378.             free( p_message );
  1379.             return 0;
  1380.         }
  1381.         va_end( args );
  1382.     }
  1384.     p_message->psz_name = strdup( psz_name );
  1385.     p_message->i_child = 0;
  1386.     p_message->child = NULL;
  1388.     return p_message;
  1389. }
  1391. void vlm_MessageDelete( vlm_message_t *p_message )
  1392. {
  1393.     if( p_message->psz_name ) free( p_message->psz_name );
  1394.     if( p_message->psz_value ) free( p_message->psz_value );
  1395.     while( p_message->i_child-- )
  1396.         vlm_MessageDelete( p_message->child[p_message->i_child] );
  1397.     if( p_message->child ) free( p_message->child );
  1398.     free( p_message );
  1399. }
  1401. /* Add a child */
  1402. static vlm_message_t *vlm_MessageAdd( vlm_message_t *p_message,
  1403.                                       vlm_message_t *p_child )
  1404. {
  1405.     if( p_message == NULL ) return NULL;
  1407.     if( p_child )
  1408.     {
  1409.         TAB_APPEND( p_message->i_child, p_message->child, p_child );
  1410.     }
  1412.     return p_child;
  1413. }
  1415. /*****************************************************************************
  1416.  * Misc utility functions
  1417.  *****************************************************************************/
  1418. static vlm_message_t *vlm_Show( vlm_t *vlm, vlm_media_t *media,
  1419.                                 vlm_schedule_t *schedule, char *psz_filter )
  1420. {
  1421.     if( media != NULL )
  1422.     {
  1423.         int i;
  1424.         vlm_message_t *msg;
  1425.         vlm_message_t *msg_media;
  1426.         vlm_message_t *msg_child;
  1428.         msg = vlm_MessageNew( "show", NULL );
  1429.         msg_media = vlm_MessageAdd( msg, vlm_MessageNew( media->psz_name, 0 ));
  1431.         vlm_MessageAdd( msg_media,
  1432.                         vlm_MessageNew( "type", media->i_type == VOD_TYPE ?
  1433.                                         "vod" : "broadcast" ) );
  1434.         vlm_MessageAdd( msg_media,
  1435.                         vlm_MessageNew( "enabled", media->b_enabled ?
  1436.                                         "yes" : "no" ) );
  1438.         vlm_MessageAdd( msg_media,
  1439.                         vlm_MessageNew( "loop", media->b_loop ?
  1440.                                         "yes" : "no" ) );
  1442.         if( media->i_type == VOD_TYPE && media->psz_mux )
  1443.             vlm_MessageAdd( msg_media,
  1444.                             vlm_MessageNew( "mux", media->psz_mux ) );
  1446.         msg_child = vlm_MessageAdd( msg_media,
  1447.                                     vlm_MessageNew( "inputs", NULL ) );
  1449.         for( i = 0; i < media->i_input; i++ )
  1450.         {
  1451.             vlm_MessageAdd( msg_child,
  1452.                             vlm_MessageNew( media->input[i], NULL ) );
  1453.         }
  1455.         vlm_MessageAdd( msg_media,
  1456.                         vlm_MessageNew( "output", media->psz_output ?
  1457.                                         media->psz_output : "" ) );
  1459.         msg_child = vlm_MessageAdd( msg_media, vlm_MessageNew( "options", 0 ));
  1461.         for( i = 0; i < media->i_option; i++ )
  1462.         {
  1463.             vlm_MessageAdd( msg_child, vlm_MessageNew( media->option[i], 0 ) );
  1464.         }
  1466.         msg_child = vlm_MessageAdd( msg_media,
  1467.                                     vlm_MessageNew( "instances", NULL ) );
  1469.         for( i = 0; i < media->i_instance; i++ )
  1470.         {
  1471.             vlm_media_instance_t *p_instance = media->instance[i];
  1472.             vlc_value_t val;
  1474.             if( !p_instance->p_input ) val.i_int = END_S;
  1475.             else var_Get( p_instance->p_input, "state", &val );
  1477.             vlm_MessageAdd( msg_child,
  1478.                 vlm_MessageNew( p_instance->psz_name ?
  1479.                                 p_instance->psz_name : "default",
  1480.                                 val.i_int == PLAYING_S ? "playing" :
  1481.                                 val.i_int == PAUSE_S ? "paused" :
  1482.                                 "stopped" ) );
  1483.         }
  1485.         return msg;
  1487.     }
  1489.     else if( schedule != NULL )
  1490.     {
  1491.         int i;
  1492.         vlm_message_t *msg;
  1493.         vlm_message_t *msg_schedule;
  1494.         vlm_message_t *msg_child;
  1495.         char buffer[100];
  1497.         msg = vlm_MessageNew( "show", NULL );
  1498.         msg_schedule =
  1499.             vlm_MessageAdd( msg, vlm_MessageNew( schedule->psz_name, 0 ) );
  1501.         vlm_MessageAdd( msg_schedule, vlm_MessageNew("type", "schedule") );
  1503.         vlm_MessageAdd( msg_schedule,
  1504.                         vlm_MessageNew( "enabled", schedule->b_enabled ?
  1505.                                         "yes" : "no" ) );
  1507. #if !defined( UNDER_CE )
  1508.         if( schedule->i_date != 0 )
  1509.         {
  1510.             struct tm date;
  1511.             time_t i_time = (time_t)( schedule->i_date / 1000000 );
  1512.             char *psz_date;
  1514. #ifdef HAVE_LOCALTIME_R
  1515.             localtime_r( &i_time, &date);
  1516. #else
  1517.             struct tm *p_date = localtime( &i_time );
  1518.             date = *p_date;
  1519. #endif
  1521.             asprintf( &psz_date, "%d/%d/%d-%d:%d:%d",
  1522.                       date.tm_year + 1900, date.tm_mon + 1, date.tm_mday,
  1523.                       date.tm_hour, date.tm_min, date.tm_sec );
  1525.             vlm_MessageAdd( msg_schedule,
  1526.                             vlm_MessageNew( "date", psz_date ) );
  1527.             free( psz_date );
  1528.         }
  1529.         else
  1530.         {
  1531.             vlm_MessageAdd( msg_schedule, vlm_MessageNew("date", "now") );
  1532.         }
  1534.         if( schedule->i_period != 0 )
  1535.         {
  1536.             time_t i_time = (time_t) ( schedule->i_period / 1000000 );
  1537.             struct tm date;
  1539.             date.tm_sec = (int)( i_time % 60 );
  1540.             i_time = i_time / 60;
  1541.             date.tm_min = (int)( i_time % 60 );
  1542.             i_time = i_time / 60;
  1543.             date.tm_hour = (int)( i_time % 24 );
  1544.             i_time = i_time / 24;
  1545.             date.tm_mday = (int)( i_time % 30 );
  1546.             i_time = i_time / 30;
  1547.             /* okay, okay, months are not always 30 days long */
  1548.             date.tm_mon = (int)( i_time % 12 );
  1549.             i_time = i_time / 12;
  1550.             date.tm_year = (int)i_time;
  1552.             sprintf( buffer, "%d/%d/%d-%d:%d:%d", date.tm_year, date.tm_mon,
  1553.                      date.tm_mday, date.tm_hour, date.tm_min, date.tm_sec);
  1555.             vlm_MessageAdd( msg_schedule, vlm_MessageNew("period", buffer) );
  1556.         }
  1557.         else
  1558.         {
  1559.             vlm_MessageAdd( msg_schedule, vlm_MessageNew("period", "0") );
  1560.         }
  1561. #endif /* UNDER_CE */
  1563.         sprintf( buffer, "%d", schedule->i_repeat );
  1564.         vlm_MessageAdd( msg_schedule, vlm_MessageNew( "repeat", buffer ) );
  1566.         msg_child =
  1567.             vlm_MessageAdd( msg_schedule, vlm_MessageNew("commands", 0) );
  1569.         for( i = 0; i < schedule->i_command; i++ )
  1570.         {
  1571.            vlm_MessageAdd( msg_child,
  1572.                            vlm_MessageNew( schedule->command[i], NULL ) );
  1573.         }
  1575.         return msg;
  1577.     }
  1579.     else if( psz_filter && strcmp( psz_filter, "media" ) == 0 )
  1580.     {
  1581.         int i, j;
  1582.         vlm_message_t *msg;
  1583.         vlm_message_t *msg_child;
  1585.         msg = vlm_MessageNew( "show", NULL );
  1586.         msg_child = vlm_MessageAdd( msg, vlm_MessageNew( "media", NULL ) );
  1588.         for( i = 0; i < vlm->i_media; i++ )
  1589.         {
  1590.             vlm_media_t *m = vlm->media[i];
  1591.             vlm_message_t *msg_media, *msg_instance;
  1593.             msg_media = vlm_MessageAdd( msg_child,
  1594.                                         vlm_MessageNew( m->psz_name, 0 ) );
  1596.             vlm_MessageAdd( msg_media,
  1597.                             vlm_MessageNew( "type", m->i_type == VOD_TYPE ?
  1598.                                             "vod" : "broadcast" ) );
  1600.             vlm_MessageAdd( msg_media,
  1601.                             vlm_MessageNew( "enabled", m->b_enabled ?
  1602.                                             "yes" : "no" ) );
  1604.             if( m->i_type == VOD_TYPE && m->psz_mux )
  1605.                 vlm_MessageAdd( msg_media,
  1606.                                 vlm_MessageNew( "mux", m->psz_mux ) );
  1608.             msg_instance = vlm_MessageAdd( msg_media,
  1609.                                            vlm_MessageNew( "instances", 0 ) );
  1611.             for( j = 0; j < m->i_instance; j++ )
  1612.             {
  1613.                 vlm_media_instance_t *p_instance = m->instance[j];
  1614.                 vlc_value_t val;
  1616.                 if( !p_instance->p_input ) val.i_int = END_S;
  1617.                 else var_Get( p_instance->p_input, "state", &val );
  1619.                 vlm_MessageAdd( msg_instance,
  1620.                     vlm_MessageNew( p_instance->psz_name ?
  1621.                                     p_instance->psz_name : "default",
  1622.                                     val.i_int == PLAYING_S ? "playing" :
  1623.                                     val.i_int == PAUSE_S ? "paused" :
  1624.                                     "stopped" ) );
  1625.             }
  1626.         }
  1628.         return msg;
  1629.     }
  1631.     else if( psz_filter && strcmp( psz_filter, "schedule") == 0 )
  1632.     {
  1633.         int i;
  1634.         vlm_message_t *msg;
  1635.         vlm_message_t *msg_child;
  1637.         msg = vlm_MessageNew( "show", NULL );
  1638.         msg_child = vlm_MessageAdd( msg, vlm_MessageNew( "schedule", NULL ) );
  1640.         for( i = 0; i < vlm->i_schedule; i++ )
  1641.         {
  1642.             vlm_schedule_t *s = vlm->schedule[i];
  1643.             vlm_message_t *msg_schedule;
  1644.             mtime_t i_time, i_next_date;
  1646.             msg_schedule = vlm_MessageAdd( msg_child,
  1647.                                            vlm_MessageNew( s->psz_name, 0 ) );
  1648.             vlm_MessageAdd( msg_schedule,
  1649.                             vlm_MessageNew( "enabled", s->b_enabled ?
  1650.                                             "yes" : "no" ) );
  1652.             if( !s->b_enabled ) return msg;
  1655.             vlm_MessageAdd( msg_schedule,
  1656.                             vlm_MessageNew( "enabled", "yes" ) );
  1658.             /* calculate next date */
  1659.             i_time = mdate();
  1660.             i_next_date = s->i_date;
  1662.             if( s->i_period != 0 )
  1663.             {
  1664.                 int j = 0;
  1665.                 while( s->i_date + j * s->i_period <= i_time &&
  1666.                        s->i_repeat > j )
  1667.                 {
  1668.                     j++;
  1669.                 }
  1671.                 i_next_date = s->i_date + j * s->i_period;
  1672.             }
  1674.             if( i_next_date > i_time )
  1675.             {
  1676.                 time_t i_date = (time_t) (i_next_date / 1000000) ;
  1678. #if !defined( UNDER_CE )
  1679. #ifdef HAVE_CTIME_R
  1680.                 char psz_date[500];
  1681.                 ctime_r( &i_date, psz_date );
  1682. #else
  1683.                 char *psz_date = ctime( &i_date );
  1684. #endif
  1686.                 vlm_MessageAdd( msg_schedule,
  1687.                                 vlm_MessageNew( "next launch", psz_date ) );
  1688. #endif
  1689.             }
  1690.         }
  1692.         return msg;
  1693.     }
  1695.     else if( psz_filter == NULL && media == NULL && schedule == NULL )
  1696.     {
  1697.         vlm_message_t *show1 = vlm_Show( vlm, NULL, NULL, "media" );
  1698.         vlm_message_t *show2 = vlm_Show( vlm, NULL, NULL, "schedule" );
  1700.         vlm_MessageAdd( show1, show2->child[0] );
  1702.         /* We must destroy the parent node "show" of show2
  1703.          * and not the children */
  1704.         free( show2->psz_name );
  1705.         free( show2 );
  1707.         return show1;
  1708.     }
  1710.     else
  1711.     {
  1712.         return vlm_MessageNew( "show", NULL );
  1713.     }
  1714. }
  1716. static vlm_message_t *vlm_Help( vlm_t *vlm, char *psz_filter )
  1717. {
  1718.     vlm_message_t *message, *message_child;
  1720. #define MessageAdd( a ) 
  1721.         vlm_MessageAdd( message, vlm_MessageNew( a, NULL ) );
  1722. #define MessageAddChild( a ) 
  1723.         vlm_MessageAdd( message_child, vlm_MessageNew( a, NULL ) );
  1725.     if( psz_filter == NULL )
  1726.     {
  1727.         message = vlm_MessageNew( "help", NULL );
  1729.         message_child = MessageAdd( "Commands Syntax:" );
  1730.         MessageAddChild( "new (name) vod|broadcast|schedule [properties]" );
  1731.         MessageAddChild( "setup (name) (properties)" );
  1732.         MessageAddChild( "show [(name)|media|schedule]" );
  1733.         MessageAddChild( "del (name)|all|media|schedule" );
  1734.         MessageAddChild( "control (name) [instance_name] (command)" );
  1735.         MessageAddChild( "save (config_file)" );
  1736.         MessageAddChild( "load (config_file)" );
  1738.         message_child = MessageAdd( "Media Proprieties Syntax:" );
  1739.         MessageAddChild( "input (input_name)" );
  1740.         MessageAddChild( "output (output_name)" );
  1741.         MessageAddChild( "enabled|disabled" );
  1742.         MessageAddChild( "loop|unloop (broadcast only)" );
  1743.         MessageAddChild( "mux (mux_name)" );
  1745.         message_child = MessageAdd( "Schedule Proprieties Syntax:" );
  1746.         MessageAddChild( "enabled|disabled" );
  1747.         MessageAddChild( "append (command_until_rest_of_the_line)" );
  1748.         MessageAddChild( "date (year)/(month)/(day)-(hour):(minutes):"
  1749.                          "(seconds)|now" );
  1750.         MessageAddChild( "period (years_aka_12_months)/(months_aka_30_days)/"
  1751.                          "(days)-(hours):(minutes):(seconds)" );
  1752.         MessageAddChild( "repeat (number_of_repetitions)" );
  1754.         message_child = MessageAdd( "Control Commands Syntax:" );
  1755.         MessageAddChild( "play" );
  1756.         MessageAddChild( "pause" );
  1757.         MessageAddChild( "stop" );
  1758.         MessageAddChild( "seek (percentage)" );
  1760.         return message;
  1761.     }
  1763.     return vlm_MessageNew( "help", NULL );
  1764. }
  1766. /*****************************************************************************
  1767.  * Config handling functions
  1768.  *****************************************************************************/
  1769. static int vlm_Load( vlm_t *vlm, char *file )
  1770. {
  1771.     char *pf = file;
  1773.     while( *pf != '' )
  1774.     {
  1775.         vlm_message_t *message = NULL;
  1776.         int i_temp = 0;
  1777.         int i_next;
  1779.         while( pf[i_temp] != 'n' && pf[i_temp] != '' && pf[i_temp] != 'r' )
  1780.         {
  1781.             i_temp++;
  1782.         }
  1784.         if( pf[i_temp] == 'r' || pf[i_temp] == 'n' )
  1785.         {
  1786.             pf[i_temp] = '';
  1787.             i_next = i_temp + 1;
  1788.         }
  1789.         else
  1790.         {
  1791.             i_next = i_temp;
  1792.         }
  1794.         if( ExecuteCommand( vlm, pf, &message ) )
  1795.         {
  1796.             free( message );
  1797.             return 1;
  1798.         }
  1799.         free( message );
  1801.         pf += i_next;
  1802.     }
  1804.     return 0;
  1805. }
  1807. static char *vlm_Save( vlm_t *vlm )
  1808. {
  1809.     char *save = NULL;
  1810.     char *p;
  1811.     int i,j;
  1812.     int i_length = 0;
  1814.     for( i = 0; i < vlm->i_media; i++ )
  1815.     {
  1816.         vlm_media_t *media = vlm->media[i];
  1818.         if( media->i_type == VOD_TYPE )
  1819.         {
  1820.             i_length += strlen( "new  vod " ) + strlen(media->psz_name);
  1821.         }
  1822.         else
  1823.         {
  1824.             i_length += strlen( "new  broadcast " ) + strlen(media->psz_name);
  1825.         }
  1827.         if( media->b_enabled == VLC_TRUE )
  1828.         {
  1829.             i_length += strlen( "enabled" );
  1830.         }
  1831.         else
  1832.         {
  1833.             i_length += strlen( "disabled" );
  1834.         }
  1836.         if( media->b_loop == VLC_TRUE )
  1837.         {
  1838.             i_length += strlen( " loopn" );
  1839.         }
  1840.         else
  1841.         {
  1842.             i_length += strlen( "n" );
  1843.         }
  1845.         for( j = 0; j < media->i_input; j++ )
  1846.         {
  1847.             i_length += strlen( "setup  input ""n" ) +
  1848.                 strlen( media->psz_name ) + strlen( media->input[j] );
  1849.         }
  1851.         if( media->psz_output != NULL )
  1852.         {
  1853.             i_length += strlen(media->psz_name) + strlen(media->psz_output) +
  1854.                 strlen( "setup  output n" );
  1855.         }
  1857.         for( j=0 ; j < media->i_option ; j++ )
  1858.         {
  1859.             i_length += strlen(media->psz_name) + strlen(media->option[j]) +
  1860.                 strlen("setup  option n");
  1861.         }
  1862.     }
  1864.     for( i = 0; i < vlm->i_schedule; i++ )
  1865.     {
  1866.         vlm_schedule_t *schedule = vlm->schedule[i];
  1868.         i_length += strlen( "new  schedule " ) + strlen( schedule->psz_name );
  1870.         if( schedule->b_enabled == VLC_TRUE )
  1871.         {
  1872.             i_length += strlen( "date //-:: enabledn" ) + 14;
  1873.         }
  1874.         else
  1875.         {
  1876.             i_length += strlen( "date //-:: disabledn" ) + 14;
  1877.         }
  1880.         if( schedule->i_period != 0 )
  1881.         {
  1882.             i_length += strlen( "setup  " ) + strlen( schedule->psz_name ) +
  1883.                 strlen( "period //-::n" ) + 14;
  1884.         }
  1886.         if( schedule->i_repeat >= 0 )
  1887.         {
  1888.             char buffer[12];
  1890.             sprintf( buffer, "%d", schedule->i_repeat );
  1891.             i_length += strlen( "setup  repeat n" ) +
  1892.                 strlen( schedule->psz_name ) + strlen( buffer );
  1893.         }
  1894.         else
  1895.         {
  1896.             i_length++;
  1897.         }
  1899.         for( j = 0; j < schedule->i_command; j++ )
  1900.         {
  1901.             i_length += strlen( "setup  append n" ) +
  1902.                 strlen( schedule->psz_name ) + strlen( schedule->command[j] );
  1903.         }
  1905.     }
  1907.     /* Don't forget the '' */
  1908.     i_length++;
  1909.     /* now we have the length of save */
  1911.     p = save = malloc( i_length );
  1912.     *save = '';
  1914.     /* finally we can write in it */
  1915.     for( i = 0; i < vlm->i_media; i++ )
  1916.     {
  1917.         vlm_media_t *media = vlm->media[i];
  1919.         if( media->i_type == VOD_TYPE )
  1920.         {
  1921.             p += sprintf( p, "new %s vod ", media->psz_name);
  1922.         }
  1923.         else
  1924.         {
  1925.             p += sprintf( p, "new %s broadcast ", media->psz_name);
  1926.         }
  1928.         if( media->b_enabled == VLC_TRUE )
  1929.         {
  1930.             p += sprintf( p, "enabled" );
  1931.         }
  1932.         else
  1933.         {
  1934.             p += sprintf( p, "disabled" );
  1935.         }
  1937.         if( media->b_loop == VLC_TRUE )
  1938.         {
  1939.             p += sprintf( p, " loopn" );
  1940.         }
  1941.         else
  1942.         {
  1943.             p += sprintf( p, "n" );
  1944.         }
  1946.         for( j = 0; j < media->i_input; j++ )
  1947.         {
  1948.             p += sprintf( p, "setup %s input "%s"n", media->psz_name,
  1949.                           media->input[j] );
  1950.         }
  1952.         if( media->psz_output != NULL )
  1953.         {
  1954.             p += sprintf( p, "setup %s output %sn", media->psz_name,
  1955.                           media->psz_output );
  1956.         }
  1958.         for( j = 0; j < media->i_option; j++ )
  1959.         {
  1960.             p += sprintf( p, "setup %s option %sn", media->psz_name,
  1961.                           media->option[j] );
  1962.         }
  1963.     }
  1965.     /* and now, the schedule scripts */
  1966. #if !defined( UNDER_CE )
  1967.     for( i = 0; i < vlm->i_schedule; i++ )
  1968.     {
  1969.         vlm_schedule_t *schedule = vlm->schedule[i];
  1970.         struct tm date;
  1971.         time_t i_time = (time_t) ( schedule->i_date / 1000000 );
  1973. #ifdef HAVE_LOCALTIME_R
  1974.         localtime_r( &i_time, &date);
  1975. #else
  1976.         struct tm *p_date = localtime( &i_time );
  1977.         date = *p_date;
  1978. #endif
  1980.         p += sprintf( p, "new %s schedule ", schedule->psz_name);
  1982.         if( schedule->b_enabled == VLC_TRUE )
  1983.         {
  1984.             p += sprintf( p, "date %d/%d/%d-%d:%d:%d enabledn",
  1985.                           date.tm_year + 1900, date.tm_mon + 1, date.tm_mday,
  1986.                           date.tm_hour, date.tm_min, date.tm_sec );
  1987.         }
  1988.         else
  1989.         {
  1990.             p += sprintf( p, "date %d/%d/%d-%d:%d:%d disabledn",
  1991.                           date.tm_year + 1900, date.tm_mon + 1, date.tm_mday,
  1992.                           date.tm_hour, date.tm_min, date.tm_sec);
  1993.         }
  1995.         if( schedule->i_period != 0 )
  1996.         {
  1997.             p += sprintf( p, "setup %s ", schedule->psz_name );
  1999.             i_time = (time_t) ( schedule->i_period / 1000000 );
  2001.             date.tm_sec = (int)( i_time % 60 );
  2002.             i_time = i_time / 60;
  2003.             date.tm_min = (int)( i_time % 60 );
  2004.             i_time = i_time / 60;
  2005.             date.tm_hour = (int)( i_time % 24 );
  2006.             i_time = i_time / 24;
  2007.             date.tm_mday = (int)( i_time % 30 );
  2008.             i_time = i_time / 30;
  2009.             /* okay, okay, months are not always 30 days long */
  2010.             date.tm_mon = (int)( i_time % 12 );
  2011.             i_time = i_time / 12;
  2012.             date.tm_year = (int)i_time;
  2014.             p += sprintf( p, "period %d/%d/%d-%d:%d:%dn",
  2015.                           date.tm_year, date.tm_mon, date.tm_mday,
  2016.                           date.tm_hour, date.tm_min, date.tm_sec);
  2017.         }
  2019.         if( schedule->i_repeat >= 0 )
  2020.         {
  2021.             p += sprintf( p, "setup %s repeat %dn",
  2022.                           schedule->psz_name, schedule->i_repeat );
  2023.         }
  2024.         else
  2025.         {
  2026.             p += sprintf( p, "n" );
  2027.         }
  2029.         for( j = 0; j < schedule->i_command; j++ )
  2030.         {
  2031.             p += sprintf( p, "setup %s append %sn",
  2032.                           schedule->psz_name, schedule->command[j] );
  2033.         }
  2035.     }
  2036. #endif /* UNDER_CE */
  2038.     return save;
  2039. }
  2041. /*****************************************************************************
  2042.  * Manage:
  2043.  *****************************************************************************/
  2044. static int vlm_MediaVodControl( void *p_private, vod_media_t *p_vod_media,
  2045.                                 char *psz_id, int i_query, va_list args )
  2046. {
  2047.     vlm_t *vlm = (vlm_t *)p_private;
  2048.     int i, i_ret = VLC_EGENERIC;
  2050.     if( !p_private || !p_vod_media ) return VLC_EGENERIC;
  2052.     vlc_mutex_lock( &vlm->lock );
  2054.     /* Find media */
  2055.     for( i = 0; i < vlm->i_media; i++ )
  2056.     {
  2057.         if( p_vod_media == vlm->media[i]->vod_media ) break;
  2058.     }
  2060.     if( i == vlm->i_media )
  2061.     {
  2062.         vlc_mutex_unlock( &vlm->lock );
  2063.         return VLC_EGENERIC;
  2064.     }
  2066.     switch( i_query )
  2067.     {
  2068.     case VOD_MEDIA_PLAY:
  2069.         vlm->media[i]->psz_vod_output = (char *)va_arg( args, char * );
  2070.         i_ret = vlm_MediaControl( vlm, vlm->media[i], psz_id, "play", 0 );
  2071.         vlm->media[i]->psz_vod_output = 0;
  2072.         break;
  2074.     case VOD_MEDIA_PAUSE:
  2075.         i_ret = vlm_MediaControl( vlm, vlm->media[i], psz_id, "pause", 0 );
  2076.         break;
  2078.     case VOD_MEDIA_STOP:
  2079.         i_ret = vlm_MediaControl( vlm, vlm->media[i], psz_id, "stop", 0 );
  2080.         break;
  2082.     default:
  2083.         break;
  2084.     }
  2086.     vlc_mutex_unlock( &vlm->lock );
  2088.     return i_ret;
  2089. }
  2091. /*****************************************************************************
  2092.  * Manage:
  2093.  *****************************************************************************/
  2094. static int Manage( vlc_object_t* p_object )
  2095. {
  2096.     vlm_t *vlm = (vlm_t*)p_object;
  2097.     int i, j;
  2098.     mtime_t i_lastcheck;
  2099.     mtime_t i_time;
  2101.     i_lastcheck = mdate();
  2103.     msleep( 100000 );
  2105.     while( !vlm->b_die )
  2106.     {
  2107.         vlc_mutex_lock( &vlm->lock );
  2109.         /* destroy the inputs that wants to die, and launch the next input */
  2110.         for( i = 0; i < vlm->i_media; i++ )
  2111.         {
  2112.             vlm_media_t *p_media = vlm->media[i];
  2114.             for( j = 0; j < p_media->i_instance; j++ )
  2115.             {
  2116.                 vlm_media_instance_t *p_instance = p_media->instance[j];
  2118.                 if( !p_instance->p_input ||
  2119.                     ( !p_instance->p_input->b_eof &&
  2120.                       !p_instance->p_input->b_error ) ) continue;
  2122.                 input_StopThread( p_instance->p_input );
  2123.                 input_DestroyThread( p_instance->p_input );
  2124.                 vlc_object_detach( p_instance->p_input );
  2125.                 vlc_object_destroy( p_instance->p_input );
  2127.                 p_instance->i_index++;
  2128.                 if( p_instance->i_index == p_media->i_input &&
  2129.                     p_media->b_loop ) p_instance->i_index = 0;
  2131.                 if( p_instance->i_index < p_media->i_input )
  2132.                 {
  2133.                     /* FIXME, find a way to select the right instance */
  2134.                     char buffer[12];
  2135.                     sprintf( buffer, "%d", p_instance->i_index );
  2136.                     vlm_MediaControl( vlm, p_media, p_instance->psz_name,
  2137.                                       "play", buffer );
  2138.                 }
  2139.                 else
  2140.                 {
  2141.                     if( vlm_MediaControl( vlm, p_media, p_instance->psz_name,
  2142.                                           "stop", 0 ) == VLC_SUCCESS ) i--;
  2143.                 }
  2144.             }
  2145.         }
  2147.         /* scheduling */
  2148.         i_time = mdate();
  2150.         for( i = 0; i < vlm->i_schedule; i++ )
  2151.         {
  2152.             mtime_t i_real_date = vlm->schedule[i]->i_date;
  2154.             if( vlm->schedule[i]->b_enabled == VLC_TRUE )
  2155.             {
  2156.                 if( vlm->schedule[i]->i_date == 0 ) // now !
  2157.                 {
  2158.                     vlm->schedule[i]->i_date = (i_time / 1000000) * 1000000 ;
  2159.                     i_real_date = i_time;
  2160.                 }
  2161.                 else if( vlm->schedule[i]->i_period != 0 )
  2162.                 {
  2163.                     int j = 0;
  2164.                     while( vlm->schedule[i]->i_date + j *
  2165.                            vlm->schedule[i]->i_period <= i_lastcheck &&
  2166.                            ( vlm->schedule[i]->i_repeat > j ||
  2167.                              vlm->schedule[i]->i_repeat == -1 ) )
  2168.                     {
  2169.                         j++;
  2170.                     }
  2172.                     i_real_date = vlm->schedule[i]->i_date + j *
  2173.                         vlm->schedule[i]->i_period;
  2174.                 }
  2176.                 if( i_real_date <= i_time && i_real_date > i_lastcheck )
  2177.                 {
  2178.                     for( j = 0; j < vlm->schedule[i]->i_command; j++ )
  2179.                     {
  2180.                         vlm_message_t *message = NULL;
  2182.                         ExecuteCommand( vlm, vlm->schedule[i]->command[j],
  2183.                                         &message );
  2185.                         /* for now, drop the message */
  2186.                         free( message );
  2187.                     }
  2188.                 }
  2189.             }
  2190.         }
  2192.         i_lastcheck = i_time;
  2194.         vlc_mutex_unlock( &vlm->lock );
  2196.         msleep( 100000 );
  2197.     }
  2199.     return VLC_SUCCESS;
  2200. }
  2202. #else /* ENABLE_VLM */
  2204. /* We just define an empty wrapper */
  2205. vlm_t *__vlm_New( vlc_object_t *a )
  2206. {
  2207.     msg_Err( a, "VideoLAN manager support is disabled" );
  2208.     return 0;
  2209. }
  2210. void vlm_Delete( vlm_t *a ){}
  2211. int vlm_ExecuteCommand( vlm_t *a, char *b, vlm_message_t **c ){ return -1; }
  2212. void vlm_MessageDelete( vlm_message_t *a ){}
  2214. #endif /* ENABLE_VLM */