f1690817152f1100527c249ba98c34b7477ba796
[melted] / src / miracle / miracle_local.c
1 /*
2 * miracle_local.c -- Local Miracle Parser
3 * Copyright (C) 2002-2003 Ushodaya Enterprises Limited
4 * Author: Charles Yates <charles.yates@pandora.be>
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
10 *
11 * This program 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
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software Foundation,
18 * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
19 */
20
21 #ifdef HAVE_CONFIG_H
22 #include <config.h>
23 #endif
24
25 /* System header files */
26 #include <stdlib.h>
27 #include <string.h>
28 #include <signal.h>
29 #include <execinfo.h>
30 #include <stdio.h>
31
32 /* Valerie header files */
33 #include <valerie/valerie_util.h>
34
35 /* MLT header files. */
36 #include <framework/mlt_factory.h>
37
38 /* Application header files */
39 #include "miracle_local.h"
40 #include "miracle_connection.h"
41 #include "miracle_commands.h"
42 #include "miracle_unit_commands.h"
43 #include "miracle_log.h"
44
45 /** Private miracle_local structure.
46 */
47
48 typedef struct
49 {
50 valerie_parser parser;
51 char root_dir[1024];
52 }
53 *miracle_local, miracle_local_t;
54
55 /** Forward declarations.
56 */
57
58 static valerie_response miracle_local_connect( miracle_local );
59 static valerie_response miracle_local_execute( miracle_local, char * );
60 static void miracle_local_close( miracle_local );
61 response_codes miracle_help( command_argument arg );
62 response_codes miracle_run( command_argument arg );
63 response_codes miracle_shutdown( command_argument arg );
64
65 /** DV Parser constructor.
66 */
67
68 valerie_parser miracle_parser_init_local( )
69 {
70 valerie_parser parser = malloc( sizeof( valerie_parser_t ) );
71 miracle_local local = malloc( sizeof( miracle_local_t ) );
72
73 if ( parser != NULL )
74 {
75 memset( parser, 0, sizeof( valerie_parser_t ) );
76
77 parser->connect = (parser_connect)miracle_local_connect;
78 parser->execute = (parser_execute)miracle_local_execute;
79 parser->close = (parser_close)miracle_local_close;
80 parser->real = local;
81
82 if ( local != NULL )
83 {
84 memset( local, 0, sizeof( miracle_local_t ) );
85 local->parser = parser;
86 local->root_dir[0] = '/';
87 }
88
89 // Construct the factory
90 mlt_factory_init( getenv( "MLT_REPOSITORY" ) );
91 }
92 return parser;
93 }
94
95 /** response status code/message pair
96 */
97
98 typedef struct
99 {
100 int code;
101 char *message;
102 }
103 responses_t;
104
105 /** response messages
106 */
107
108 static responses_t responses [] =
109 {
110 {RESPONSE_SUCCESS, "OK"},
111 {RESPONSE_SUCCESS_N, "OK"},
112 {RESPONSE_SUCCESS_1, "OK"},
113 {RESPONSE_UNKNOWN_COMMAND, "Unknown command"},
114 {RESPONSE_TIMEOUT, "Operation timed out"},
115 {RESPONSE_MISSING_ARG, "Argument missing"},
116 {RESPONSE_INVALID_UNIT, "Unit not found"},
117 {RESPONSE_BAD_FILE, "Failed to locate or open clip"},
118 {RESPONSE_OUT_OF_RANGE, "Argument value out of range"},
119 {RESPONSE_TOO_MANY_FILES, "Too many files open"},
120 {RESPONSE_ERROR, "Server Error"}
121 };
122
123 /** Argument types.
124 */
125
126 typedef enum
127 {
128 ATYPE_NONE,
129 ATYPE_FLOAT,
130 ATYPE_STRING,
131 ATYPE_INT
132 }
133 arguments_types;
134
135 /** A command definition.
136 */
137
138 typedef struct
139 {
140 /* The command string corresponding to this operation (e.g. "play") */
141 char *command;
142 /* The function associated with it */
143 response_codes (*operation) ( command_argument );
144 /* a boolean to indicate if this is a unit or global command
145 unit commands require a unit identifier as first argument */
146 int is_unit;
147 /* What type is the argument (RTTI :-) ATYPE_whatever */
148 int type;
149 /* online help information */
150 char *help;
151 }
152 command_t;
153
154 /* The following define the queue of commands available to the user. The
155 first entry is the name of the command (the string which must be typed),
156 the second command is the function associated with it, the third argument
157 is for the type of the argument, and the last argument specifies whether
158 this is something which should be handled immediately or whether it
159 should be queued (only robot motion commands need to be queued). */
160
161 static command_t vocabulary[] =
162 {
163 {"BYE", NULL, 0, ATYPE_NONE, "Terminates the session. Units are not removed and task queue is not flushed."},
164 {"HELP", miracle_help, 0, ATYPE_NONE, "Display this information!"},
165 {"NLS", miracle_list_nodes, 0, ATYPE_NONE, "List the AV/C nodes on the 1394 bus."},
166 {"UADD", miracle_add_unit, 0, ATYPE_STRING, "Create a new DV unit (virtual VTR) to transmit to receiver specified in GUID argument."},
167 {"ULS", miracle_list_units, 0, ATYPE_NONE, "Lists the units that have already been added to the server."},
168 {"CLS", miracle_list_clips, 0, ATYPE_STRING, "Lists the clips at directory name argument."},
169 {"SET", miracle_set_global_property, 0, ATYPE_STRING, "Set a server configuration property."},
170 {"GET", miracle_get_global_property, 0, ATYPE_STRING, "Get a server configuration property."},
171 {"RUN", miracle_run, 0, ATYPE_STRING, "Run a batch file." },
172 {"LIST", miracle_list, 1, ATYPE_NONE, "List the playlist associated to a unit."},
173 {"LOAD", miracle_load, 1, ATYPE_STRING, "Load clip specified in absolute filename argument."},
174 {"INSERT", miracle_insert, 1, ATYPE_STRING, "Insert a clip at the given clip index."},
175 {"REMOVE", miracle_remove, 1, ATYPE_NONE, "Remove a clip at the given clip index."},
176 {"CLEAN", miracle_clean, 1, ATYPE_NONE, "Clean a unit by removing all but the currently playing clip."},
177 {"MOVE", miracle_move, 1, ATYPE_INT, "Move a clip to another clip index."},
178 {"APND", miracle_append, 1, ATYPE_STRING, "Append a clip specified in absolute filename argument."},
179 {"PLAY", miracle_play, 1, ATYPE_NONE, "Play a loaded clip at speed -2000 to 2000 where 1000 = normal forward speed."},
180 {"STOP", miracle_stop, 1, ATYPE_NONE, "Stop a loaded and playing clip."},
181 {"PAUSE", miracle_pause, 1, ATYPE_NONE, "Pause a playing clip."},
182 {"REW", miracle_rewind, 1, ATYPE_NONE, "Rewind a unit. If stopped, seek to beginning of clip. If playing, play fast backwards."},
183 {"FF", miracle_ff, 1, ATYPE_NONE, "Fast forward a unit. If stopped, seek to beginning of clip. If playing, play fast forwards."},
184 {"STEP", miracle_step, 1, ATYPE_INT, "Step argument number of frames forward or backward."},
185 {"GOTO", miracle_goto, 1, ATYPE_INT, "Jump to frame number supplied as argument."},
186 {"SIN", miracle_set_in_point, 1, ATYPE_INT, "Set the IN point of the loaded clip to frame number argument. -1 = reset in point to 0"},
187 {"SOUT", miracle_set_out_point, 1, ATYPE_INT, "Set the OUT point of the loaded clip to frame number argument. -1 = reset out point to maximum."},
188 {"USTA", miracle_get_unit_status, 1, ATYPE_NONE, "Report information about the unit."},
189 {"USET", miracle_set_unit_property, 1, ATYPE_STRING, "Set a unit configuration property."},
190 {"UGET", miracle_get_unit_property, 1, ATYPE_STRING, "Get a unit configuration property."},
191 {"XFER", miracle_transfer, 1, ATYPE_STRING, "Transfer the unit's clip to another unit specified as argument."},
192 {"SHUTDOWN", miracle_shutdown, 0, ATYPE_NONE, "Shutdown the server."},
193 {NULL, NULL, 0, ATYPE_NONE, NULL}
194 };
195
196 /** Usage message
197 */
198
199 static char helpstr [] =
200 "Miracle -- A Multimedia Playout Server\n"
201 " Copyright (C) 2002-2003 Ushodaya Enterprises Limited\n"
202 " Authors:\n"
203 " Dan Dennedy <dan@dennedy.org>\n"
204 " Charles Yates <charles.yates@pandora.be>\n"
205 "Available commands:\n";
206
207 /** Lookup the response message for a status code.
208 */
209
210 inline char *get_response_msg( int code )
211 {
212 int i = 0;
213 for ( i = 0; responses[ i ].message != NULL && code != responses[ i ].code; i ++ ) ;
214 return responses[ i ].message;
215 }
216
217 /** Tell the user the miracle command set
218 */
219
220 response_codes miracle_help( command_argument cmd_arg )
221 {
222 int i = 0;
223
224 valerie_response_printf( cmd_arg->response, 10240, "%s", helpstr );
225
226 for ( i = 0; vocabulary[ i ].command != NULL; i ++ )
227 valerie_response_printf( cmd_arg->response, 1024,
228 "%-10.10s%s\n",
229 vocabulary[ i ].command,
230 vocabulary[ i ].help );
231
232 valerie_response_printf( cmd_arg->response, 2, "\n" );
233
234 return RESPONSE_SUCCESS_N;
235 }
236
237 /** Execute a batch file.
238 */
239
240 response_codes miracle_run( command_argument cmd_arg )
241 {
242 valerie_response temp = valerie_parser_run( cmd_arg->parser, (char *)cmd_arg->argument );
243
244 if ( temp != NULL )
245 {
246 int index = 0;
247
248 valerie_response_set_error( cmd_arg->response,
249 valerie_response_get_error_code( temp ),
250 valerie_response_get_error_string( temp ) );
251
252 for ( index = 1; index < valerie_response_count( temp ); index ++ )
253 valerie_response_printf( cmd_arg->response, 10240, "%s\n", valerie_response_get_line( temp, index ) );
254
255 valerie_response_close( temp );
256 }
257
258 return valerie_response_get_error_code( cmd_arg->response );
259 }
260
261 response_codes miracle_shutdown( command_argument cmd_arg )
262 {
263 exit( 0 );
264 return RESPONSE_SUCCESS;
265 }
266
267 /** Processes 'thread' id
268 */
269
270 static pthread_t self;
271
272 /* Signal handler to deal with various shutdown signals. Basically this
273 should clean up and power down the motor. Note that the death of any
274 child thread will kill all thrads. */
275
276 void signal_handler( int sig )
277 {
278 if ( pthread_equal( self, pthread_self( ) ) )
279 {
280
281 #ifdef _GNU_SOURCE
282 miracle_log( LOG_DEBUG, "Received %s - shutting down.", strsignal(sig) );
283 #else
284 miracle_log( LOG_DEBUG, "Received signal %i - shutting down.", sig );
285 #endif
286
287 exit(EXIT_SUCCESS);
288 }
289 }
290
291 static void sigsegv_handler()
292 {
293 void *array[ 10 ];
294 size_t size;
295 char **strings;
296 size_t i;
297
298 miracle_log( LOG_CRIT, "\a\nMiracle experienced a segmentation fault.\n"
299 "Dumping stack from the offending thread\n\n" );
300 size = backtrace( array, 10 );
301 strings = backtrace_symbols( array, size );
302
303 miracle_log( LOG_CRIT, "Obtained %zd stack frames.\n", size );
304
305 for ( i = 0; i < size; i++ )
306 miracle_log( LOG_CRIT, "%s\n", strings[ i ] );
307
308 free( strings );
309
310 miracle_log( LOG_CRIT, "\nDone dumping - exiting.\n" );
311 exit( EXIT_FAILURE );
312 }
313
314
315
316 /** Local 'connect' function.
317 */
318
319 static valerie_response miracle_local_connect( miracle_local local )
320 {
321 valerie_response response = valerie_response_init( );
322
323 self = pthread_self( );
324
325 valerie_response_set_error( response, 100, "VTR Ready" );
326
327 signal( SIGHUP, signal_handler );
328 signal( SIGINT, signal_handler );
329 signal( SIGTERM, SIG_DFL );
330 signal( SIGSTOP, signal_handler );
331 signal( SIGPIPE, signal_handler );
332 signal( SIGALRM, signal_handler );
333 signal( SIGCHLD, SIG_IGN );
334 signal( SIGSEGV, sigsegv_handler );
335
336 return response;
337 }
338
339 /** Set the error and determine the message associated to this command.
340 */
341
342 void miracle_command_set_error( command_argument cmd, response_codes code )
343 {
344 valerie_response_set_error( cmd->response, code, get_response_msg( code ) );
345 }
346
347 /** Parse the unit argument.
348 */
349
350 int miracle_command_parse_unit( command_argument cmd, int argument )
351 {
352 int unit = -1;
353 char *string = valerie_tokeniser_get_string( cmd->tokeniser, argument );
354 if ( string != NULL && ( string[ 0 ] == 'U' || string[ 0 ] == 'u' ) && strlen( string ) > 1 )
355 unit = atoi( string + 1 );
356 return unit;
357 }
358
359 /** Parse a normal argument.
360 */
361
362 void *miracle_command_parse_argument( command_argument cmd, int argument, arguments_types type )
363 {
364 void *ret = NULL;
365 char *value = valerie_tokeniser_get_string( cmd->tokeniser, argument );
366
367 if ( value != NULL )
368 {
369 switch( type )
370 {
371 case ATYPE_NONE:
372 break;
373
374 case ATYPE_FLOAT:
375 ret = malloc( sizeof( float ) );
376 if ( ret != NULL )
377 *( float * )ret = atof( value );
378 break;
379
380 case ATYPE_STRING:
381 ret = strdup( value );
382 break;
383
384 case ATYPE_INT:
385 ret = malloc( sizeof( int ) );
386 if ( ret != NULL )
387 *( int * )ret = atoi( value );
388 break;
389 }
390 }
391
392 return ret;
393 }
394
395 /** Get the error code - note that we simply the success return.
396 */
397
398 response_codes miracle_command_get_error( command_argument cmd )
399 {
400 response_codes ret = valerie_response_get_error_code( cmd->response );
401 if ( ret == RESPONSE_SUCCESS_N || ret == RESPONSE_SUCCESS_1 )
402 ret = RESPONSE_SUCCESS;
403 return ret;
404 }
405
406 /** Execute the command.
407 */
408
409 static valerie_response miracle_local_execute( miracle_local local, char *command )
410 {
411 command_argument_t cmd;
412 cmd.parser = local->parser;
413 cmd.response = valerie_response_init( );
414 cmd.tokeniser = valerie_tokeniser_init( );
415 cmd.command = command;
416 cmd.unit = -1;
417 cmd.argument = NULL;
418 cmd.root_dir = local->root_dir;
419
420 /* Set the default error */
421 miracle_command_set_error( &cmd, RESPONSE_UNKNOWN_COMMAND );
422
423 /* Parse the command */
424 if ( valerie_tokeniser_parse_new( cmd.tokeniser, command, " " ) > 0 )
425 {
426 int index = 0;
427 char *value = valerie_tokeniser_get_string( cmd.tokeniser, 0 );
428 int found = 0;
429
430 /* Strip quotes from all tokens */
431 for ( index = 0; index < valerie_tokeniser_count( cmd.tokeniser ); index ++ )
432 valerie_util_strip( valerie_tokeniser_get_string( cmd.tokeniser, index ), '\"' );
433
434 /* Search the vocabulary array for value */
435 for ( index = 1; !found && vocabulary[ index ].command != NULL; index ++ )
436 if ( ( found = !strcasecmp( vocabulary[ index ].command, value ) ) )
437 break;
438
439 /* If we found something, the handle the args and call the handler. */
440 if ( found )
441 {
442 int position = 1;
443
444 miracle_command_set_error( &cmd, RESPONSE_SUCCESS );
445
446 if ( vocabulary[ index ].is_unit )
447 {
448 cmd.unit = miracle_command_parse_unit( &cmd, position );
449 if ( cmd.unit == -1 )
450 miracle_command_set_error( &cmd, RESPONSE_MISSING_ARG );
451 position ++;
452 }
453
454 if ( miracle_command_get_error( &cmd ) == RESPONSE_SUCCESS )
455 {
456 cmd.argument = miracle_command_parse_argument( &cmd, position, vocabulary[ index ].type );
457 if ( cmd.argument == NULL && vocabulary[ index ].type != ATYPE_NONE )
458 miracle_command_set_error( &cmd, RESPONSE_MISSING_ARG );
459 position ++;
460 }
461
462 if ( miracle_command_get_error( &cmd ) == RESPONSE_SUCCESS )
463 {
464 response_codes error = vocabulary[ index ].operation( &cmd );
465 miracle_command_set_error( &cmd, error );
466 }
467
468 free( cmd.argument );
469 }
470 }
471
472 valerie_tokeniser_close( cmd.tokeniser );
473
474 return cmd.response;
475 }
476
477 /** Close the parser.
478 */
479
480 static void miracle_local_close( miracle_local local )
481 {
482 miracle_delete_all_units();
483 pthread_kill_other_threads_np();
484 miracle_log( LOG_DEBUG, "Clean shutdown." );
485 free( local );
486 //mlt_factory_close( );
487 }