git.sesse.net Git - vlc/blob - modules/access/jack.c

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