vlm.c

video linux conference

    for( i = 0; i < vlm->i_schedule; i++ )
    {
        if( strcmp( psz_name, vlm->schedule[i]->psz_name ) == 0 )
        {
            return vlm->schedule[i];
        }
    }

    return NULL;
}

/* Ok, setup schedule command will be able to support only one (argument value) at a time  */
int vlm_ScheduleSetup( vlm_schedule_t *schedule, char *psz_cmd,
                       char *psz_value )
{
    if( !strcmp( psz_cmd, "enabled" ) )
    {
        schedule->b_enabled = VLC_TRUE;
    }
    else if( !strcmp( psz_cmd, "disabled" ) )
    {
        schedule->b_enabled = VLC_FALSE;
    }
#if !defined( UNDER_CE )
    else if( !strcmp( psz_cmd, "date" ) )
    {
        struct tm time;
        char *p;
        time_t date;

        time.tm_sec = 0;         /* seconds */
        time.tm_min = 0;         /* minutes */
        time.tm_hour = 0;        /* hours */
        time.tm_mday = 0;        /* day of the month */
        time.tm_mon = 0;         /* month */
        time.tm_year = 0;        /* year */
        time.tm_wday = 0;        /* day of the week */
        time.tm_yday = 0;        /* day in the year */
        time.tm_isdst = -1;       /* daylight saving time */

        /* date should be year/month/day-hour:minutes:seconds */
        p = strchr( psz_value, '-' );

        if( !strcmp( psz_value, "now" ) )
        {
            schedule->i_date = 0;
        }
        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 */
        {
            return 1;
        }
        else
        {
            int i,j,k;

            switch( sscanf( p + 1, "%d:%d:%d", &i, &j, &k ) )
            {
                case 1:
                    time.tm_sec = i;
                    break;
                case 2:
                    time.tm_min = i;
                    time.tm_sec = j;
                    break;
                case 3:
                    time.tm_hour = i;
                    time.tm_min = j;
                    time.tm_sec = k;
                    break;
                default:
                    return 1;
            }

            *p = '\0';

            switch( sscanf( psz_value, "%d/%d/%d", &i, &j, &k ) )
            {
                case 1:
                    time.tm_mday = i;
                    break;
                case 2:
                    time.tm_mon = i - 1;
                    time.tm_mday = j;
                    break;
                case 3:
                    time.tm_year = i - 1900;
                    time.tm_mon = j - 1;
                    time.tm_mday = k;
                    break;
                default:
                    return 1;
            }

            date = mktime( &time );
            schedule->i_date = ((mtime_t) date) * 1000000;
        }
    }
    else if( !strcmp( psz_cmd, "period" ) )
    {
        struct tm time;
        char *p;
        char *psz_time = NULL, *psz_date = NULL;
        time_t date;
        int i,j,k;

        /* First, if date or period are modified, repeat should be equal to -1 */
        schedule->i_repeat = -1;

        time.tm_sec = 0;         /* seconds */
        time.tm_min = 0;         /* minutes */
        time.tm_hour = 0;        /* hours */
        time.tm_mday = 0;        /* day of the month */
        time.tm_mon = 0;         /* month */
        time.tm_year = 0;        /* year */
        time.tm_wday = 0;        /* day of the week */
        time.tm_yday = 0;        /* day in the year */
        time.tm_isdst = -1;       /* daylight saving time */

        /* date should be year/month/day-hour:minutes:seconds */
        p = strchr( psz_value, '-' );
        if( p )
        {
            psz_date = psz_value;
            psz_time = p + 1;

            *p = '\0';
        }
        else
        {
            psz_time = psz_value;
        }


        switch( sscanf( psz_time, "%d:%d:%d", &i, &j, &k ) )
        {
            case 1:
                time.tm_sec = i;
                break;
            case 2:
                time.tm_min = i;
                time.tm_sec = j;
                break;
            case 3:
                time.tm_hour = i;
                time.tm_min = j;
                time.tm_sec = k;
                break;
            default:
                return 1;
        }
        if( psz_date )
        {
            switch( sscanf( psz_date, "%d/%d/%d", &i, &j, &k ) )
            {
                case 1:
                    time.tm_mday = i;
                    break;
                case 2:
                    time.tm_mon = i;
                    time.tm_mday = j;
                    break;
                case 3:
                    time.tm_year = i;
                    time.tm_mon = j;
                    time.tm_mday = k;
                    break;
                default:
                    return 1;
            }
        }

        /* ok, that's stupid... who is going to schedule streams every 42 years ? */
        date = (((( time.tm_year * 12 + time.tm_mon ) * 30 + time.tm_mday ) * 24 + time.tm_hour ) * 60 + time.tm_min ) * 60 + time.tm_sec ;
        schedule->i_period = ((mtime_t) date) * 1000000;
    }
#endif /* UNDER_CE */
    else if( !strcmp( psz_cmd, "repeat" ) )
    {
        int i;

        if( sscanf( psz_value, "%d", &i ) == 1 )
        {
            schedule->i_repeat = i;
        }
        else
        {
            return 1;
        }
    }
    else if( !strcmp( psz_cmd, "append" ) )
    {
        char *command = strdup( psz_value );

        TAB_APPEND( schedule->i_command, schedule->command, command );
    }
    else
    {
        return 1;
    }
    return 0;
}

/*****************************************************************************
 * Message handling functions
 *****************************************************************************/
static vlm_message_t *vlm_MessageNew( char *psz_name,
                                      const char *psz_format, ... )
{
    vlm_message_t *p_message;
    va_list args;

    if( !psz_name ) return 0;

    p_message = malloc( sizeof(vlm_message_t) );
    if( !p_message)
    {
        return NULL;
    }

    p_message->psz_value = 0;

    if( psz_format )
    {
        va_start( args, psz_format );
        if( vasprintf( &p_message->psz_value, psz_format, args ) < 0 )
        {
            va_end( args );
            free( p_message );
            return 0;
        }
        va_end( args );
    }

    p_message->psz_name = strdup( psz_name );
    p_message->i_child = 0;
    p_message->child = NULL;

    return p_message;
}

void vlm_MessageDelete( vlm_message_t *p_message )
{
    if( p_message->psz_name ) free( p_message->psz_name );
    if( p_message->psz_value ) free( p_message->psz_value );
    while( p_message->i_child-- )
        vlm_MessageDelete( p_message->child[p_message->i_child] );
    if( p_message->child ) free( p_message->child );
    free( p_message );
}

/* Add a child */
static vlm_message_t *vlm_MessageAdd( vlm_message_t *p_message,
                                      vlm_message_t *p_child )
{
    if( p_message == NULL ) return NULL;

    if( p_child )
    {
        TAB_APPEND( p_message->i_child, p_message->child, p_child );
    }

    return p_child;
}

/*****************************************************************************
 * Misc utility functions
 *****************************************************************************/
static vlm_message_t *vlm_Show( vlm_t *vlm, vlm_media_t *media,
                                vlm_schedule_t *schedule, char *psz_filter )
{
    if( media != NULL )
    {
        int i;
        vlm_message_t *msg;
        vlm_message_t *msg_media;
        vlm_message_t *msg_child;

        msg = vlm_MessageNew( "show", NULL );
        msg_media = vlm_MessageAdd( msg, vlm_MessageNew( media->psz_name, 0 ));

        vlm_MessageAdd( msg_media,
                        vlm_MessageNew( "type", media->i_type == VOD_TYPE ?
                                        "vod" : "broadcast" ) );
        vlm_MessageAdd( msg_media,
                        vlm_MessageNew( "enabled", media->b_enabled ?
                                        "yes" : "no" ) );

        vlm_MessageAdd( msg_media,
                        vlm_MessageNew( "loop", media->b_loop ?
                                        "yes" : "no" ) );

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

        msg_child = vlm_MessageAdd( msg_media,
                                    vlm_MessageNew( "inputs", NULL ) );

        for( i = 0; i < media->i_input; i++ )
        {
            vlm_MessageAdd( msg_child,
                            vlm_MessageNew( media->input[i], NULL ) );
        }

        vlm_MessageAdd( msg_media,
                        vlm_MessageNew( "output", media->psz_output ?
                                        media->psz_output : "" ) );

        msg_child = vlm_MessageAdd( msg_media, vlm_MessageNew( "options", 0 ));

        for( i = 0; i < media->i_option; i++ )
        {
            vlm_MessageAdd( msg_child, vlm_MessageNew( media->option[i], 0 ) );
        }

        msg_child = vlm_MessageAdd( msg_media,
                                    vlm_MessageNew( "instances", NULL ) );

        for( i = 0; i < media->i_instance; i++ )
        {
            vlm_media_instance_t *p_instance = media->instance[i];
            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_child,
                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( schedule != NULL )
    {
        int i;
        vlm_message_t *msg;
        vlm_message_t *msg_schedule;
        vlm_message_t *msg_child;
        char buffer[100];

        msg = vlm_MessageNew( "show", NULL );
        msg_schedule =
            vlm_MessageAdd( msg, vlm_MessageNew( schedule->psz_name, 0 ) );

        vlm_MessageAdd( msg_schedule, vlm_MessageNew("type", "schedule") );

        vlm_MessageAdd( msg_schedule,
                        vlm_MessageNew( "enabled", schedule->b_enabled ?
                                        "yes" : "no" ) );

#if !defined( UNDER_CE )
        if( schedule->i_date != 0 )
        {
            struct tm date;
            time_t i_time = (time_t)( schedule->i_date / 1000000 );
            char *psz_date;

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

            asprintf( &psz_date, "%d/%d/%d-%d:%d:%d",
                      date.tm_year + 1900, date.tm_mon + 1, date.tm_mday,
                      date.tm_hour, date.tm_min, date.tm_sec );

            vlm_MessageAdd( msg_schedule,
                            vlm_MessageNew( "date", psz_date ) );
            free( psz_date );
        }
        else
        {
            vlm_MessageAdd( msg_schedule, vlm_MessageNew("date", "now") );
        }

        if( schedule->i_period != 0 )
        {
            time_t i_time = (time_t) ( schedule->i_period / 1000000 );
            struct tm date;

            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 );
            i_time = i_time / 30;
            /* okay, okay, months are not always 30 days long */
            date.tm_mon = (int)( i_time % 12 );
            i_time = i_time / 12;
            date.tm_year = (int)i_time;

            sprintf( buffer, "%d/%d/%d-%d:%d:%d", date.tm_year, date.tm_mon,
                     date.tm_mday, date.tm_hour, date.tm_min, date.tm_sec);

            vlm_MessageAdd( msg_schedule, vlm_MessageNew("period", buffer) );
        }
        else
        {
            vlm_MessageAdd( msg_schedule, vlm_MessageNew("period", "0") );
        }
#endif /* UNDER_CE */

        sprintf( buffer, "%d", schedule->i_repeat );
        vlm_MessageAdd( msg_schedule, vlm_MessageNew( "repeat", buffer ) );

        msg_child =
            vlm_MessageAdd( msg_schedule, vlm_MessageNew("commands", 0) );

        for( i = 0; i < schedule->i_command; i++ )
        {
           vlm_MessageAdd( msg_child,
                           vlm_MessageNew( schedule->command[i], NULL ) );
        }

        return msg;

    }

    else if( psz_filter && !strcmp( psz_filter, "media" ) )
    {
        int i, j;
        vlm_message_t *msg;
        vlm_message_t *msg_child;
        int i_vod = 0, i_broadcast = 0;
        char *psz_count;