vlm.c

uclinux 下的vlc播放器源代码

                            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;
            vlm_message_t *msg_instance;
            char *psz_tmp;

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

            msg_instance = vlm_MessageNew( "instance" , NULL );
            vlm_MessageAdd( msg_instance, vlm_MessageNew( "name" , p_instance->psz_name ? p_instance->psz_name : "default" ) );
            vlm_MessageAdd( msg_instance, vlm_MessageNew( "state",
                                val.i_int == PLAYING_S ? "playing" :
                                val.i_int == PAUSE_S ? "paused" :
                                "stopped" ) );
#define APPEND_INPUT_INFO( a, format, type ) \
            asprintf( &psz_tmp, format, \
                      var_Get ## type( p_instance->p_input, a ) ); \
            vlm_MessageAdd( msg_instance, vlm_MessageNew( a, psz_tmp ) ); \
            free( psz_tmp );
            APPEND_INPUT_INFO( "position", "%f", Float );
            APPEND_INPUT_INFO( "time", I64Fi, Time );
            APPEND_INPUT_INFO( "length", I64Fi, Time );
            APPEND_INPUT_INFO( "rate", "%d", Integer );
            APPEND_INPUT_INFO( "title", "%d", Integer );
            APPEND_INPUT_INFO( "chapter", "%d", Integer );
            APPEND_INPUT_INFO( "seekable", "%d", Bool );
#undef APPEND_INPUT_INFO
            asprintf( &psz_tmp, "%d", p_instance->i_index + 1 );
            vlm_MessageAdd( msg_instance, vlm_MessageNew( "playlistindex", psz_tmp ) );
            free( psz_tmp );
            vlm_MessageAdd( msg_child, msg_instance );
        }

        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;

        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" ) );

            /* 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( "export" );
        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) | [+-](seconds)s | [+-](milliseconds)ms" );

        return message;
    }

    return vlm_MessageNew( "help", NULL );
}

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

    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 )
            {
                if( message->psz_value )
                    msg_Err( vlm, "Load error on line %d: %s: %s",
                             i_line, message->psz_name, message->psz_value );
                vlm_MessageDelete( message );
            }
            return 1;
        }
        if( message ) vlm_MessageDelete( message );

        pf += i_end;
        i_line++;
    }

    return 0;
}

static char *Save( vlm_t *vlm )
{
    char *save = NULL;
    char psz_header[] = "\n"
                        "# VLC media player VLM command batch\n"
                        "# http://www.videolan.org/vlc/\n\n" ;
    char *p;
    int i,j;
    int i_length = strlen( psz_header );

    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"