2 * valerie.c -- High Level Client API for miracle
3 * Copyright (C) 2002-2003 Ushodaya Enterprises Limited
4 * Author: Charles Yates <charles.yates@pandora.be>
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
21 /* System header files */
27 /* Application header files */
29 #include "valerie_tokeniser.h"
30 #include "valerie_util.h"
32 /** Initialise the valerie structure.
35 valerie
valerie_init( valerie_parser parser
)
37 valerie
this = malloc( sizeof( valerie_t
) );
40 memset( this, 0, sizeof( valerie_t
) );
41 this->parser
= parser
;
46 /** Set the response structure associated to the last command.
49 static void valerie_set_last_response( valerie
this, valerie_response response
)
53 if ( this->last_response
!= NULL
)
54 valerie_response_close( this->last_response
);
55 this->last_response
= response
;
59 /** Connect to the parser.
62 valerie_error_code
valerie_connect( valerie
this )
64 valerie_error_code error
= valerie_server_unavailable
;
65 valerie_response response
= valerie_parser_connect( this->parser
);
66 if ( response
!= NULL
)
68 valerie_set_last_response( this, response
);
69 if ( valerie_response_get_error_code( response
) == 100 )
75 /** Interpret a non-context sensitive error code.
78 static valerie_error_code
valerie_get_error_code( valerie
this, valerie_response response
)
80 valerie_error_code error
= valerie_server_unavailable
;
81 switch( valerie_response_get_error_code( response
) )
84 error
= valerie_server_unavailable
;
87 error
= valerie_no_response
;
95 error
= valerie_invalid_command
;
98 error
= valerie_server_timeout
;
101 error
= valerie_missing_argument
;
104 error
= valerie_unit_unavailable
;
107 error
= valerie_invalid_file
;
111 error
= valerie_unknown_error
;
117 /** Execute a command.
120 valerie_error_code
valerie_execute( valerie
this, size_t size
, char *format
, ... )
122 valerie_error_code error
= valerie_server_unavailable
;
123 char *command
= malloc( size
);
124 if ( this != NULL
&& command
!= NULL
)
127 va_start( list
, format
);
128 if ( vsnprintf( command
, size
, format
, list
) != 0 )
130 valerie_response response
= valerie_parser_execute( this->parser
, command
);
131 valerie_set_last_response( this, response
);
132 error
= valerie_get_error_code( this, response
);
136 error
= valerie_invalid_command
;
142 error
= valerie_malloc_failed
;
148 /** Execute a command.
151 valerie_error_code
valerie_receive( valerie
this, char *doc
, size_t size
, char *format
, ... )
153 valerie_error_code error
= valerie_server_unavailable
;
154 char *command
= malloc( size
);
155 if ( this != NULL
&& command
!= NULL
)
158 va_start( list
, format
);
159 if ( vsnprintf( command
, size
, format
, list
) != 0 )
161 valerie_response response
= valerie_parser_received( this->parser
, command
, doc
);
162 valerie_set_last_response( this, response
);
163 error
= valerie_get_error_code( this, response
);
167 error
= valerie_invalid_command
;
173 error
= valerie_malloc_failed
;
179 /** Execute a command.
182 valerie_error_code
valerie_push( valerie
this, mlt_service service
, size_t size
, char *format
, ... )
184 valerie_error_code error
= valerie_server_unavailable
;
185 char *command
= malloc( size
);
186 if ( this != NULL
&& command
!= NULL
)
189 va_start( list
, format
);
190 if ( vsnprintf( command
, size
, format
, list
) != 0 )
192 valerie_response response
= valerie_parser_push( this->parser
, command
, service
);
193 valerie_set_last_response( this, response
);
194 error
= valerie_get_error_code( this, response
);
198 error
= valerie_invalid_command
;
204 error
= valerie_malloc_failed
;
210 /** Set a global property.
213 valerie_error_code
valerie_set( valerie
this, char *property
, char *value
)
215 return valerie_execute( this, 1024, "SET %s=%s", property
, value
);
218 /** Get a global property.
221 valerie_error_code
valerie_get( valerie
this, char *property
, char *value
, int length
)
223 valerie_error_code error
= valerie_execute( this, 1024, "GET %s", property
);
224 if ( error
== valerie_ok
)
226 valerie_response response
= valerie_get_last_response( this );
227 strncpy( value
, valerie_response_get_line( response
, 1 ), length
);
235 valerie_error_code
valerie_run( valerie
this, char *file
)
237 return valerie_execute( this, 10240, "RUN \"%s\"", file
);
243 valerie_error_code
valerie_unit_add( valerie
this, char *guid
, int *unit
)
245 valerie_error_code error
= valerie_execute( this, 1024, "UADD %s", guid
);
246 if ( error
== valerie_ok
)
248 int length
= valerie_response_count( this->last_response
);
249 char *line
= valerie_response_get_line( this->last_response
, length
- 1 );
250 if ( line
== NULL
|| sscanf( line
, "U%d", unit
) != 1 )
251 error
= valerie_unit_creation_failed
;
255 if ( error
== valerie_unknown_error
)
256 error
= valerie_unit_creation_failed
;
261 /** Load a file on the specified unit.
264 valerie_error_code
valerie_unit_load( valerie
this, int unit
, char *file
)
266 return valerie_execute( this, 10240, "LOAD U%d \"%s\"", unit
, file
);
269 static void valerie_interpret_clip_offset( char *output
, valerie_clip_offset offset
, int clip
)
273 case valerie_absolute
:
274 sprintf( output
, "%d", clip
);
276 case valerie_relative
:
278 sprintf( output
, "%d", clip
);
280 sprintf( output
, "+%d", clip
);
285 /** Load a file on the specified unit with the specified in/out points.
288 valerie_error_code
valerie_unit_load_clipped( valerie
this, int unit
, char *file
, int32_t in
, int32_t out
)
290 return valerie_execute( this, 10240, "LOAD U%d \"%s\" %d %d", unit
, file
, in
, out
);
293 /** Load a file on the specified unit at the end of the current pump.
296 valerie_error_code
valerie_unit_load_back( valerie
this, int unit
, char *file
)
298 return valerie_execute( this, 10240, "LOAD U%d \"!%s\"", unit
, file
);
301 /** Load a file on the specified unit at the end of the pump with the specified in/out points.
304 valerie_error_code
valerie_unit_load_back_clipped( valerie
this, int unit
, char *file
, int32_t in
, int32_t out
)
306 return valerie_execute( this, 10240, "LOAD U%d \"!%s\" %d %d", unit
, file
, in
, out
);
309 /** Append a file on the specified unit.
312 valerie_error_code
valerie_unit_append( valerie
this, int unit
, char *file
, int32_t in
, int32_t out
)
314 return valerie_execute( this, 10240, "APND U%d \"%s\" %d %d", unit
, file
, in
, out
);
317 /** Push a service on to a unit.
320 valerie_error_code
valerie_unit_receive( valerie
this, int unit
, char *command
, char *doc
)
322 return valerie_receive( this, doc
, 10240, "PUSH U%d %s", unit
, command
);
325 /** Push a service on to a unit.
328 valerie_error_code
valerie_unit_push( valerie
this, int unit
, char *command
, mlt_service service
)
330 return valerie_push( this, service
, 10240, "PUSH U%d %s", unit
, command
);
333 /** Clean the unit - this function removes all but the currently playing clip.
336 valerie_error_code
valerie_unit_clean( valerie
this, int unit
)
338 return valerie_execute( this, 1024, "CLEAN U%d", unit
);
341 /** Clear the unit - this function removes all clips.
344 valerie_error_code
valerie_unit_clear( valerie
this, int unit
)
346 return valerie_execute( this, 1024, "CLEAR U%d", unit
);
349 /** Move clips on the units playlist.
352 valerie_error_code
valerie_unit_clip_move( valerie
this, int unit
, valerie_clip_offset src_offset
, int src
, valerie_clip_offset dest_offset
, int dest
)
356 valerie_interpret_clip_offset( temp1
, src_offset
, src
);
357 valerie_interpret_clip_offset( temp2
, dest_offset
, dest
);
358 return valerie_execute( this, 1024, "MOVE U%d %s %s", unit
, temp1
, temp2
);
361 /** Remove clip at the specified position.
364 valerie_error_code
valerie_unit_clip_remove( valerie
this, int unit
, valerie_clip_offset offset
, int clip
)
367 valerie_interpret_clip_offset( temp
, offset
, clip
);
368 return valerie_execute( this, 1024, "REMOVE U%d %s", unit
, temp
);
371 /** Remove the currently playing clip.
374 valerie_error_code
valerie_unit_remove_current_clip( valerie
this, int unit
)
376 return valerie_execute( this, 1024, "REMOVE U%d", unit
);
379 /** Insert clip at the specified position.
382 valerie_error_code
valerie_unit_clip_insert( valerie
this, int unit
, valerie_clip_offset offset
, int clip
, char *file
, int32_t in
, int32_t out
)
385 valerie_interpret_clip_offset( temp
, offset
, clip
);
386 return valerie_execute( this, 1024, "INSERT U%d \"%s\" %s %d %d", unit
, file
, temp
, in
, out
);
389 /** Play the unit at normal speed.
392 valerie_error_code
valerie_unit_play( valerie
this, int unit
)
394 return valerie_execute( this, 1024, "PLAY U%d 1000", unit
);
397 /** Play the unit at specified speed.
400 valerie_error_code
valerie_unit_play_at_speed( valerie
this, int unit
, int speed
)
402 return valerie_execute( this, 10240, "PLAY U%d %d", unit
, speed
);
405 /** Stop playback on the specified unit.
408 valerie_error_code
valerie_unit_stop( valerie
this, int unit
)
410 return valerie_execute( this, 1024, "STOP U%d", unit
);
413 /** Pause playback on the specified unit.
416 valerie_error_code
valerie_unit_pause( valerie
this, int unit
)
418 return valerie_execute( this, 1024, "PAUSE U%d", unit
);
421 /** Rewind the specified unit.
424 valerie_error_code
valerie_unit_rewind( valerie
this, int unit
)
426 return valerie_execute( this, 1024, "REW U%d", unit
);
429 /** Fast forward the specified unit.
432 valerie_error_code
valerie_unit_fast_forward( valerie
this, int unit
)
434 return valerie_execute( this, 1024, "FF U%d", unit
);
437 /** Step by the number of frames on the specified unit.
440 valerie_error_code
valerie_unit_step( valerie
this, int unit
, int32_t step
)
442 return valerie_execute( this, 1024, "STEP U%d %d", unit
, step
);
445 /** Goto the specified frame on the specified unit.
448 valerie_error_code
valerie_unit_goto( valerie
this, int unit
, int32_t position
)
450 return valerie_execute( this, 1024, "GOTO U%d %d", unit
, position
);
453 /** Goto the specified frame in the clip on the specified unit.
456 valerie_error_code
valerie_unit_clip_goto( valerie
this, int unit
, valerie_clip_offset offset
, int clip
, int32_t position
)
459 valerie_interpret_clip_offset( temp
, offset
, clip
);
460 return valerie_execute( this, 1024, "GOTO U%d %d %s", unit
, position
, temp
);
463 /** Set the in point of the loaded file on the specified unit.
466 valerie_error_code
valerie_unit_set_in( valerie
this, int unit
, int32_t in
)
468 return valerie_execute( this, 1024, "SIN U%d %d", unit
, in
);
471 /** Set the in point of the clip on the specified unit.
474 valerie_error_code
valerie_unit_clip_set_in( valerie
this, int unit
, valerie_clip_offset offset
, int clip
, int32_t in
)
477 valerie_interpret_clip_offset( temp
, offset
, clip
);
478 return valerie_execute( this, 1024, "SIN U%d %d %s", unit
, in
, temp
);
481 /** Set the out point of the loaded file on the specified unit.
484 valerie_error_code
valerie_unit_set_out( valerie
this, int unit
, int32_t out
)
486 return valerie_execute( this, 1024, "SOUT U%d %d", unit
, out
);
489 /** Set the out point of the clip on the specified unit.
492 valerie_error_code
valerie_unit_clip_set_out( valerie
this, int unit
, valerie_clip_offset offset
, int clip
, int32_t in
)
495 valerie_interpret_clip_offset( temp
, offset
, clip
);
496 return valerie_execute( this, 1024, "SOUT U%d %d %s", unit
, in
, temp
);
499 /** Clear the in point of the loaded file on the specified unit.
502 valerie_error_code
valerie_unit_clear_in( valerie
this, int unit
)
504 return valerie_execute( this, 1024, "SIN U%d -1", unit
);
507 /** Clear the out point of the loaded file on the specified unit.
510 valerie_error_code
valerie_unit_clear_out( valerie
this, int unit
)
512 return valerie_execute( this, 1024, "SOUT U%d -1", unit
);
515 /** Clear the in and out points on the loaded file on the specified unit.
518 valerie_error_code
valerie_unit_clear_in_out( valerie
this, int unit
)
520 valerie_error_code error
= valerie_unit_clear_out( this, unit
);
521 if ( error
== valerie_ok
)
522 error
= valerie_unit_clear_in( this, unit
);
526 /** Set a unit configuration property.
529 valerie_error_code
valerie_unit_set( valerie
this, int unit
, char *name
, char *value
)
531 return valerie_execute( this, 1024, "USET U%d %s=%s", unit
, name
, value
);
534 /** Get a unit configuration property.
537 valerie_error_code
valerie_unit_get( valerie
this, int unit
, char *name
)
539 return valerie_execute( this, 1024, "UGET U%d %s", unit
, name
);
542 /** Get a units status.
545 valerie_error_code
valerie_unit_status( valerie
this, int unit
, valerie_status status
)
547 valerie_error_code error
= valerie_execute( this, 1024, "USTA U%d", unit
);
548 int error_code
= valerie_response_get_error_code( this->last_response
);
550 memset( status
, 0, sizeof( valerie_status_t
) );
552 if ( error_code
== 202 && valerie_response_count( this->last_response
) == 2 )
553 valerie_status_parse( status
, valerie_response_get_line( this->last_response
, 1 ) );
554 else if ( error_code
== 403 )
555 status
->status
= unit_undefined
;
560 /** Transfer the current settings of unit src to unit dest.
563 valerie_error_code
valerie_unit_transfer( valerie
this, int src
, int dest
)
565 return valerie_execute( this, 1024, "XFER U%d U%d", src
, dest
);
568 /** Obtain the parsers notifier.
571 valerie_notifier
valerie_get_notifier( valerie
this )
574 return valerie_parser_get_notifier( this->parser
);
579 /** List the contents of the specified directory.
582 valerie_dir
valerie_dir_init( valerie
this, char *directory
)
584 valerie_dir dir
= malloc( sizeof( valerie_dir_t
) );
587 memset( dir
, 0, sizeof( valerie_dir_t
) );
588 dir
->directory
= strdup( directory
);
589 dir
->response
= valerie_parser_executef( this->parser
, "CLS \"%s\"", directory
);
594 /** Return the error code associated to the dir.
597 valerie_error_code
valerie_dir_get_error_code( valerie_dir dir
)
600 return valerie_get_error_code( NULL
, dir
->response
);
602 return valerie_malloc_failed
;
605 /** Get a particular file entry in the directory.
608 valerie_error_code
valerie_dir_get( valerie_dir dir
, int index
, valerie_dir_entry entry
)
610 valerie_error_code error
= valerie_ok
;
611 memset( entry
, 0, sizeof( valerie_dir_entry_t
) );
612 if ( index
< valerie_dir_count( dir
) )
614 char *line
= valerie_response_get_line( dir
->response
, index
+ 1 );
615 valerie_tokeniser tokeniser
= valerie_tokeniser_init( );
616 valerie_tokeniser_parse_new( tokeniser
, line
, " " );
618 if ( valerie_tokeniser_count( tokeniser
) > 0 )
620 valerie_util_strip( valerie_tokeniser_get_string( tokeniser
, 0 ), '\"' );
621 strcpy( entry
->full
, dir
->directory
);
622 if ( entry
->full
[ strlen( entry
->full
) - 1 ] != '/' )
623 strcat( entry
->full
, "/" );
624 strcpy( entry
->name
, valerie_tokeniser_get_string( tokeniser
, 0 ) );
625 strcat( entry
->full
, entry
->name
);
627 switch ( valerie_tokeniser_count( tokeniser
) )
633 entry
->size
= strtoull( valerie_tokeniser_get_string( tokeniser
, 1 ), NULL
, 10 );
636 error
= valerie_invalid_file
;
640 valerie_tokeniser_close( tokeniser
);
645 /** Get the number of entries in the directory
648 int valerie_dir_count( valerie_dir dir
)
650 if ( dir
!= NULL
&& valerie_response_count( dir
->response
) >= 2 )
651 return valerie_response_count( dir
->response
) - 2;
656 /** Close the directory structure.
659 void valerie_dir_close( valerie_dir dir
)
663 free( dir
->directory
);
664 valerie_response_close( dir
->response
);
669 /** List the playlist of the specified unit.
672 valerie_list
valerie_list_init( valerie
this, int unit
)
674 valerie_list list
= calloc( 1, sizeof( valerie_list_t
) );
677 list
->response
= valerie_parser_executef( this->parser
, "LIST U%d", unit
);
678 if ( valerie_response_count( list
->response
) >= 2 )
679 list
->generation
= atoi( valerie_response_get_line( list
->response
, 1 ) );
684 /** Return the error code associated to the list.
687 valerie_error_code
valerie_list_get_error_code( valerie_list list
)
690 return valerie_get_error_code( NULL
, list
->response
);
692 return valerie_malloc_failed
;
695 /** Get a particular file entry in the list.
698 valerie_error_code
valerie_list_get( valerie_list list
, int index
, valerie_list_entry entry
)
700 valerie_error_code error
= valerie_ok
;
701 memset( entry
, 0, sizeof( valerie_list_entry_t
) );
702 if ( index
< valerie_list_count( list
) )
704 char *line
= valerie_response_get_line( list
->response
, index
+ 2 );
705 valerie_tokeniser tokeniser
= valerie_tokeniser_init( );
706 valerie_tokeniser_parse_new( tokeniser
, line
, " " );
708 if ( valerie_tokeniser_count( tokeniser
) > 0 )
710 entry
->clip
= atoi( valerie_tokeniser_get_string( tokeniser
, 0 ) );
711 valerie_util_strip( valerie_tokeniser_get_string( tokeniser
, 1 ), '\"' );
712 strcpy( entry
->full
, valerie_tokeniser_get_string( tokeniser
, 1 ) );
713 entry
->in
= atol( valerie_tokeniser_get_string( tokeniser
, 2 ) );
714 entry
->out
= atol( valerie_tokeniser_get_string( tokeniser
, 3 ) );
715 entry
->max
= atol( valerie_tokeniser_get_string( tokeniser
, 4 ) );
716 entry
->size
= atol( valerie_tokeniser_get_string( tokeniser
, 5 ) );
717 entry
->fps
= atof( valerie_tokeniser_get_string( tokeniser
, 6 ) );
719 valerie_tokeniser_close( tokeniser
);
724 /** Get the number of entries in the list
727 int valerie_list_count( valerie_list list
)
729 if ( list
!= NULL
&& valerie_response_count( list
->response
) >= 3 )
730 return valerie_response_count( list
->response
) - 3;
735 /** Close the list structure.
738 void valerie_list_close( valerie_list list
)
742 valerie_response_close( list
->response
);
747 /** List the currently connected nodes.
750 valerie_nodes
valerie_nodes_init( valerie
this )
752 valerie_nodes nodes
= malloc( sizeof( valerie_nodes_t
) );
755 memset( nodes
, 0, sizeof( valerie_nodes_t
) );
756 nodes
->response
= valerie_parser_executef( this->parser
, "NLS" );
761 /** Return the error code associated to the nodes list.
764 valerie_error_code
valerie_nodes_get_error_code( valerie_nodes nodes
)
767 return valerie_get_error_code( NULL
, nodes
->response
);
769 return valerie_malloc_failed
;
772 /** Get a particular node entry.
775 valerie_error_code
valerie_nodes_get( valerie_nodes nodes
, int index
, valerie_node_entry entry
)
777 valerie_error_code error
= valerie_ok
;
778 memset( entry
, 0, sizeof( valerie_node_entry_t
) );
779 if ( index
< valerie_nodes_count( nodes
) )
781 char *line
= valerie_response_get_line( nodes
->response
, index
+ 1 );
782 valerie_tokeniser tokeniser
= valerie_tokeniser_init( );
783 valerie_tokeniser_parse_new( tokeniser
, line
, " " );
785 if ( valerie_tokeniser_count( tokeniser
) == 3 )
787 entry
->node
= atoi( valerie_tokeniser_get_string( tokeniser
, 0 ) );
788 strncpy( entry
->guid
, valerie_tokeniser_get_string( tokeniser
, 1 ), sizeof( entry
->guid
) );
789 valerie_util_strip( valerie_tokeniser_get_string( tokeniser
, 2 ), '\"' );
790 strncpy( entry
->name
, valerie_tokeniser_get_string( tokeniser
, 2 ), sizeof( entry
->name
) );
793 valerie_tokeniser_close( tokeniser
);
798 /** Get the number of nodes
801 int valerie_nodes_count( valerie_nodes nodes
)
803 if ( nodes
!= NULL
&& valerie_response_count( nodes
->response
) >= 2 )
804 return valerie_response_count( nodes
->response
) - 2;
809 /** Close the nodes structure.
812 void valerie_nodes_close( valerie_nodes nodes
)
816 valerie_response_close( nodes
->response
);
821 /** List the currently defined units.
824 valerie_units
valerie_units_init( valerie
this )
826 valerie_units units
= malloc( sizeof( valerie_units_t
) );
829 memset( units
, 0, sizeof( valerie_units_t
) );
830 units
->response
= valerie_parser_executef( this->parser
, "ULS" );
835 /** Return the error code associated to the nodes list.
838 valerie_error_code
valerie_units_get_error_code( valerie_units units
)
841 return valerie_get_error_code( NULL
, units
->response
);
843 return valerie_malloc_failed
;
846 /** Get a particular unit entry.
849 valerie_error_code
valerie_units_get( valerie_units units
, int index
, valerie_unit_entry entry
)
851 valerie_error_code error
= valerie_ok
;
852 memset( entry
, 0, sizeof( valerie_unit_entry_t
) );
853 if ( index
< valerie_units_count( units
) )
855 char *line
= valerie_response_get_line( units
->response
, index
+ 1 );
856 valerie_tokeniser tokeniser
= valerie_tokeniser_init( );
857 valerie_tokeniser_parse_new( tokeniser
, line
, " " );
859 if ( valerie_tokeniser_count( tokeniser
) == 4 )
861 entry
->unit
= atoi( valerie_tokeniser_get_string( tokeniser
, 0 ) + 1 );
862 entry
->node
= atoi( valerie_tokeniser_get_string( tokeniser
, 1 ) );
863 strncpy( entry
->guid
, valerie_tokeniser_get_string( tokeniser
, 2 ), sizeof( entry
->guid
) );
864 entry
->online
= atoi( valerie_tokeniser_get_string( tokeniser
, 3 ) );
867 valerie_tokeniser_close( tokeniser
);
872 /** Get the number of units
875 int valerie_units_count( valerie_units units
)
877 if ( units
!= NULL
&& valerie_response_count( units
->response
) >= 2 )
878 return valerie_response_count( units
->response
) - 2;
883 /** Close the units structure.
886 void valerie_units_close( valerie_units units
)
890 valerie_response_close( units
->response
);
895 /** Get the response of the last command executed.
898 valerie_response
valerie_get_last_response( valerie
this )
900 return this->last_response
;
903 /** Obtain a printable message associated to the error code provided.
906 char *valerie_error_description( valerie_error_code error
)
908 char *msg
= "Unrecognised error";
914 case valerie_malloc_failed
:
915 msg
= "Memory allocation error";
917 case valerie_unknown_error
:
918 msg
= "Unknown error";
920 case valerie_no_response
:
921 msg
= "No response obtained";
923 case valerie_invalid_command
:
924 msg
= "Invalid command";
926 case valerie_server_timeout
:
927 msg
= "Communications with server timed out";
929 case valerie_missing_argument
:
930 msg
= "Missing argument";
932 case valerie_server_unavailable
:
933 msg
= "Unable to communicate with server";
935 case valerie_unit_creation_failed
:
936 msg
= "Unit creation failed";
938 case valerie_unit_unavailable
:
939 msg
= "Unit unavailable";
941 case valerie_invalid_file
:
942 msg
= "Invalid file";
944 case valerie_invalid_position
:
945 msg
= "Invalid position";
951 /** Close the valerie structure.
954 void valerie_close( valerie
this )
958 valerie_set_last_response( this, NULL
);