Changeset 470b47fe952dbba82beca44cafefd4b6ec711384

Show
Ignore:
Timestamp:
28/03/06 22:29:28 (3 years ago)
Author:
Clément Stenac <zorglub@videolan.org>
git-committer:
Clément Stenac <zorglub@videolan.org> 1143577768 +0000
git-parent:

[4dfd839aff9cfb0e3cd0e30b92e60af388bb0fc7]

git-author:
Clément Stenac <zorglub@videolan.org> 1143577768 +0000
Message:

String fixes in src (Refs:#438)

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved
  • src/audio_output/input.c

    r9302aca r470b47f  
    167167        if( psz_parser == NULL || !*psz_parser ) 
    168168            continue; 
    169          
     169 
    170170        while( psz_parser && *psz_parser ) 
    171171        { 
     
    174174            if( p_input->i_nb_filters >= AOUT_MAX_FILTERS ) 
    175175            { 
    176                 msg_Dbg( p_aout, "max filter reached (%d)", AOUT_MAX_FILTERS ); 
     176                msg_Dbg( p_aout, "max filters reached (%d)", AOUT_MAX_FILTERS ); 
    177177                break; 
    178178            } 
     
    211211                memcpy( &p_filter->output, &chain_output_format, 
    212212                        sizeof(audio_sample_format_t) ); 
    213                          
     213 
    214214                p_filter->p_module = module_Need( p_filter, "visualization", 
    215215                                                  psz_parser, VLC_TRUE ); 
     
    236236                        aout_FormatPrepare( &p_filter->input ); 
    237237                        aout_FormatPrepare( &p_filter->output ); 
    238                         p_filter->p_module = module_Need( p_filter, "audio filter", 
     238                        p_filter->p_module = module_Need( p_filter, 
     239                                                          "audio filter", 
    239240                                                          psz_parser, VLC_TRUE ); 
    240241                    } 
     
    246247                        memcpy( &p_filter->output, &chain_output_format, 
    247248                                sizeof(audio_sample_format_t) ); 
    248                         p_filter->p_module = module_Need( p_filter, "visualization", 
     249                        p_filter->p_module = module_Need( p_filter, 
     250                                                          "visualization", 
    249251                                                          psz_parser, VLC_TRUE ); 
    250252                    } 
     
    461463        if( p_input->p_input_thread ) 
    462464        { 
    463             stats_UpdateInteger( p_input->p_input_thread, STATS_LOST_ABUFFERS, 1, 
    464                                  NULL ); 
     465            stats_UpdateInteger( p_input->p_input_thread, STATS_LOST_ABUFFERS, 
     466                                 1, NULL ); 
    465467        } 
    466468        aout_BufferFree( p_buffer ); 
     
    503505        if( p_input->p_input_thread ) 
    504506        { 
    505             stats_UpdateInteger( p_input->p_input_thread, STATS_LOST_ABUFFERS, 1, 
    506                                  NULL ); 
     507            stats_UpdateInteger( p_input->p_input_thread, STATS_LOST_ABUFFERS, 
     508                                 1, NULL ); 
    507509        } 
    508510        return 0; 
  • src/audio_output/intf.c

    r2cb472d r470b47f  
    159159    config_PutInt( p_object, "volume", i_volume ); 
    160160    var_Create( p_object->p_libvlc, "saved-volume", VLC_VAR_INTEGER ); 
    161     var_SetInteger( p_object->p_libvlc, "saved-volume" , (audio_volume_t) i_volume ); 
     161    var_SetInteger( p_object->p_libvlc, "saved-volume" , 
     162                    (audio_volume_t) i_volume ); 
    162163    if ( pi_volume != NULL ) *pi_volume = (audio_volume_t) i_volume; 
    163164 
     
    167168    if ( !p_aout->mixer.b_error ) 
    168169    { 
    169         i_result = p_aout->output.pf_volume_set( p_aout, (audio_volume_t) i_volume ); 
     170        i_result = p_aout->output.pf_volume_set( p_aout, 
     171                                                (audio_volume_t) i_volume ); 
    170172    } 
    171173    vlc_mutex_unlock( &p_aout->mixer_lock ); 
  • src/audio_output/mixer.c

    r5bd61a8 r470b47f  
    4747    if ( p_aout->mixer.p_module == NULL ) 
    4848    { 
    49         msg_Err( p_aout, "no suitable aout mixer" ); 
     49        msg_Err( p_aout, "no suitable audio mixer" ); 
    5050        return -1; 
    5151    } 
  • src/audio_output/output.c

    r2cb472d r470b47f  
    5858    if ( p_aout->output.p_module == NULL ) 
    5959    { 
    60         msg_Err( p_aout, "no suitable aout module" ); 
     60        msg_Err( p_aout, "no suitable audio output module" ); 
    6161        vlc_mutex_unlock( &p_aout->output_fifo_lock ); 
    6262        return -1; 
     
    196196                                     &p_aout->output.output ) < 0 ) 
    197197    { 
    198         msg_Err( p_aout, "couldn't set an output pipeline" ); 
     198        msg_Err( p_aout, "couldn't create audio output pipeline" ); 
    199199        module_Unneed( p_aout, p_aout->output.p_module ); 
    200200        return -1; 
  • src/control/mediacontrol_audio_video.c

    rebeebc5 r470b47f  
    9898        p_pic = _mediacontrol_createRGBPicture( p_snapshot->i_width, 
    9999                                                p_snapshot->i_height, 
    100                        VLC_FOURCC( 'p','n','g',' ' ), 
     100                                                VLC_FOURCC( 'p','n','g',' ' ), 
    101101                                                p_snapshot->date, 
    102102                                                p_snapshot->p_data, 
     
    200200        mtime_t i_now = mdate(); 
    201201 
    202         i_duration = 1000 * mediacontrol_unit_convert( self->p_playlist->p_input, 
    203                                                        end->key, 
    204                                                        mediacontrol_MediaTime, 
    205                                                        end->value ); 
     202        i_duration = 1000 * mediacontrol_unit_convert( 
     203                                                self->p_playlist->p_input, 
     204                                                end->key, 
     205                                                mediacontrol_MediaTime, 
     206                                                end->value ); 
    206207 
    207208        mediacontrol_showtext( p_vout, DEFAULT_CHAN, psz_message, NULL, 
     
    226227 
    227228        i_debut = mediacontrol_position2microsecond( p_input, 
    228                                                      ( mediacontrol_Position* ) begin ); 
     229                                            ( mediacontrol_Position* ) begin ); 
    229230        i_debut += i_now; 
    230231 
    231232        i_fin = mediacontrol_position2microsecond( p_input, 
    232                                                    ( mediacontrol_Position * ) end ); 
     233                                          ( mediacontrol_Position * ) end ); 
    233234        i_fin += i_now; 
    234235 
  • src/control/mediacontrol_core.c

    rf1dd5a8 r470b47f  
    124124    { 
    125125        /* Relative or ModuloPosition make no sense */ 
    126         RAISE( mediacontrol_PositionOriginNotSupported, "Only absolute position is valid." ); 
     126        RAISE( mediacontrol_PositionOriginNotSupported, 
     127                                        "Only absolute position is valid." ); 
    127128        return NULL; 
    128129    } 
     
    365366    vlc_value_t val; 
    366367 
    367     retval = ( mediacontrol_StreamInformation* )malloc( sizeof( mediacontrol_StreamInformation ) ); 
     368    retval = ( mediacontrol_StreamInformation* ) 
     369                            malloc( sizeof( mediacontrol_StreamInformation ) ); 
    368370    if( ! retval ) 
    369371    { 
     
    411413 
    412414        retval->position = mediacontrol_unit_convert( p_input, 
    413                                                       mediacontrol_MediaTime, a_key, 
    414                                                       retval->position ); 
     415                                         mediacontrol_MediaTime, a_key, 
     416                                         retval->position ); 
    415417        retval->length   = mediacontrol_unit_convert( p_input, 
    416                                                       mediacontrol_MediaTime, a_key, 
    417                                                       retval->length ); 
     418                                         mediacontrol_MediaTime, a_key, 
     419                                         retval->length ); 
    418420    } 
    419421    return retval; 
  • src/control/mediacontrol_util.c

    r4fdac05 r470b47f  
    9797        double f_fps; 
    9898 
    99     if( demux2_Control( p_input->input.p_demux, DEMUX_GET_FPS, &f_fps ) || f_fps < 0.1 ) 
     99        if( demux2_Control( p_input->input.p_demux, DEMUX_GET_FPS, &f_fps ) || 
     100                                f_fps < 0.1 ) 
    100101            return 0; 
    101102 
  • src/extras/libc.c

    rbe639de2 r470b47f  
    897897        tv.tv_sec = 0; 
    898898        tv.tv_usec = 10000; 
    899          
     899 
    900900        i_ret = select( pi_stdin[0] > pi_stdout[0] ? pi_stdin[0] + 1 : 
    901901                        pi_stdout[0] + 1, &readfds, &writefds, NULL, &tv ); 
     
    959959 
    960960#elif defined( WIN32 ) && !defined( UNDER_CE ) 
    961     SECURITY_ATTRIBUTES saAttr;  
    962     PROCESS_INFORMATION piProcInfo;  
     961    SECURITY_ATTRIBUTES saAttr; 
     962    PROCESS_INFORMATION piProcInfo; 
    963963    STARTUPINFO siStartInfo; 
    964     BOOL bFuncRetn = FALSE;  
     964    BOOL bFuncRetn = FALSE; 
    965965    HANDLE hChildStdinRd, hChildStdinWr, hChildStdoutRd, hChildStdoutWr; 
    966966    DWORD i_status; 
     
    970970 
    971971    /* Set the bInheritHandle flag so pipe handles are inherited. */ 
    972     saAttr.nLength = sizeof(SECURITY_ATTRIBUTES);  
    973     saAttr.bInheritHandle = TRUE;  
    974     saAttr.lpSecurityDescriptor = NULL;  
     972    saAttr.nLength = sizeof(SECURITY_ATTRIBUTES); 
     973    saAttr.bInheritHandle = TRUE; 
     974    saAttr.lpSecurityDescriptor = NULL; 
    975975 
    976976    /* Create a pipe for the child process's STDOUT. */ 
    977     if ( !CreatePipe( &hChildStdoutRd, &hChildStdoutWr, &saAttr, 0 ) )  
    978     { 
    979         msg_Err( p_object, "stdout pipe creation failed" );  
     977    if ( !CreatePipe( &hChildStdoutRd, &hChildStdoutWr, &saAttr, 0 ) ) 
     978    { 
     979        msg_Err( p_object, "stdout pipe creation failed" ); 
    980980        return -1; 
    981981    } 
     
    985985 
    986986    /* Create a pipe for the child process's STDIN. */ 
    987     if ( !CreatePipe( &hChildStdinRd, &hChildStdinWr, &saAttr, 0 ) )  
    988     { 
    989         msg_Err( p_object, "stdin pipe creation failed" );  
     987    if ( !CreatePipe( &hChildStdinRd, &hChildStdinWr, &saAttr, 0 ) ) 
     988    { 
     989        msg_Err( p_object, "stdin pipe creation failed" ); 
    990990        return -1; 
    991991    } 
     
    996996    /* Set up members of the PROCESS_INFORMATION structure. */ 
    997997    ZeroMemory( &piProcInfo, sizeof(PROCESS_INFORMATION) ); 
    998   
     998 
    999999    /* Set up members of the STARTUPINFO structure. */ 
    10001000    ZeroMemory( &siStartInfo, sizeof(STARTUPINFO) ); 
    1001     siStartInfo.cb = sizeof(STARTUPINFO);  
     1001    siStartInfo.cb = sizeof(STARTUPINFO); 
    10021002    siStartInfo.hStdError = hChildStdoutWr; 
    10031003    siStartInfo.hStdOutput = hChildStdoutWr; 
     
    10461046    } 
    10471047    *p = '\0'; 
    1048   
     1048 
    10491049    /* Create the child process. */ 
    10501050    bFuncRetn = CreateProcess( NULL, 
    1051           psz_cmd,       // command line  
    1052           NULL,          // process security attributes  
    1053           NULL,          // primary thread security attributes  
    1054           TRUE,          // handles are inherited  
    1055           0,             // creation flags  
     1051          psz_cmd,       // command line 
     1052          NULL,          // process security attributes 
     1053          NULL,          // primary thread security attributes 
     1054          TRUE,          // handles are inherited 
     1055          0,             // creation flags 
    10561056          p_env, 
    10571057          psz_cwd, 
    1058           &siStartInfo,  // STARTUPINFO pointer  
    1059           &piProcInfo ); // receives PROCESS_INFORMATION  
     1058          &siStartInfo,  // STARTUPINFO pointer 
     1059          &piProcInfo ); // receives PROCESS_INFORMATION 
    10601060 
    10611061    free( psz_cmd ); 
    10621062    free( p_env ); 
    1063     
    1064     if ( bFuncRetn == 0 )  
    1065     { 
    1066         msg_Err( p_object, "child creation failed" );  
     1063 
     1064    if ( bFuncRetn == 0 ) 
     1065    { 
     1066        msg_Err( p_object, "child creation failed" ); 
    10671067        return -1; 
    10681068    } 
     
    10841084     * read end of the pipe. */ 
    10851085    CloseHandle(hChildStdoutWr); 
    1086   
     1086 
    10871087    /* Read output from the child process. */ 
    10881088    *pi_data = 0; 
     
    10921092    { 
    10931093        DWORD i_read; 
    1094         if ( !ReadFile( hChildStdoutRd, &(*pp_data)[*pi_data], 1024, &i_read,  
     1094        if ( !ReadFile( hChildStdoutRd, &(*pp_data)[*pi_data], 1024, &i_read, 
    10951095                        NULL ) 
    10961096              || i_read == 0 ) 
    1097             break;  
     1097            break; 
    10981098        *pi_data += i_read; 
    10991099        *pp_data = realloc( *pp_data, *pi_data + 1025 ); 
  • src/input/control.c

    r2cb472d r470b47f  
    534534    if( p_playlist ) 
    535535    { 
    536         var_SetInteger( p_playlist, "item-change", p_input->input.p_item->i_id ); 
     536        var_SetInteger( p_playlist, "item-change", 
     537                        p_input->input.p_item->i_id ); 
    537538        vlc_object_release( p_playlist ); 
    538539    } 
  • src/input/decoder.c

    r0b44cb9 r470b47f  
    944944        { 
    945945            p_dec->fmt_out.video.i_visible_height = 1080; 
    946             p_dec->fmt_out.video.i_sar_num *= 135;  
    947             p_dec->fmt_out.video.i_sar_den *= 136;  
     946            p_dec->fmt_out.video.i_sar_num *= 135; 
     947            p_dec->fmt_out.video.i_sar_den *= 136; 
    948948            msg_Warn( p_dec, "Fixing broken HDTV stream (display_height=1088)"); 
    949949        } 
     
    952952            !p_dec->fmt_out.video.i_sar_den ) 
    953953        { 
    954             p_dec->fmt_out.video.i_sar_num = p_dec->fmt_out.video.i_aspect *  
     954            p_dec->fmt_out.video.i_sar_num = p_dec->fmt_out.video.i_aspect * 
    955955              p_dec->fmt_out.video.i_visible_height; 
    956956 
  • src/input/demux.c

    r2cb472d r470b47f  
    7676    if( s && *psz_module == '\0' && strrchr( p_demux->psz_path, '.' ) ) 
    7777    { 
    78         /* XXX: add only file without any problem here and with strong detection. 
    79          *  - no .mp3, .a52, ... (aac is added as it works only by file ext anyway 
    80          *  - wav can't be added 'cause of a52 and dts in them as raw audio 
     78       /* XXX: add only file without any problem here and with strong detection. 
     79        *  - no .mp3, .a52, ... (aac is added as it works only by file ext 
     80        *     anyway 
     81        *  - wav can't be added 'cause of a52 and dts in them as raw audio 
    8182         */ 
    8283         static struct { char *ext; char *demux; } exttodemux[] = 
     
    100101        }; 
    101102        /* Here, we don't mind if it does not work, it must be quick */ 
    102         static struct { char *ext; char *demux; } exttodemux_quick[] =  
     103        static struct { char *ext; char *demux; } exttodemux_quick[] = 
    103104        { 
    104105            { "mp3", "mpga" }, 
  • src/input/es_out.c

    rcf716aa r470b47f  
    180180    { 
    181181        for( i = 0; p_sys->ppsz_audio_language[i]; i++ ) 
    182             msg_Dbg( p_input, "select audio in language[%d] %s", 
     182            msg_Dbg( p_input, "selected audio language[%d] %s", 
    183183                     i, p_sys->ppsz_audio_language[i] ); 
    184184    } 
     
    190190    { 
    191191        for( i = 0; p_sys->ppsz_sub_language[i]; i++ ) 
    192             msg_Dbg( p_input, "select subtitle in language[%d] %s", 
     192            msg_Dbg( p_input, "selected subtitle language[%d] %s", 
    193193                     i, p_sys->ppsz_sub_language[i] ); 
    194194    } 
     
    288288        es_out_id_t *es = p_sys->es[i]; 
    289289        es->b_discontinuity = VLC_TRUE; /* signal discontinuity */ 
    290          
     290 
    291291        /* Send a dummy block to let decoder know that 
    292292         * there is a discontinuity */ 
     
    369369        if( es->psz_language && *es->psz_language ) 
    370370        { 
    371             text.psz_string = malloc( strlen( es->fmt.psz_description) + strlen( es->psz_language ) + 10 ); 
    372             sprintf( text.psz_string, "%s - [%s]", es->fmt.psz_description, es->psz_language ); 
     371            text.psz_string = malloc( strlen( es->fmt.psz_description) + 
     372                                      strlen( es->psz_language ) + 10 ); 
     373            sprintf( text.psz_string, "%s - [%s]", es->fmt.psz_description, 
     374                                                   es->psz_language ); 
    373375        } 
    374376        else text.psz_string = strdup( es->fmt.psz_description ); 
     
    379381        { 
    380382            char *temp; 
    381             text.psz_string = malloc( strlen( _("Track %i") )+ strlen( es->psz_language ) + 30 ); 
     383            text.psz_string = malloc( strlen( _("Track %i") )+ 
     384                                      strlen( es->psz_language ) + 30 ); 
    382385            asprintf( &temp,  _("Track %i"), val.i_int ); 
    383386            sprintf( text.psz_string, "%s - [%s]", temp, es->psz_language ); 
     
    781784                     es->i_id ); 
    782785            return; 
    783    
     786       
    784787    } 
    785788 
  • src/input/input.c

    r6b99a43 r470b47f  
    208208                     else if( !strncmp( psz_start, "time=", 5 ) ) 
    209209                     { 
    210                          p_seekpoint->i_time_offset = atoll(psz_start + 5) * 1000000; 
     210                         p_seekpoint->i_time_offset = atoll(psz_start + 5) * 
     211                                                        1000000; 
    211212                     } 
    212213                     psz_start = psz_end + 1; 
     
    15771578                    input_EsOutDiscontinuity( p_input->p_es_out, VLC_FALSE ); 
    15781579                    es_out_Control( p_input->p_es_out, ES_OUT_RESET_PCR ); 
    1579                      
     1580 
    15801581                    access2_Control( p_access, ACCESS_SET_TITLE, i_title ); 
    15811582                    stream_AccessReset( p_input->input.p_stream ); 
     
    16181619                    input_EsOutDiscontinuity( p_input->p_es_out, VLC_FALSE ); 
    16191620                    es_out_Control( p_input->p_es_out, ES_OUT_RESET_PCR ); 
    1620                      
     1621 
    16211622                    demux2_Control( p_demux, DEMUX_SET_SEEKPOINT, i_seekpoint ); 
    16221623                } 
     
    16541655                    input_EsOutDiscontinuity( p_input->p_es_out, VLC_FALSE ); 
    16551656                    es_out_Control( p_input->p_es_out, ES_OUT_RESET_PCR ); 
    1656                      
    1657                     access2_Control( p_access, ACCESS_SET_SEEKPOINT, i_seekpoint ); 
     1657 
     1658                    access2_Control( p_access, ACCESS_SET_SEEKPOINT, 
     1659                                    i_seekpoint ); 
    16581660                    stream_AccessReset( p_input->input.p_stream ); 
    16591661                } 
     
    19721974{ 
    19731975    input_source_t *in = (input_source_t*) malloc( sizeof( input_source_t ) ); 
    1974     
     1976 
    19751977    if( !in ) 
    19761978    { 
     
    20442046                psz_demux = psz_var_demux; 
    20452047 
    2046                 msg_Dbg( p_input, "Enforce demux ` %s'", psz_demux ); 
     2048                msg_Dbg( p_input, "enforced demux ` %s'", psz_demux ); 
    20472049            } 
    20482050            else if( psz_var_demux ) 
     
    22822284    int64_t i_time; 
    22832285    int i; 
    2284      
     2286  
    22852287    if( demux2_Control( p_input->input.p_demux, DEMUX_GET_TIME, &i_time ) ) 
    22862288    { 
  • src/input/subtitles.c

    rdc229fd r470b47f  
    3737#endif 
    3838 
    39 #ifdef HAVE_LIMITS_H   
    40 #   include <limits.h>   
     39#ifdef HAVE_LIMITS_H 
     40#   include <limits.h> 
    4141#endif 
    4242 
     
    6565 * The possible extentions for subtitle files we support 
    6666 */ 
    67 static const char * sub_exts[] = {  "utf", "utf8", "utf-8", "sub", "srt", "smi", "txt", "ssa", "idx", NULL}; 
     67static const char * sub_exts[] = {  "utf", "utf8", "utf-8", "sub", "srt", "smi", "txt", "ssa", "idx", NULL }; 
    6868/* extensions from unsupported types */ 
    6969/* rt, aqt, jss, js, ass */ 
     
    162162} 
    163163 
    164 /* Utility function for scandir */   
     164/* Utility function for scandir */ 
    165165static int Filter( const char *psz_dir_content ) 
    166166{ 
     
    230230                if( psz_temp ) 
    231231                { 
    232                     sprintf( psz_temp, "%s%s%c",  
     232                    sprintf( psz_temp, "%s%s%c", 
    233233                             psz_subdir[0] == '.' ? psz_dir : "", 
    234234                             psz_subdir, 
     
    344344    subdirs = tmp_subdirs; 
    345345 
    346     for( j = -1; (j == -1) || ( (j >= 0) && (subdirs != NULL) && (*subdirs != NULL) ); 
    347         j++) 
     346    for( j = -1; (j == -1) || ( (j >= 0) && (subdirs != NULL) && 
     347        (*subdirs != NULL) ); j++) 
    348348    { 
    349349        const char *psz_dir = j < 0 ? f_dir : *subdirs; 
     
    365365            for( a = 0; a < i_dir_content; a++ ) 
    366366            { 
    367                 char *psz_name = vlc_fix_readdir_charset( p_this, ppsz_dir_content[a] ); 
     367                char *psz_name = vlc_fix_readdir_charset( p_this, 
     368                                                          ppsz_dir_content[a] ); 
    368369                int i_prio = 0; 
    369370 
     
    409410 
    410411                    sprintf( psz_path, "%s%s", psz_dir, psz_name ); 
    411                     msg_Dbg( p_this, "autodetected subtitle: %s with priority %d", psz_path, i_prio ); 
     412                    msg_Dbg( p_this, 
     413                                "autodetected subtitle: %s with priority %d", 
     414                                psz_path, i_prio ); 
    412415                    /* FIXME: a portable wrapper for stat() or access() would be more suited */ 
    413416                    if( ( f = utf8_fopen( psz_path, "rt" ) ) ) 
    414417                    { 
    415418                        fclose( f ); 
    416                         msg_Dbg( p_this, "autodetected subtitle: %s with priority %d", psz_path, i_prio ); 
     419                        msg_Dbg( p_this, 
     420                                "autodetected subtitle: %s with priority %d", 
     421                                psz_path, i_prio ); 
    417422                        result[i_sub_count].priority = i_prio; 
    418423                        result[i_sub_count].psz_fname = psz_path; 
     
    457462            { 
    458463                if( result[i].psz_fname && result[j].psz_fname && 
    459                     !strncasecmp( result[j].psz_fname, result[i].psz_fname, sizeof( result[j].psz_fname) - 4 ) &&  
     464                    !strncasecmp( result[j].psz_fname, result[i].psz_fname, 
     465                                sizeof( result[j].psz_fname) - 4 ) && 
    460466                    !strcasecmp( result[i].psz_ext, "idx" ) ) 
    461467                    break; 
  • src/interface/interaction.c

    r68f500c r470b47f  
    514514    interaction_t *p_interaction; 
    515515 
    516     msg_Dbg( p_playlist, "initializing interaction system" ); 
    517  
    518516    p_interaction = vlc_object_create( VLC_OBJECT( p_playlist ), 
    519517                                       sizeof( interaction_t ) ); 
     
    545543    if( !p_list ) 
    546544    { 
    547         msg_Err( p_interaction, "Unable to create module list" ); 
     545        msg_Err( p_interaction, "unable to create module list" ); 
    548546        return; 
    549547    } 
  • src/interface/interface.c

    rc4fef7e r470b47f  
    120120    if( p_intf->p_module == NULL ) 
    121121    { 
    122         msg_Err( p_intf, "no suitable intf module" ); 
     122        msg_Err( p_intf, "no suitable interface module" ); 
    123123        vlc_object_destroy( p_intf ); 
    124124        return NULL; 
     
    161161        /* This is the primary intf */ 
    162162        /* Run a manager thread, launch the interface, kill the manager */ 
    163         if( vlc_thread_create( p_intf, "manager", Manager, 
     163        if( vlc_thread_create( p_intf, "manage", Manager, 
    164164                               VLC_THREAD_PRIORITY_LOW, VLC_FALSE ) ) 
    165165        { 
     
    190190        if( !strcmp( p_intf->p_module->psz_object_name, "macosx" ) ) 
    191191        { 
    192             msg_Err( p_intf, "You cannot run the MacOS X module as an extrainterface. Please read the README.MacOSX.rtf file"); 
     192            msg_Err( p_intf, "You cannot run the MacOS X module as an " 
     193                             "extra interface. Please read the " 
     194                             "README.MacOSX.rtf file"); 
    193195            return VLC_EGENERIC; 
    194196        } 
  • src/misc/objects.c

    r70e482e r470b47f  
    123123        case VLC_OBJECT_DIALOGS: 
    124124            i_size = sizeof(intf_thread_t); 
    125             psz_type = "dialogs provider"; 
     125            psz_type = "dialogs"; 
    126126            break; 
    127127        case VLC_OBJECT_PLAYLIST: 
     
    171171        case VLC_OBJECT_SPU: 
    172172            i_size = sizeof(spu_t); 
    173             psz_type = "subpicture unit"; 
     173            psz_type = "subpicture"; 
    174174            break; 
    175175        case VLC_OBJECT_AOUT: 
     
    207207        case VLC_OBJECT_OPENGL: 
    208208            i_size = sizeof( vout_thread_t ); 
    209             psz_type = "opengl provider"; 
     209            psz_type = "opengl"; 
    210210            break; 
    211211        case VLC_OBJECT_ANNOUNCE: 
    212212            i_size = sizeof( announce_handler_t ); 
    213             psz_type = "announce handler"; 
     213            psz_type = "announce"; 
    214214            break; 
    215215        case VLC_OBJECT_OSDMENU: 
  • src/misc/stats.c

    r0b44cb9 r470b47f  
    506506            p_counter->i_compute_type != STATS_LAST ) 
    507507        { 
    508             msg_Err( p_handler, "Unable to compute MIN or MAX for this type"); 
     508            msg_Err( p_handler, "unable to compute MIN or MAX for this type"); 
    509509            return VLC_EGENERIC; 
    510510        } 
  • src/misc/vlm.c

    ra1ff886 r470b47f  
    8383    if( !(p_vlm = vlc_object_find( p_this, VLC_OBJECT_VLM, FIND_ANYWHERE )) ) 
    8484    { 
    85         msg_Info( p_this, "creating vlm" ); 
     85        msg_Info( p_this, "creating VLM" ); 
    8686        if( ( p_vlm = vlc_object_create( p_this, VLC_OBJECT_VLM ) ) == NULL ) 
    8787        { 
     
    118118        char *psz_buffer = NULL; 
    119119 
    120         msg_Dbg( p_this, "loading vlm conf ..." ); 
     120        msg_Dbg( p_this, "loading VLM configuration" ); 
    121121        asprintf(&psz_buffer, "load %s", psz_vlmconf ); 
    122122        if( psz_buffer ) 
     
    124124            msg_Dbg( p_this, psz_buffer); 
    125125            if( vlm_ExecuteCommand( p_vlm, psz_buffer, &p_message ) ){ 
    126                 msg_Warn( p_this, "error while loading the vlm conf file" ); 
     126                msg_Warn( p_this, "error while loading the configuration file" ); 
    127127            } 
    128128            vlm_MessageDelete(p_message); 
  • src/network/acl.c

    r1c35288 r470b47f  
    9898 
    9999        default: 
    100             msg_Err( p_this, "IMPOSSIBLE: unknown address family!" ); 
     100            msg_Err( p_this, "unknown address family" ); 
    101101            vlc_freeaddrinfo( res ); 
    102102            return -1; 
     
    284284            if( ferror( file ) ) 
    285285            { 
    286                 msg_Err( p_acl->p_owner, "Error reading %s : %s\n", psz_path, 
     286                msg_Err( p_acl->p_owner, "error reading %s : %s\n", psz_path, 
    287287                        strerror( errno ) ); 
    288288                goto error; 
     
    304304        if( ptr == NULL ) 
    305305        { 
    306             msg_Warn( p_acl->p_owner, "Skipping overly long line in %s\n", 
     306            msg_Warn( p_acl->p_owner, "skipping overly long line in %s\n", 
    307307                      psz_path); 
    308308            do 
     
    311311                if( ferror( file ) || feof( file ) ) 
    312312                { 
    313                     msg_Err( p_acl->p_owner, "Error reading %s : %s\n", 
     313                    msg_Err( p_acl->p_owner, "error reading %s : %s\n", 
    314314                             psz_path, strerror( errno ) ); 
    315315                    goto error;