mvar.c

uclinux 下的vlc播放器源代码

mvar_t *E_(mvar_InputVarSetNew)( intf_thread_t *p_intf, char *name,
                                 input_thread_t *p_input,
                                 const char *psz_variable )
{
    intf_sys_t     *p_sys = p_intf->p_sys;
    mvar_t *s = E_(mvar_New)( name, "set" );
    vlc_value_t val, val_list, text_list;
    int i_type, i;

    if( p_input == NULL )
    {
        return s;
    }

    /* Check the type of the object variable */
    i_type = var_Type( p_sys->p_input, psz_variable );

    /* Make sure we want to display the variable */
    if( i_type & VLC_VAR_HASCHOICE )
    {
        var_Change( p_sys->p_input, psz_variable, VLC_VAR_CHOICESCOUNT, &val, NULL );
        if( val.i_int == 0 ) return s;
        if( (i_type & VLC_VAR_TYPE) != VLC_VAR_VARIABLE && val.i_int == 1 )
            return s;
    }
    else
    {
        return s;
    }

    switch( i_type & VLC_VAR_TYPE )
    {
    case VLC_VAR_VOID:
    case VLC_VAR_BOOL:
    case VLC_VAR_VARIABLE:
    case VLC_VAR_STRING:
    case VLC_VAR_INTEGER:
        break;
    default:
        /* Variable doesn't exist or isn't handled */
        return s;
    }

    if( var_Get( p_sys->p_input, psz_variable, &val ) < 0 )
    {
        return s;
    }

    if( var_Change( p_sys->p_input, psz_variable, VLC_VAR_GETLIST,
                    &val_list, &text_list ) < 0 )
    {
        if( (i_type & VLC_VAR_TYPE) == VLC_VAR_STRING ) free( val.psz_string );
        return s;
    }

    for( i = 0; i < val_list.p_list->i_count; i++ )
    {
        char *psz, psz_int[16];
        mvar_t *itm;

        switch( i_type & VLC_VAR_TYPE )
        {
        case VLC_VAR_STRING:
            itm = E_(mvar_New)( name, "set" );
            psz = E_(FromUTF8)( p_intf, text_list.p_list->p_values[i].psz_string );
            E_(mvar_AppendNewVar)( itm, "name", psz );
            psz = E_(FromUTF8)( p_intf, val_list.p_list->p_values[i].psz_string );
            E_(mvar_AppendNewVar)( itm, "id", psz );
            free( psz );
            snprintf( psz_int, sizeof(psz_int), "%d",
                      ( !strcmp( val.psz_string,
                                   val_list.p_list->p_values[i].psz_string )
                           && !( i_type & VLC_VAR_ISCOMMAND ) ) );
            E_(mvar_AppendNewVar)( itm, "selected", psz_int );
            E_(mvar_AppendVar)( s, itm );
            break;

        case VLC_VAR_INTEGER:
            itm = E_(mvar_New)( name, "set" );
            psz = E_(FromUTF8)( p_intf, text_list.p_list->p_values[i].psz_string );
            E_(mvar_AppendNewVar)( itm, "name", psz );
            snprintf( psz_int, sizeof(psz_int), "%d",
                      val_list.p_list->p_values[i].i_int );
            E_(mvar_AppendNewVar)( itm, "id", psz_int );
            snprintf( psz_int, sizeof(psz_int), "%d",
                      ( val.i_int == val_list.p_list->p_values[i].i_int )
                         && !( i_type & VLC_VAR_ISCOMMAND ) );
            E_(mvar_AppendNewVar)( itm, "selected", psz_int );
            E_(mvar_AppendVar)( s, itm );
            break;

        default:
            break;
        }
    }
    /* clean up everything */
    if( (i_type & VLC_VAR_TYPE) == VLC_VAR_STRING ) free( val.psz_string );
    var_Change( p_sys->p_input, psz_variable, VLC_VAR_FREELIST, &val_list,
                &text_list );
    return s;
}

#if 0
mvar_t *E_(mvar_HttpdInfoSetNew)( char *name, httpd_t *p_httpd, int i_type )
{
    mvar_t       *s = E_(mvar_New)( name, "set" );
    httpd_info_t info;
    int          i;

    if( !p_httpd->pf_control( p_httpd, i_type, &info, NULL ) )
    {
        for( i= 0; i < info.i_count; )
        {
            mvar_t *inf;

            inf = E_(mvar_New)( name, "set" );
            do
            {
                /* fprintf( stderr," mvar_HttpdInfoSetNew: append name=`%s' value=`%s'\n",
                            info.info[i].psz_name, info.info[i].psz_value ); */
                E_(mvar_AppendNewVar)( inf,
                                   info.info[i].psz_name,
                                   info.info[i].psz_value );
                i++;
            } while( i < info.i_count && strcmp( info.info[i].psz_name, "id" ) );
            E_(mvar_AppendVar)( s, inf );
        }
    }

    /* free mem */
    for( i = 0; i < info.i_count; i++ )
    {
        free( info.info[i].psz_name );
        free( info.info[i].psz_value );
    }
    if( info.i_count > 0 )
    {
        free( info.info );
    }

    return s;
}
#endif

mvar_t *E_(mvar_FileSetNew)( intf_thread_t *p_intf, char *name,
                             char *psz_dir )
{
    mvar_t *s = E_(mvar_New)( name, "set" );
#ifdef HAVE_SYS_STAT_H
    struct stat   stat_info;
#endif
    char        **ppsz_dir_content;
    int           i_dir_content, i;
    /* convert all / to native separator */
#if defined( WIN32 )
    const char sep = '\\';
#else
    const char sep = '/';
#endif

    psz_dir = E_(RealPath)( p_intf, psz_dir );

#ifdef HAVE_SYS_STAT_H
    if( (utf8_stat( psz_dir, &stat_info ) == -1 )
     || !S_ISDIR( stat_info.st_mode )
#   if defined( WIN32 )
          && psz_dir[0] != '\0' && (psz_dir[0] != '\\' || psz_dir[1] != '\0')
#   endif
      )
    {
        free( psz_dir );
        return s;
    }
#endif

    /* parse psz_src dir */
    if( ( i_dir_content = utf8_scandir( psz_dir, &ppsz_dir_content, Filter,
                                        InsensitiveAlphasort ) ) == -1 )
    {
        msg_Warn( p_intf, "error while scanning dir %s (%s)", psz_dir,
                  strerror(errno) );
        free( psz_dir );
        return s;
    }

    for( i = 0; i < i_dir_content; i++ )
    {
        char *psz_dir_content = ppsz_dir_content[i];
        char psz_tmp[strlen( psz_dir ) + 1 + strlen( psz_dir_content ) + 1];
        mvar_t *f;
        char *psz_name, *psz_ext, *psz_dummy;

#if defined( WIN32 )
        if( psz_dir[0] == '\0' || (psz_dir[0] == '\\' && psz_dir[1] == '\0') )
        {
            strcpy( psz_tmp, psz_dir_content );
        }
        else
#endif
        {
            sprintf( psz_tmp, "%s%c%s", psz_dir, sep, psz_dir_content );

#ifdef HAVE_SYS_STAT_H
            if( utf8_stat( psz_tmp, &stat_info ) == -1 )
            {
                free( psz_dir_content );
                continue;
            }
#endif
        }
        f = E_(mvar_New)( name, "set" );

        /* FIXME: merge vlc_fix_readdir_charset with utf8_readir */
        psz_dummy = vlc_fix_readdir_charset( p_intf, psz_dir_content );
        psz_name = E_(FromUTF8)( p_intf, psz_dummy );
        free( psz_dummy );

        /* put lower-case file extension in 'ext' */
        psz_ext = strrchr( psz_name, '.' );
        psz_ext = strdup( psz_ext != NULL ? psz_ext + 1 : "" );
        for( psz_dummy = psz_ext; *psz_dummy != '\0'; psz_dummy++ )
            *psz_dummy = tolower( *psz_dummy );

        E_(mvar_AppendNewVar)( f, "ext", psz_ext );
        free( psz_ext );

#if defined( WIN32 )
        if( psz_dir[0] == '\0' || (psz_dir[0] == '\\' && psz_dir[1] == '\0') )
        {
            char psz_tmp[3];
            sprintf( psz_tmp, "%c:", psz_name[0] );
            E_(mvar_AppendNewVar)( f, "name", psz_name );
            E_(mvar_AppendNewVar)( f, "basename", psz_tmp );
            E_(mvar_AppendNewVar)( f, "type", "directory" );
            E_(mvar_AppendNewVar)( f, "size", "unknown" );
            E_(mvar_AppendNewVar)( f, "date", "unknown" );
        }
        else
#endif
        {
            char psz_ctime[26];
            char psz_tmp[strlen( psz_dir ) + 1 + strlen( psz_name ) + 1];

            sprintf( psz_tmp, "%s%c%s", psz_dir, sep, psz_name );
            E_(mvar_AppendNewVar)( f, "name", psz_tmp );
            E_(mvar_AppendNewVar)( f, "basename", psz_name );

#ifdef HAVE_SYS_STAT_H
            if( S_ISDIR( stat_info.st_mode ) )
            {
                E_(mvar_AppendNewVar)( f, "type", "directory" );
            }
            else if( S_ISREG( stat_info.st_mode ) )
            {
                E_(mvar_AppendNewVar)( f, "type", "file" );
            }
            else
            {
                E_(mvar_AppendNewVar)( f, "type", "unknown" );
            }

            sprintf( psz_ctime, I64Fd, (int64_t)stat_info.st_size );
            E_(mvar_AppendNewVar)( f, "size", psz_ctime );

            /* FIXME memory leak FIXME */
#   ifdef HAVE_CTIME_R
            ctime_r( &stat_info.st_mtime, psz_ctime );
            E_(mvar_AppendNewVar)( f, "date", psz_ctime );
#   else
            E_(mvar_AppendNewVar)( f, "date", ctime( &stat_info.st_mtime ) );
#   endif

#else
            E_(mvar_AppendNewVar)( f, "type", "unknown" );
            E_(mvar_AppendNewVar)( f, "size", "unknown" );
            E_(mvar_AppendNewVar)( f, "date", "unknown" );
#endif
        }

        E_(mvar_AppendVar)( s, f );

        free( psz_name );
        free( psz_dir_content );
    }

    free( psz_dir );
    if( ppsz_dir_content != NULL )
        free( ppsz_dir_content );
    return s;
}

void E_(mvar_VlmSetNewLoop)( char *name, vlm_t *vlm, mvar_t *s, vlm_message_t *el, vlc_bool_t b_name );
void E_(mvar_VlmSetNewLoop)( char *name, vlm_t *vlm, mvar_t *s, vlm_message_t *el, vlc_bool_t b_name )
{
    /* Over name */
    mvar_t        *set;
    int k;

    /* Add a node with name and info */
    set = E_(mvar_New)( name, "set" );
    if( b_name == VLC_TRUE )
    {
        E_(mvar_AppendNewVar)( set, "name", el->psz_name );
    }

    for( k = 0; k < el->i_child; k++ )
    {
        vlm_message_t *ch = el->child[k];
        if( ch->i_child > 0 )
        {
            E_(mvar_VlmSetNewLoop)( ch->psz_name, vlm, set, ch, VLC_FALSE );
        }
        else
        {
            if( ch->psz_value )
            {
                E_(mvar_AppendNewVar)( set, ch->psz_name, ch->psz_value );
            }
            else
            {
                E_(mvar_AppendNewVar)( set, el->psz_name, ch->psz_name );
            }
        }
    }

    E_(mvar_AppendVar)( s, set );
}

mvar_t *E_(mvar_VlmSetNew)( char *name, vlm_t *vlm )
{
    mvar_t        *s = E_(mvar_New)( name, "set" );
    vlm_message_t *msg;
    int    i;

    if( vlm == NULL ) return s;

    if( vlm_ExecuteCommand( vlm, "show", &msg ) )
    {
        return s;
    }

    for( i = 0; i < msg->i_child; i++ )
    {
        /* Over media, schedule */
        vlm_message_t *ch = msg->child[i];
        int j;

        for( j = 0; j < ch->i_child; j++ )
        {
            /* Over name */
            vlm_message_t *el = ch->child[j];
            vlm_message_t *inf, *desc;
            char          psz[6 + strlen(el->psz_name)];

            sprintf( psz, "show %s", el->psz_name );
            if( vlm_ExecuteCommand( vlm, psz, &inf ) )
                continue;
            desc = inf->child[0];

            E_(mvar_VlmSetNewLoop)( el->psz_name, vlm, s, desc, VLC_TRUE );

            vlm_MessageDelete( inf );
        }
    }
    vlm_MessageDelete( msg );

    return s;
}