fce4ab2214f1f07f58b5d49198b99781669762b4
[melted] / mlt / src / miracle / miracle_local.c
1 /*
2 * dvlocal.c -- Local dv1394d 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
30 /* Library header files */
31 #include <dvutil.h>
32
33 /* Application header files */
34 #include <dvclipfactory.h>
35 #include <dvframepool.h>
36 #include "dvlocal.h"
37 #include "dvconnection.h"
38 #include "global_commands.h"
39 #include "unit_commands.h"
40 #include "log.h"
41 #include "raw1394util.h"
42
43 /** Private dv_local structure.
44 */
45
46 typedef struct
47 {
48 dv_parser parser;
49 char root_dir[1024];
50 }
51 *dv_local, dv_local_t;
52
53 /** Forward declarations.
54 */
55
56 static dv_response dv_local_connect( dv_local );
57 static dv_response dv_local_execute( dv_local, char * );
58 static void dv_local_close( dv_local );
59 response_codes print_help( command_argument arg );
60 response_codes dv1394d_run( command_argument arg );
61 response_codes dv1394d_shutdown( command_argument arg );
62
63 /** DV Parser constructor.
64 */
65
66 dv_parser dv_parser_init_local( )
67 {
68 dv_parser parser = malloc( sizeof( dv_parser_t ) );
69 dv_local local = malloc( sizeof( dv_local_t ) );
70
71 if ( parser != NULL )
72 {
73 memset( parser, 0, sizeof( dv_parser_t ) );
74
75 parser->connect = (parser_connect)dv_local_connect;
76 parser->execute = (parser_execute)dv_local_execute;
77 parser->close = (parser_close)dv_local_close;
78 parser->real = local;
79
80 if ( local != NULL )
81 {
82 memset( local, 0, sizeof( dv_local_t ) );
83 local->parser = parser;
84 local->root_dir[0] = '/';
85 }
86 }
87 return parser;
88 }
89
90 /** response status code/message pair
91 */
92
93 typedef struct
94 {
95 int code;
96 char *message;
97 }
98 responses_t;
99
100 /** response messages
101 */
102
103 static responses_t responses [] =
104 {
105 {RESPONSE_SUCCESS, "OK"},
106 {RESPONSE_SUCCESS_N, "OK"},
107 {RESPONSE_SUCCESS_1, "OK"},
108 {RESPONSE_UNKNOWN_COMMAND, "Unknown command"},
109 {RESPONSE_TIMEOUT, "Operation timed out"},
110 {RESPONSE_MISSING_ARG, "Argument missing"},
111 {RESPONSE_INVALID_UNIT, "Unit not found"},
112 {RESPONSE_BAD_FILE, "Failed to locate or open clip"},
113 {RESPONSE_OUT_OF_RANGE, "Argument value out of range"},
114 {RESPONSE_TOO_MANY_FILES, "Too many files open"},
115 {RESPONSE_ERROR, "Server Error"}
116 };
117
118 /** Argument types.
119 */
120
121 typedef enum
122 {
123 ATYPE_NONE,
124 ATYPE_FLOAT,
125 ATYPE_STRING,
126 ATYPE_INT
127 }
128 arguments_types;
129
130 /** A command definition.
131 */
132
133 typedef struct
134 {
135 /* The command string corresponding to this operation (e.g. "play") */
136 char *command;
137 /* The function associated with it */
138 response_codes (*operation) ( command_argument );
139 /* a boolean to indicate if this is a unit or global command
140 unit commands require a unit identifier as first argument */
141 int is_unit;
142 /* What type is the argument (RTTI :-) ATYPE_whatever */
143 int type;
144 /* online help information */
145 char *help;
146 }
147 command_t;
148
149 /* The following define the queue of commands available to the user. The
150 first entry is the name of the command (the string which must be typed),
151 the second command is the function associated with it, the third argument
152 is for the type of the argument, and the last argument specifies whether
153 this is something which should be handled immediately or whether it
154 should be queued (only robot motion commands need to be queued). */
155
156 static command_t vocabulary[] =
157 {
158 {"BYE", NULL, 0, ATYPE_NONE, "Terminates the session. Units are not removed and task queue is not flushed."},
159 {"HELP", print_help, 0, ATYPE_NONE, "Display this information!"},
160 {"NLS", dv1394d_list_nodes, 0, ATYPE_NONE, "List the AV/C nodes on the 1394 bus."},
161 {"UADD", dv1394d_add_unit, 0, ATYPE_STRING, "Create a new DV unit (virtual VTR) to transmit to receiver specified in GUID argument."},
162 {"ULS", dv1394d_list_units, 0, ATYPE_NONE, "Lists the units that have already been added to the server."},
163 {"CLS", dv1394d_list_clips, 0, ATYPE_STRING, "Lists the clips at directory name argument."},
164 {"SET", dv1394d_set_global_property, 0, ATYPE_STRING, "Set a server configuration property."},
165 {"GET", dv1394d_get_global_property, 0, ATYPE_STRING, "Get a server configuration property."},
166 {"RUN", dv1394d_run, 0, ATYPE_STRING, "Run a batch file." },
167 {"LIST", dv1394d_list, 1, ATYPE_NONE, "List the playlist associated to a unit."},
168 {"LOAD", dv1394d_load, 1, ATYPE_STRING, "Load clip specified in absolute filename argument."},
169 {"INSERT", dv1394d_insert, 1, ATYPE_STRING, "Insert a clip at the given clip index."},
170 {"REMOVE", dv1394d_remove, 1, ATYPE_NONE, "Remove a clip at the given clip index."},
171 {"CLEAN", dv1394d_clean, 1, ATYPE_NONE, "Clean a unit by removing all but the currently playing clip."},
172 {"MOVE", dv1394d_move, 1, ATYPE_INT, "Move a clip to another clip index."},
173 {"APND", dv1394d_append, 1, ATYPE_STRING, "Append a clip specified in absolute filename argument."},
174 {"PLAY", dv1394d_play, 1, ATYPE_NONE, "Play a loaded clip at speed -2000 to 2000 where 1000 = normal forward speed."},
175 {"STOP", dv1394d_stop, 1, ATYPE_NONE, "Stop a loaded and playing clip."},
176 {"PAUSE", dv1394d_pause, 1, ATYPE_NONE, "Pause a playing clip."},
177 {"REW", dv1394d_rewind, 1, ATYPE_NONE, "Rewind a unit. If stopped, seek to beginning of clip. If playing, play fast backwards."},
178 {"FF", dv1394d_ff, 1, ATYPE_NONE, "Fast forward a unit. If stopped, seek to beginning of clip. If playing, play fast forwards."},
179 {"STEP", dv1394d_step, 1, ATYPE_INT, "Step argument number of frames forward or backward."},
180 {"GOTO", dv1394d_goto, 1, ATYPE_INT, "Jump to frame number supplied as argument."},
181 {"SIN", dv1394d_set_in_point, 1, ATYPE_INT, "Set the IN point of the loaded clip to frame number argument. -1 = reset in point to 0"},
182 {"SOUT", dv1394d_set_out_point, 1, ATYPE_INT, "Set the OUT point of the loaded clip to frame number argument. -1 = reset out point to maximum."},
183 {"USTA", dv1394d_get_unit_status, 1, ATYPE_NONE, "Report information about the unit."},
184 {"USET", dv1394d_set_unit_property, 1, ATYPE_STRING, "Set a unit configuration property."},
185 {"UGET", dv1394d_get_unit_property, 1, ATYPE_STRING, "Get a unit configuration property."},
186 {"XFER", dv1394d_transfer, 1, ATYPE_STRING, "Transfer the unit's clip to another unit specified as argument."},
187 {"SHUTDOWN", dv1394d_shutdown, 0, ATYPE_NONE, "Shutdown the server."},
188 {NULL, NULL, 0, ATYPE_NONE, NULL}
189 };
190
191 /** Usage message
192 */
193
194 static char helpstr [] =
195 "dv1394d -- A DV over IEEE 1394 TCP Server\n"
196 " Copyright (C) 2002-2003 Ushodaya Enterprises Limited\n"
197 " Authors:\n"
198 " Dan Dennedy <dan@dennedy.org>\n"
199 " Charles Yates <charles.yates@pandora.be>\n"
200 "Available commands:\n";
201
202 /** Lookup the response message for a status code.
203 */
204
205 inline char *get_response_msg( int code )
206 {
207 int i = 0;
208 for ( i = 0; responses[ i ].message != NULL && code != responses[ i ].code; i ++ ) ;
209 return responses[ i ].message;
210 }
211
212 /** Tell the user the dv1394d command set
213 */
214
215 response_codes print_help( command_argument cmd_arg )
216 {
217 int i = 0;
218
219 dv_response_printf( cmd_arg->response, 10240, "%s", helpstr );
220
221 for ( i = 0; vocabulary[ i ].command != NULL; i ++ )
222 dv_response_printf( cmd_arg->response, 1024,
223 "%-10.10s%s\n",
224 vocabulary[ i ].command,
225 vocabulary[ i ].help );
226
227 dv_response_printf( cmd_arg->response, 2, "\n" );
228
229 return RESPONSE_SUCCESS_N;
230 }
231
232 /** Execute a batch file.
233 */
234
235 response_codes dv1394d_run( command_argument cmd_arg )
236 {
237 dv_response temp = dv_parser_run( cmd_arg->parser, (char *)cmd_arg->argument );
238
239 if ( temp != NULL )
240 {
241 int index = 0;
242
243 dv_response_set_error( cmd_arg->response,
244 dv_response_get_error_code( temp ),
245 dv_response_get_error_string( temp ) );
246
247 for ( index = 1; index < dv_response_count( temp ); index ++ )
248 dv_response_printf( cmd_arg->response, 10240, "%s\n", dv_response_get_line( temp, index ) );
249
250 dv_response_close( temp );
251 }
252
253 return dv_response_get_error_code( cmd_arg->response );
254 }
255
256 response_codes dv1394d_shutdown( command_argument cmd_arg )
257 {
258 exit( 0 );
259 return RESPONSE_SUCCESS;
260 }
261
262 /** Processes 'thread' id
263 */
264
265 static pthread_t self;
266
267 /* Signal handler to deal with various shutdown signals. Basically this
268 should clean up and power down the motor. Note that the death of any
269 child thread will kill all thrads. */
270
271 void signal_handler( int sig )
272 {
273 if ( pthread_equal( self, pthread_self( ) ) )
274 {
275
276 #ifdef _GNU_SOURCE
277 dv1394d_log( LOG_DEBUG, "Received %s - shutting down.", strsignal(sig) );
278 #else
279 dv1394d_log( LOG_DEBUG, "Received signal %i - shutting down.", sig );
280 #endif
281
282 exit(EXIT_SUCCESS);
283 }
284 }
285
286 /** Local 'connect' function.
287 */
288
289 static dv_response dv_local_connect( dv_local local )
290 {
291 dv_response response = dv_response_init( );
292
293 self = pthread_self( );
294
295 dv_response_set_error( response, 100, "VTR Ready" );
296
297 signal( SIGHUP, signal_handler );
298 signal( SIGINT, signal_handler );
299 signal( SIGTERM, signal_handler );
300 signal( SIGSTOP, signal_handler );
301 signal( SIGCHLD, SIG_IGN );
302
303 raw1394_reconcile_bus();
304 /* Start the raw1394 service threads for handling bus resets */
305 raw1394_start_service_threads();
306
307 return response;
308 }
309
310 /** Set the error and determine the message associated to this command.
311 */
312
313 void dv_command_set_error( command_argument cmd, response_codes code )
314 {
315 dv_response_set_error( cmd->response, code, get_response_msg( code ) );
316 }
317
318 /** Parse the unit argument.
319 */
320
321 int dv_command_parse_unit( command_argument cmd, int argument )
322 {
323 int unit = -1;
324 char *string = dv_tokeniser_get_string( cmd->tokeniser, argument );
325 if ( string != NULL && ( string[ 0 ] == 'U' || string[ 0 ] == 'u' ) && strlen( string ) > 1 )
326 unit = atoi( string + 1 );
327 return unit;
328 }
329
330 /** Parse a normal argument.
331 */
332
333 void *dv_command_parse_argument( command_argument cmd, int argument, arguments_types type )
334 {
335 void *ret = NULL;
336 char *value = dv_tokeniser_get_string( cmd->tokeniser, argument );
337
338 if ( value != NULL )
339 {
340 switch( type )
341 {
342 case ATYPE_NONE:
343 break;
344
345 case ATYPE_FLOAT:
346 ret = malloc( sizeof( float ) );
347 if ( ret != NULL )
348 *( float * )ret = atof( value );
349 break;
350
351 case ATYPE_STRING:
352 ret = strdup( value );
353 break;
354
355 case ATYPE_INT:
356 ret = malloc( sizeof( int ) );
357 if ( ret != NULL )
358 *( int * )ret = atoi( value );
359 break;
360 }
361 }
362
363 return ret;
364 }
365
366 /** Get the error code - note that we simply the success return.
367 */
368
369 response_codes dv_command_get_error( command_argument cmd )
370 {
371 response_codes ret = dv_response_get_error_code( cmd->response );
372 if ( ret == RESPONSE_SUCCESS_N || ret == RESPONSE_SUCCESS_1 )
373 ret = RESPONSE_SUCCESS;
374 return ret;
375 }
376
377 /** Execute the command.
378 */
379
380 static dv_response dv_local_execute( dv_local local, char *command )
381 {
382 command_argument_t cmd;
383 cmd.parser = local->parser;
384 cmd.response = dv_response_init( );
385 cmd.tokeniser = dv_tokeniser_init( );
386 cmd.command = command;
387 cmd.unit = -1;
388 cmd.argument = NULL;
389 cmd.root_dir = local->root_dir;
390
391 /* Set the default error */
392 dv_command_set_error( &cmd, RESPONSE_UNKNOWN_COMMAND );
393
394 /* Parse the command */
395 if ( dv_tokeniser_parse_new( cmd.tokeniser, command, " " ) > 0 )
396 {
397 int index = 0;
398 char *value = dv_tokeniser_get_string( cmd.tokeniser, 0 );
399 int found = 0;
400
401 /* Strip quotes from all tokens */
402 for ( index = 0; index < dv_tokeniser_count( cmd.tokeniser ); index ++ )
403 dv_util_strip( dv_tokeniser_get_string( cmd.tokeniser, index ), '\"' );
404
405 /* Search the vocabulary array for value */
406 for ( index = 1; !found && vocabulary[ index ].command != NULL; index ++ )
407 if ( ( found = !strcasecmp( vocabulary[ index ].command, value ) ) )
408 break;
409
410 /* If we found something, the handle the args and call the handler. */
411 if ( found )
412 {
413 int position = 1;
414
415 dv_command_set_error( &cmd, RESPONSE_SUCCESS );
416
417 if ( vocabulary[ index ].is_unit )
418 {
419 cmd.unit = dv_command_parse_unit( &cmd, position );
420 if ( cmd.unit == -1 )
421 dv_command_set_error( &cmd, RESPONSE_MISSING_ARG );
422 position ++;
423 }
424
425 if ( dv_command_get_error( &cmd ) == RESPONSE_SUCCESS )
426 {
427 cmd.argument = dv_command_parse_argument( &cmd, position, vocabulary[ index ].type );
428 if ( cmd.argument == NULL && vocabulary[ index ].type != ATYPE_NONE )
429 dv_command_set_error( &cmd, RESPONSE_MISSING_ARG );
430 position ++;
431 }
432
433 if ( dv_command_get_error( &cmd ) == RESPONSE_SUCCESS )
434 {
435 response_codes error = vocabulary[ index ].operation( &cmd );
436 dv_command_set_error( &cmd, error );
437 }
438
439 free( cmd.argument );
440 }
441 }
442
443 dv_tokeniser_close( cmd.tokeniser );
444
445 return cmd.response;
446 }
447
448 /** Close the parser.
449 */
450
451 static void dv_local_close( dv_local local )
452 {
453 raw1394_stop_service_threads();
454 dv1394d_delete_all_units();
455 pthread_kill_other_threads_np();
456 dv1394d_log( LOG_DEBUG, "Clean shutdown." );
457 free( local );
458 dv_clip_factory_close( );
459 dv_frame_pool_close( );
460 }