vlm.c

video linux conference

        for( i = 0; i < vlm->i_media; i++ )
        {
            if( vlm->media[i]->i_type == VOD_TYPE )
                i_vod ++;
            else
                i_broadcast ++;
        }

        asprintf( &psz_count, "( %d broadcast - %d vod )", i_broadcast, i_vod);

        msg = vlm_MessageNew( "show", NULL );
        msg_child = vlm_MessageAdd( msg, vlm_MessageNew( "media", psz_count ) );
        free( psz_count );

        for( i = 0; i < vlm->i_media; i++ )
        {
            vlm_media_t *m = vlm->media[i];
            vlm_message_t *msg_media, *msg_instance;

            msg_media = vlm_MessageAdd( msg_child,
                                        vlm_MessageNew( m->psz_name, 0 ) );

            vlm_MessageAdd( msg_media,
                            vlm_MessageNew( "type", m->i_type == VOD_TYPE ?
                                            "vod" : "broadcast" ) );

            vlm_MessageAdd( msg_media,
                            vlm_MessageNew( "enabled", m->b_enabled ?
                                            "yes" : "no" ) );

            if( m->i_type == VOD_TYPE && m->psz_mux )
                vlm_MessageAdd( msg_media,
                                vlm_MessageNew( "mux", m->psz_mux ) );

            msg_instance = vlm_MessageAdd( msg_media,
                                           vlm_MessageNew( "instances", 0 ) );

            for( j = 0; j < m->i_instance; j++ )
            {
                vlm_media_instance_t *p_instance = m->instance[j];
                vlc_value_t val;

                if( !p_instance->p_input ) val.i_int = END_S;
                else var_Get( p_instance->p_input, "state", &val );

                vlm_MessageAdd( msg_instance,
                    vlm_MessageNew( p_instance->psz_name ?
                                    p_instance->psz_name : "default",
                                    val.i_int == PLAYING_S ? "playing" :
                                    val.i_int == PAUSE_S ? "paused" :
                                    "stopped" ) );
            }
        }

        return msg;
    }

    else if( psz_filter && !strcmp( psz_filter, "schedule" ) )
    {
        int i;
        vlm_message_t *msg;
        vlm_message_t *msg_child;

        msg = vlm_MessageNew( "show", NULL );
        msg_child = vlm_MessageAdd( msg, vlm_MessageNew( "schedule", NULL ) );

        for( i = 0; i < vlm->i_schedule; i++ )
        {
            vlm_schedule_t *s = vlm->schedule[i];
            vlm_message_t *msg_schedule;
            mtime_t i_time, i_next_date;

            msg_schedule = vlm_MessageAdd( msg_child,
                                           vlm_MessageNew( s->psz_name, 0 ) );
            vlm_MessageAdd( msg_schedule,
                            vlm_MessageNew( "enabled", s->b_enabled ?
                                            "yes" : "no" ) );

            if( !s->b_enabled ) return msg;


            vlm_MessageAdd( msg_schedule,
                            vlm_MessageNew( "enabled", "yes" ) );

            /* calculate next date */
            i_time = vlm_Date();
            i_next_date = s->i_date;

            if( s->i_period != 0 )
            {
                int j = 0;
                while( s->i_date + j * s->i_period <= i_time &&
                       s->i_repeat > j )
                {
                    j++;
                }

                i_next_date = s->i_date + j * s->i_period;
            }

            if( i_next_date > i_time )
            {
                time_t i_date = (time_t) (i_next_date / 1000000) ;

#if !defined( UNDER_CE )
#ifdef HAVE_CTIME_R
                char psz_date[500];
                ctime_r( &i_date, psz_date );
#else
                char *psz_date = ctime( &i_date );
#endif

                vlm_MessageAdd( msg_schedule,
                                vlm_MessageNew( "next launch", psz_date ) );
#endif
            }
        }

        return msg;
    }

    else if( psz_filter == NULL && media == NULL && schedule == NULL )
    {
        vlm_message_t *show1 = vlm_Show( vlm, NULL, NULL, "media" );
        vlm_message_t *show2 = vlm_Show( vlm, NULL, NULL, "schedule" );

        vlm_MessageAdd( show1, show2->child[0] );

        /* We must destroy the parent node "show" of show2
         * and not the children */
        free( show2->psz_name );
        free( show2 );

        return show1;
    }

    else
    {
        return vlm_MessageNew( "show", NULL );
    }
}

static vlm_message_t *vlm_Help( vlm_t *vlm, char *psz_filter )
{
    vlm_message_t *message, *message_child;

#define MessageAdd( a ) \
        vlm_MessageAdd( message, vlm_MessageNew( a, NULL ) );
#define MessageAddChild( a ) \
        vlm_MessageAdd( message_child, vlm_MessageNew( a, NULL ) );

    if( psz_filter == NULL )
    {
        message = vlm_MessageNew( "help", NULL );

        message_child = MessageAdd( "Commands Syntax:" );
        MessageAddChild( "new (name) vod|broadcast|schedule [properties]" );
        MessageAddChild( "setup (name) (properties)" );
        MessageAddChild( "show [(name)|media|schedule]" );
        MessageAddChild( "del (name)|all|media|schedule" );
        MessageAddChild( "control (name) [instance_name] (command)" );
        MessageAddChild( "save (config_file)" );
        MessageAddChild( "load (config_file)" );

        message_child = MessageAdd( "Media Proprieties Syntax:" );
        MessageAddChild( "input (input_name)" );
        MessageAddChild( "inputdel (input_name)|all" );
        MessageAddChild( "inputdeln input_number" );
        MessageAddChild( "output (output_name)" );
        MessageAddChild( "option (option_name)[=value]" );
        MessageAddChild( "enabled|disabled" );
        MessageAddChild( "loop|unloop (broadcast only)" );
        MessageAddChild( "mux (mux_name)" );

        message_child = MessageAdd( "Schedule Proprieties Syntax:" );
        MessageAddChild( "enabled|disabled" );
        MessageAddChild( "append (command_until_rest_of_the_line)" );
        MessageAddChild( "date (year)/(month)/(day)-(hour):(minutes):"
                         "(seconds)|now" );
        MessageAddChild( "period (years_aka_12_months)/(months_aka_30_days)/"
                         "(days)-(hours):(minutes):(seconds)" );
        MessageAddChild( "repeat (number_of_repetitions)" );

        message_child = MessageAdd( "Control Commands Syntax:" );
        MessageAddChild( "play" );
        MessageAddChild( "pause" );
        MessageAddChild( "stop" );
        MessageAddChild( "seek (percentage)" );

        return message;
    }

    return vlm_MessageNew( "help", NULL );
}

/*****************************************************************************
 * Config handling functions
 *****************************************************************************/
static int Load( vlm_t *vlm, char *file )
{
    char *pf = file;

    while( *pf != '\0' )
    {
        vlm_message_t *message = NULL;
        int i_end = 0;

        while( pf[i_end] != '\n' && pf[i_end] != '\0' && pf[i_end] != '\r' )
        {
            i_end++;
        }

        if( pf[i_end] == '\r' || pf[i_end] == '\n' )
        {
            pf[i_end] = '\0';
            i_end++;
            if( pf[i_end] == '\n' ) i_end++;
        }

        if( *pf && ExecuteCommand( vlm, pf, &message ) )
        {
            if( message ) free( message );
            return 1;
        }
        if( message ) free( message );

        pf += i_end;
    }

    return 0;
}

static char *Save( vlm_t *vlm )
{
    char *save = NULL;
    char *p;
    int i,j;
    int i_length = 0;

    for( i = 0; i < vlm->i_media; i++ )
    {
        vlm_media_t *media = vlm->media[i];

        if( media->i_type == VOD_TYPE )
        {
            i_length += strlen( "new  vod " ) + strlen(media->psz_name);
        }
        else
        {
            i_length += strlen( "new  broadcast " ) + strlen(media->psz_name);
        }

        if( media->b_enabled == VLC_TRUE )
        {
            i_length += strlen( "enabled" );
        }
        else
        {
            i_length += strlen( "disabled" );
        }

        if( media->b_loop == VLC_TRUE )
        {
            i_length += strlen( " loop\n" );
        }
        else
        {
            i_length += strlen( "\n" );
        }

        for( j = 0; j < media->i_input; j++ )
        {
            i_length += strlen( "setup  input \"\"\n" ) +
                strlen( media->psz_name ) + strlen( media->input[j] );
        }

        if( media->psz_output != NULL )
        {
            i_length += strlen(media->psz_name) + strlen(media->psz_output) +
                strlen( "setup  output \n" );
        }

        for( j=0 ; j < media->i_option ; j++ )
        {
            i_length += strlen(media->psz_name) + strlen(media->option[j]) +
                strlen("setup  option \n");
        }
    }

    for( i = 0; i < vlm->i_schedule; i++ )
    {
        vlm_schedule_t *schedule = vlm->schedule[i];

        i_length += strlen( "new  schedule " ) + strlen( schedule->psz_name );

        if( schedule->b_enabled == VLC_TRUE )
        {
            i_length += strlen( "date //-:: enabled\n" ) + 14;
        }
        else
        {
            i_length += strlen( "date //-:: disabled\n" ) + 14;
        }


        if( schedule->i_period != 0 )
        {
            i_length += strlen( "setup  " ) + strlen( schedule->psz_name ) +
                strlen( "period //-::\n" ) + 14;
        }

        if( schedule->i_repeat >= 0 )
        {
            char buffer[12];

            sprintf( buffer, "%d", schedule->i_repeat );
            i_length += strlen( "setup  repeat \n" ) +
                strlen( schedule->psz_name ) + strlen( buffer );
        }
        else
        {
            i_length++;
        }

        for( j = 0; j < schedule->i_command; j++ )
        {
            i_length += strlen( "setup  append \n" ) +
                strlen( schedule->psz_name ) + strlen( schedule->command[j] );
        }

    }

    /* Don't forget the '\0' */
    i_length++;
    /* now we have the length of save */

    p = save = malloc( i_length );
    *save = '\0';

    /* finally we can write in it */
    for( i = 0; i < vlm->i_media; i++ )
    {
        vlm_media_t *media = vlm->media[i];

        if( media->i_type == VOD_TYPE )
        {
            p += sprintf( p, "new %s vod ", media->psz_name);
        }
        else
        {
            p += sprintf( p, "new %s broadcast ", media->psz_name);
        }

        if( media->b_enabled == VLC_TRUE )
        {
            p += sprintf( p, "enabled" );
        }
        else
        {
            p += sprintf( p, "disabled" );
        }

        if( media->b_loop == VLC_TRUE )
        {
            p += sprintf( p, " loop\n" );
        }
        else
        {
            p += sprintf( p, "\n" );
        }

        for( j = 0; j < media->i_input; j++ )
        {
            p += sprintf( p, "setup %s input \"%s\"\n", media->psz_name,
                          media->input[j] );
        }

        if( media->psz_output != NULL )
        {
            p += sprintf( p, "setup %s output %s\n", media->psz_name,
                          media->psz_output );
        }

        for( j = 0; j < media->i_option; j++ )
        {
            p += sprintf( p, "setup %s option %s\n", media->psz_name,
                          media->option[j] );
        }
    }

    /* and now, the schedule scripts */
#if !defined( UNDER_CE )
    for( i = 0; i < vlm->i_schedule; i++ )
    {
        vlm_schedule_t *schedule = vlm->schedule[i];
        struct tm date;
        time_t i_time = (time_t) ( schedule->i_date / 1000000 );

#ifdef HAVE_LOCALTIME_R
        localtime_r( &i_time, &date);
#else
        struct tm *p_date = localtime( &i_time );
        date = *p_date;
#endif

        p += sprintf( p, "new %s schedule ", schedule->psz_name);

        if( schedule->b_enabled == VLC_TRUE )
        {
            p += sprintf( p, "date %d/%d/%d-%d:%d:%d enabled\n",
                          date.tm_year + 1900, date.tm_mon + 1, date.tm_mday,
                          date.tm_hour, date.tm_min, date.tm_sec );
        }
        else
        {
            p += sprintf( p, "date %d/%d/%d-%d:%d:%d disabled\n",
                          date.tm_year + 1900, date.tm_mon + 1, date.tm_mday,
                          date.tm_hour, date.tm_min, date.tm_sec);
        }

        if( schedule->i_period != 0 )
        {
            p += sprintf( p, "setup %s ", schedule->psz_name );

            i_time = (time_t) ( schedule->i_period / 1000000 );

            date.tm_sec = (int)( i_time % 60 );
            i_time = i_time / 60;
            date.tm_min = (int)( i_time % 60 );
            i_time = i_time / 60;
            date.tm_hour = (int)( i_time % 24 );
            i_time = i_time / 24;
            date.tm_mday = (int)( i_time % 30 );