modules/access/jack.c

   1 /*****************************************************************************
   2  * jack.c: JACK audio input module
   3  *****************************************************************************
   4  * Copyright (C) 2007-2008 the VideoLAN team
   5  * Copyright (C) 2007 Société des arts technologiques
   6  * Copyright (C) 2007 Savoir-faire Linux
   7  *
   8  * Authors: Arnaud Sala <arnaud.sala at savoirfairelinux.com>
   9  *          Julien Plissonneau Duquene <... at savoirfairelinux.com>
  10  *          Pierre-Luc Beaudoin <pierre-luc.beaudoin at savoirfairelinux.com>
  11  *
  12  * This program is free software; you can redistribute it and/or modify
  13  * it under the terms of the GNU General Public License as published by
  14  * the Free Software Foundation; either version 2 of the License, or
  15  * (at your option) any later version.
  16  *
  17  * This program is distributed in the hope that it will be useful,
  18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20  * GNU General Public License for more details.
  21  *
  22  * You should have received a copy of the GNU General Public License
  23  * along with this program; if not, write to the Free Software
  24  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  25  *****************************************************************************/
  26
  27 /**
  28  * \file modules/access/jack.c
  29  * \brief JACK audio input functions
  30  */
  31
  32 /*****************************************************************************
  33  * Preamble
  34  *****************************************************************************/
  35
  36 #ifdef HAVE_CONFIG_H
  37 # include "config.h"
  38 #endif
  39
  40 #include <vlc_common.h>
  41 #include <vlc_plugin.h>
  42 #include <vlc_input.h>
  43 #include <vlc_demux.h>
  44 #include <vlc_codecs.h>
  45 #include <vlc_url.h>
  46 #include <vlc_strings.h>
  47
  48 #include <jack/jack.h>
  49 #include <jack/ringbuffer.h>
  50
  51 #include <sys/types.h>
  52 #include <unistd.h>
  53
  54 /*****************************************************************************
  55  * Module descriptor
  56  *****************************************************************************/
  57 static int  Open ( vlc_object_t * );
  58 static void Close( vlc_object_t * );
  59
  60 #define CACHING_TEXT N_("Caching value in ms")
  61 #define CACHING_LONGTEXT N_( \
  62     "Make VLC buffer audio data captured from jack for the specified " \
  63     "length in milliseconds." )
  64 #define PACE_TEXT N_( "Pace" )
  65 #define PACE_LONGTEXT N_( \
  66     "Read the audio stream at VLC pace rather than Jack pace." )
  67 #define AUTO_CONNECT_TEXT N_( "Auto Connection" )
  68 #define AUTO_CONNECT_LONGTEXT N_( \
  69     "Automatically connect VLC input ports to available output ports." )
  70
  71 vlc_module_begin ()
  72      set_description( N_("JACK audio input") )
  73      set_capability( "access_demux", 0 )
  74      set_shortname( N_( "JACK Input" ) )
  75      set_category( CAT_INPUT )
  76      set_subcategory( SUBCAT_INPUT_ACCESS )
  77
  78      add_integer( "jack-input-caching", DEFAULT_PTS_DELAY / 1000, NULL,
  79          CACHING_TEXT, CACHING_LONGTEXT, true )
  80      add_bool( "jack-input-use-vlc-pace", false, NULL,
  81          PACE_TEXT, PACE_LONGTEXT, true )
  82      add_bool( "jack-input-auto-connect", false, NULL,
  83          AUTO_CONNECT_TEXT, AUTO_CONNECT_LONGTEXT, true )
  84
  85      add_shortcut( "jack" )
  86      set_callbacks( Open, Close )
  87 vlc_module_end ()
  88
  89 /*****************************************************************************
  90  * Local prototypes
  91  *****************************************************************************/
  92
  93 struct demux_sys_t
  94 {
  95     /* Audio properties */
  96     vlc_fourcc_t                i_acodec_raw;
  97     unsigned int                i_channels;
  98     int                         i_sample_rate;
  99     int                         i_audio_max_frame_size;
 100     int                         i_frequency;
 101     block_t                     *p_block_audio;
 102     es_out_id_t                 *p_es_audio;
 103     date_t                      pts;
 104
 105     /* Jack properties */
 106     jack_client_t               *p_jack_client;
 107     jack_port_t                 **pp_jack_port_input;
 108     jack_default_audio_sample_t **pp_jack_buffer;
 109     jack_ringbuffer_t           *p_jack_ringbuffer;
 110     jack_nframes_t              jack_buffer_size;
 111     jack_nframes_t              jack_sample_rate;
 112     size_t                      jack_sample_size;
 113     char                        *psz_ports;
 114     char                        **pp_jack_port_table;
 115     char                        i_match_ports;
 116 };
 117
 118 static int Demux( demux_t * );
 119 static int Control( demux_t *p_demux, int i_query, va_list args );
 120
 121 static void Parse ( demux_t * );
 122 static void Port_finder( demux_t * );
 123 static int Process( jack_nframes_t i_frames, void *p_arg );
 124
 125 static block_t *GrabJack( demux_t * );
 126
 127 /*****************************************************************************
 128  * Open: Connect to the JACK server
 129  *****************************************************************************/
 130 static int Open( vlc_object_t *p_this )
 131 {
 132     unsigned int i;
 133     demux_t             *p_demux = ( demux_t* )p_this;
 134     demux_sys_t         *p_sys;
 135     es_format_t         fmt;
 136     int i_out_ports = 0;
 137
 138     p_demux->pf_demux = Demux;
 139     p_demux->pf_control = Control;
 140
 141     /* Allocate structure */
 142     p_demux->p_sys = p_sys = calloc( 1, sizeof( demux_sys_t ) );
 143     if( !p_sys )
 144         return VLC_ENOMEM;
 145
 146     /* Parse MRL */
 147     Parse( p_demux );
 148
 149     /* Create var */
 150     var_Create( p_demux, "jack-input-caching",
 151         VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );
 152     var_Create( p_demux, "jack-input-use-vlc-pace",
 153         VLC_VAR_BOOL | VLC_VAR_DOINHERIT );
 154     var_Create( p_demux, "jack-input-auto-connect",
 155         VLC_VAR_BOOL | VLC_VAR_DOINHERIT );
 156
 157     /* JACK connexions */
 158     /* define name and connect to jack server */
 159     char p_vlc_client_name[32];
 160     sprintf( p_vlc_client_name, "vlc-input-%d", getpid() );
 161     p_sys->p_jack_client = jack_client_new( p_vlc_client_name );
 162     if( p_sys->p_jack_client == NULL )
 163     {
 164         msg_Err( p_demux, "failed to connect to JACK server" );
 165         free( p_sys );
 166         return VLC_EGENERIC;
 167     }
 168
 169     /* find some specifics ports if user entered a regexp */
 170     if( p_sys->psz_ports )
 171     {
 172         Port_finder( p_demux );
 173         if( p_sys->i_channels == 0 )
 174         {
 175             p_sys->i_channels = p_sys->i_match_ports;
 176         }
 177     }
 178
 179     /* allocate input ports */
 180     if( p_sys->i_channels == 0 ) p_sys->i_channels = 2 ; /* default number of port */
 181     p_sys->pp_jack_port_input = malloc(
 182         p_sys->i_channels * sizeof( jack_port_t* ) );
 183     if( p_sys->pp_jack_port_input == NULL )
 184     {
 185         jack_client_close( p_sys->p_jack_client );
 186         free( p_sys );
 187         return VLC_ENOMEM;
 188     }
 189
 190     /* allocate ringbuffer */
 191     /* The length of the ringbuffer is critical, it must be large enought
 192        to keep all data between 2 GrabJack() calls.  We assume 1 sec is ok */
 193     p_sys->p_jack_ringbuffer = jack_ringbuffer_create( p_sys->i_channels
 194          * jack_get_sample_rate( p_sys->p_jack_client )
 195          * sizeof( jack_default_audio_sample_t ) );
 196     if( p_sys->p_jack_ringbuffer == NULL )
 197     {
 198         free( p_sys->pp_jack_port_input );
 199         jack_client_close( p_sys->p_jack_client );
 200         free( p_sys );
 201         return VLC_ENOMEM;
 202     }
 203
 204     /* register input ports */
 205     for( i = 0; i <  p_sys->i_channels; i++ )
 206     {
 207         char p_input_name[32];
 208         snprintf( p_input_name, 32, "vlc_in_%d", i+1 );
 209         p_sys->pp_jack_port_input[i] = jack_port_register(
 210             p_sys->p_jack_client, p_input_name, JACK_DEFAULT_AUDIO_TYPE,
 211             JackPortIsInput, 0 );
 212         if( p_sys->pp_jack_port_input[i] == NULL )
 213         {
 214             msg_Err( p_demux, "failed to register a JACK port" );
 215             jack_ringbuffer_free( p_sys->p_jack_ringbuffer );
 216             free( p_sys->pp_jack_port_input );
 217             jack_client_close( p_sys->p_jack_client );
 218             free( p_sys );
 219             return VLC_EGENERIC;
 220         }
 221     }
 222
 223     /* allocate buffer for input ports */
 224     p_sys->pp_jack_buffer = malloc ( p_sys->i_channels
 225         * sizeof( jack_default_audio_sample_t * ) );
 226     if( p_sys->pp_jack_buffer == NULL )
 227     {
 228         for( i = 0; i < p_sys->i_channels; i++ )
 229             jack_port_unregister( p_sys->p_jack_client, p_sys->pp_jack_port_input[i] );
 230         jack_ringbuffer_free( p_sys->p_jack_ringbuffer );
 231         free( p_sys->pp_jack_port_input );
 232         jack_client_close( p_sys->p_jack_client );
 233         free( p_sys );
 234         return VLC_ENOMEM;
 235     }
 236
 237     /* set process callback */
 238     jack_set_process_callback( p_sys->p_jack_client, Process, p_demux );
 239
 240     /* tell jack server we are ready */
 241     if ( jack_activate( p_sys->p_jack_client ) )
 242     {
 243         msg_Err( p_demux, "failed to activate JACK client" );
 244         free( p_sys->pp_jack_buffer );
 245         for( i = 0; i < p_sys->i_channels; i++ )
 246             jack_port_unregister( p_sys->p_jack_client, p_sys->pp_jack_port_input[i] );
 247         jack_ringbuffer_free( p_sys->p_jack_ringbuffer );
 248         free( p_sys->pp_jack_port_input );
 249         jack_client_close( p_sys->p_jack_client );
 250         free( p_sys );
 251         return VLC_EGENERIC;
 252     }
 253
 254     /* connect vlc input to specifics jack output ports if requested */
 255    /*  if( var_GetBool( p_demux, "jack-input-auto-connect" ) && p_sys->psz_ports ) */
 256     if( p_sys->psz_ports )
 257     {
 258         int        i_input_ports;
 259         int        j;
 260
 261     if( p_sys->i_match_ports > 0 )
 262         {
 263             for( j = 0; j < p_sys->i_match_ports; j++ )
 264             {
 265                 i_input_ports = j % p_sys->i_channels;
 266                 jack_connect( p_sys->p_jack_client, p_sys->pp_jack_port_table[j],
 267                     jack_port_name( p_sys->pp_jack_port_input[i_input_ports] ) );
 268             }
 269         }
 270     }
 271
 272     /* connect vlc input to all jack output ports if requested */
 273     if( var_GetBool( p_demux, "jack-input-auto-connect" ) && !p_sys->psz_ports )
 274     {
 275         int        i_input_ports;
 276         int        j;
 277         const char **pp_jack_port_output;
 278
 279         pp_jack_port_output = jack_get_ports( p_sys->p_jack_client, NULL, NULL, JackPortIsOutput );
 280
 281         while( pp_jack_port_output && pp_jack_port_output[i_out_ports] )
 282         {
 283             i_out_ports++;
 284         }
 285         if( i_out_ports > 0 )
 286         {
 287             for( j = 0; j < i_out_ports; j++ )
 288             {
 289                 i_input_ports = j % p_sys->i_channels;
 290                 jack_connect( p_sys->p_jack_client, pp_jack_port_output[j],
 291                     jack_port_name( p_sys->pp_jack_port_input[i_input_ports] ) );
 292             }
 293         }
 294         free( pp_jack_port_output );
 295     }
 296
 297     /* info about jack server */
 298     /* get buffers size */
 299     p_sys->jack_buffer_size = jack_get_buffer_size( p_sys->p_jack_client );
 300     /* get sample rate */
 301     p_sys->jack_sample_rate = jack_get_sample_rate( p_sys->p_jack_client );
 302     /* get sample size */
 303     p_sys->jack_sample_size = sizeof( jack_default_audio_sample_t );
 304
 305     /* Define output format */
 306     es_format_Init( &fmt, AUDIO_ES, VLC_CODEC_FL32 );
 307     fmt.audio.i_channels =  p_sys->i_channels;
 308     fmt.audio.i_rate =  p_sys->jack_sample_rate;
 309     fmt.audio.i_bitspersample =  p_sys->jack_sample_size * 8;
 310     fmt.audio.i_blockalign = fmt.audio.i_bitspersample / 8;
 311     fmt.i_bitrate = fmt.audio.i_rate * fmt.audio.i_bitspersample
 312         * fmt.audio.i_channels;
 313
 314     p_sys->p_es_audio = es_out_Add( p_demux->out, &fmt );
 315     date_Init( &p_sys->pts, fmt.audio.i_rate, 1 );
 316     date_Set( &p_sys->pts, 1 );
 317
 318     return VLC_SUCCESS;
 319 }
 320
 321
 322 /*****************************************************************************
 323  * Close: Disconnect from jack server and release associated resources
 324  *****************************************************************************/
 325 static void Close( vlc_object_t *p_this )
 326 {
 327     demux_t    *p_demux = ( demux_t* )p_this;
 328     demux_sys_t    *p_sys = p_demux->p_sys;
 329
 330     msg_Dbg( p_demux,"Module unloaded" );
 331     if( p_sys->p_block_audio ) block_Release( p_sys->p_block_audio );
 332     if( p_sys->p_jack_client ) jack_client_close( p_sys->p_jack_client );
 333     if( p_sys->p_jack_ringbuffer ) jack_ringbuffer_free( p_sys->p_jack_ringbuffer );
 334     free( p_sys->pp_jack_port_input );
 335     free( p_sys->pp_jack_buffer );
 336     free( p_sys->pp_jack_port_table );
 337     free( p_sys );
 338 }
 339
 340
 341 /*****************************************************************************
 342  * Control
 343  *****************************************************************************/
 344 static int Control( demux_t *p_demux, int i_query, va_list args )
 345 {
 346     bool  *pb;
 347     int64_t     *pi64;
 348     demux_sys_t *p_sys = p_demux->p_sys;
 349
 350     switch( i_query )
 351     {
 352     /* Special for access_demux */
 353     case DEMUX_CAN_PAUSE:
 354     case DEMUX_CAN_SEEK:
 355         pb = (bool *)va_arg( args, bool * );
 356         *pb = true;
 357         return VLC_SUCCESS;
 358
 359     case DEMUX_SET_PAUSE_STATE:
 360         return VLC_SUCCESS;
 361     case DEMUX_CAN_CONTROL_PACE:
 362         pb = ( bool* )va_arg( args, bool * );
 363         *pb = var_GetBool( p_demux, "jack-input-use-vlc-pace" );
 364         return VLC_SUCCESS;
 365
 366     case DEMUX_GET_PTS_DELAY:
 367         pi64 = ( int64_t* )va_arg( args, int64_t * );
 368         *pi64 = ( int64_t )var_GetInteger( p_demux, "jack-input-caching" )
 369             * 1000;
 370         return VLC_SUCCESS;
 371
 372     case DEMUX_GET_TIME:
 373         pi64 = ( int64_t* )va_arg( args, int64_t * );
 374         *pi64 =  date_Get(&p_sys->pts);
 375             return VLC_SUCCESS;
 376
 377     /* TODO implement others */
 378     default:
 379         return VLC_EGENERIC;
 380     }
 381
 382     return VLC_EGENERIC;
 383 }
 384
 385
 386 /*****************************************************************************
 387  * Demux
 388  *****************************************************************************/
 389 static int Demux( demux_t *p_demux )
 390 {
 391
 392     demux_sys_t *p_sys;
 393     es_out_id_t  *p_es;
 394     block_t *p_block;
 395
 396     p_sys = p_demux->p_sys;
 397     p_es = p_sys->p_es_audio;
 398     p_block = GrabJack( p_demux );
 399
 400     if( p_block )
 401     {
 402         es_out_Control( p_demux->out, ES_OUT_SET_PCR, p_block->i_pts );
 403         es_out_Send( p_demux->out, p_es, p_block );
 404     }
 405
 406     return 1;
 407 }
 408
 409
 410 /*****************************************************************************
 411  * Process Callback : fill ringbuffer with Jack audio data
 412  *****************************************************************************/
 413 int Process( jack_nframes_t i_frames, void *p_arg )
 414 {
 415     demux_t            *p_demux = ( demux_t* )p_arg;
 416     demux_sys_t        *p_sys = p_demux->p_sys;
 417     unsigned int        i, j;
 418     size_t              i_write;
 419
 420     /* Get and interlace buffers */
 421     for ( i = 0; i < p_sys->i_channels ; i++ )
 422     {
 423         p_sys->pp_jack_buffer[i] = jack_port_get_buffer(
 424             p_sys->pp_jack_port_input[i], i_frames );
 425     }
 426
 427     /* fill ring buffer with signal */
 428     for( j = 0; j < i_frames; j++ )
 429     {
 430         for( i = 0; i <p_sys->i_channels; i++ )
 431         {
 432             if( jack_ringbuffer_write_space( p_sys->p_jack_ringbuffer ) <
 433                 p_sys->jack_sample_size ) {
 434                 msg_Err( p_demux, "buffer overflow");
 435                 return 0; // buffer overflow
 436             }
 437             i_write = jack_ringbuffer_write( p_sys->p_jack_ringbuffer,
 438                                              ( char * ) (p_sys->pp_jack_buffer[i]+j),
 439                                              p_sys->jack_sample_size );
 440             if (i_write != p_sys->jack_sample_size ) {
 441                 msg_Warn( p_demux, "error writing on ring buffer");
 442             }
 443         }
 444     }
 445
 446     return 0;
 447 }
 448
 449
 450 /*****************************************************************************
 451  * GrabJack: grab audio data in the Jack buffer
 452  *****************************************************************************/
 453 static block_t *GrabJack( demux_t *p_demux )
 454 {
 455     size_t      i_read;
 456     demux_sys_t *p_sys = p_demux->p_sys;
 457     block_t     *p_block;
 458
 459     /* read signal from ring buffer */
 460     i_read = jack_ringbuffer_read_space( p_sys->p_jack_ringbuffer );
 461
 462     if( i_read < 100 ) /* avoid small read */
 463     {   /* vlc has too much free time on its hands? */
 464 #undef msleep
 465 #warning Hmm.... looks wrong
 466         msleep(1000);
 467         return NULL;
 468     }
 469
 470     if( p_sys->p_block_audio )
 471     {
 472         p_block = p_sys->p_block_audio;
 473     }
 474     else
 475     {
 476         p_block = block_New( p_demux, i_read );
 477     }
 478     if( !p_block )
 479     {
 480         msg_Warn( p_demux, "cannot get block" );
 481         return 0;
 482     }
 483
 484     //Find the previous power of 2, this algo assumes size_t has the same size on all arch
 485     i_read >>= 1;
 486     i_read--;
 487     i_read |= i_read >> 1;
 488     i_read |= i_read >> 2;
 489     i_read |= i_read >> 4;
 490     i_read |= i_read >> 8;
 491     i_read |= i_read >> 16;
 492     i_read++;
 493
 494     i_read = jack_ringbuffer_read( p_sys->p_jack_ringbuffer, ( char * ) p_block->p_buffer, i_read );
 495
 496     p_block->i_dts = p_block->i_pts =    date_Increment( &p_sys->pts,
 497          i_read/(p_sys->i_channels * p_sys->jack_sample_size) );
 498
 499     p_sys->p_block_audio = p_block;
 500     p_block->i_buffer = i_read;
 501     p_sys->p_block_audio = 0;
 502
 503     return p_block;
 504 }
 505
 506
 507 /*****************************************************************************
 508  * Port_finder: compare ports with the regexp entered
 509  *****************************************************************************/
 510 static void Port_finder( demux_t *p_demux )
 511 {
 512
 513     demux_sys_t *p_sys = p_demux->p_sys;
 514     char *psz_expr = p_sys->psz_ports;
 515     char *token = NULL;
 516     char *state = NULL;
 517     char *psz_uri = NULL;
 518     const char **pp_jack_port_output = NULL;
 519     int i_out_ports = 0;
 520     int i_total_out_ports =0;
 521     p_sys->pp_jack_port_table = NULL;
 522
 523     /* parse the ports part of the MRL */
 524     for( token = strtok_r( psz_expr, ",", &state ); token;
 525             token = strtok_r( NULL, ",", &state ) )
 526     {
 527         psz_uri = decode_URI_duplicate( token );
 528         /* get the ports which match the regexp */
 529         pp_jack_port_output = jack_get_ports( p_sys->p_jack_client,
 530            psz_uri, NULL, JackPortIsOutput );
 531         if( pp_jack_port_output == NULL )
 532         {
 533             msg_Err( p_demux, "port(s) asked not found:%s", psz_uri );
 534             free( pp_jack_port_output );
 535         }
 536         else
 537         {
 538             while( pp_jack_port_output && pp_jack_port_output[i_out_ports] )
 539             {
 540                 i_out_ports++;
 541             }
 542             /* alloc an array to store all the matched ports */
 543             p_sys->pp_jack_port_table = xrealloc( p_sys->pp_jack_port_table,
 544                 (i_out_ports * sizeof( char * ) + i_total_out_ports * sizeof( char * ) ) );
 545
 546             for(int i=0; i<i_out_ports;i++)
 547             {
 548                 p_sys->pp_jack_port_table[i_total_out_ports+i] = ( char * ) pp_jack_port_output[i];
 549             }
 550
 551             i_total_out_ports += i_out_ports;
 552         }
 553     }
 554
 555     free( pp_jack_port_output );
 556     p_sys->i_match_ports = i_total_out_ports;
 557 }
 558
 559
 560 /*****************************************************************************
 561  * Parse: Parse the MRL
 562  *****************************************************************************/
 563 static void Parse( demux_t *p_demux )
 564 {
 565     demux_sys_t *p_sys = p_demux->p_sys;
 566     char *psz_dup = strdup( p_demux->psz_path );
 567     char *psz_parser = psz_dup;
 568
 569     if( !strncmp( psz_parser, "channels=", strlen( "channels=" ) ) )
 570     {
 571         p_sys->i_channels = abs( strtol( psz_parser + strlen( "channels=" ),
 572             &psz_parser, 0 ) );
 573     }
 574     else if( !strncmp( psz_parser, "ports=", strlen( "ports=" ) ) )
 575     {
 576         int i_len;
 577         psz_parser += strlen( "ports=" );
 578         if( strchr( psz_parser, ':' ) )
 579         {
 580             i_len = strchr( psz_parser, ':' ) - psz_parser;
 581         }
 582         else
 583         {
 584             i_len = strlen( psz_parser );
 585         }
 586         p_sys->psz_ports = strndup( psz_parser, i_len );
 587         psz_parser += i_len;
 588     }
 589     else
 590     {
 591         msg_Warn( p_demux, "unknown option" );
 592     }
 593
 594     while( *psz_parser && *psz_parser != ':' )
 595     {
 596         psz_parser++;
 597     }
 598
 599     if( *psz_parser == ':' )
 600     {
 601         for( ;; )
 602         {
 603             *psz_parser++ = '\0';
 604             if( !strncmp( psz_parser, "channels=", strlen( "channels=" ) ) )
 605             {
 606                 p_sys->i_channels = abs( strtol(
 607                     psz_parser + strlen( "channels=" ), &psz_parser, 0 ) );
 608             }
 609             else if( !strncmp( psz_parser, "ports=", strlen( "ports=" ) ) )
 610             {
 611                 int i_len;
 612                 psz_parser += strlen( "ports=" );
 613                 if( strchr( psz_parser, ':' ) )
 614                 {
 615                     i_len = strchr( psz_parser, ':' ) - psz_parser;
 616                 }
 617                 else
 618                 {
 619                     i_len = strlen( psz_parser );
 620                 }
 621                 p_sys->psz_ports = strndup( psz_parser, i_len );
 622                 psz_parser += i_len;
 623             }
 624             else
 625             {
 626                 msg_Warn( p_demux, "unknown option" );
 627             }
 628             while( *psz_parser && *psz_parser != ':' )
 629             {
 630                 psz_parser++;
 631             }
 632
 633             if( *psz_parser == '\0' )
 634             {
 635                 break;
 636             }
 637         }
 638     }
 639 }
 640