projects / melted / blob
? search:


c85aff05b75c77f208c4d0e78f3943f323707e7e
[melted] / src / miracle / miracle_unit_commands.c
1 /*
2 * unit_commands.c
3 * Copyright (C) 2002-2003 Ushodaya Enterprises Limited
4 * Author: Dan Dennedy <dan@dennedy.org>
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 #include <sys/types.h>
26 #include <sys/stat.h>
27 #include <fcntl.h>
28 #include <unistd.h>
29 #include <string.h>
30 #include <stdlib.h>
31 #include <stdio.h>
32
33 #include "miracle_unit.h"
34 #include "miracle_commands.h"
35 #include "miracle_log.h"
36
37 int miracle_load( command_argument cmd_arg )
38 {
39 miracle_unit unit = miracle_get_unit(cmd_arg->unit);
40 char *filename = (char*) cmd_arg->argument;
41 char fullname[1024];
42 int flush = 1;
43
44 if ( filename[0] == '!' )
45 {
46 flush = 0;
47 filename ++;
48 }
49
50 if ( filename[0] == '/' )
51 filename++;
52
53 snprintf( fullname, 1023, "%s%s", cmd_arg->root_dir, filename );
54
55 if (unit == NULL)
56 return RESPONSE_INVALID_UNIT;
57 else
58 {
59 double in = -1, out = -1;
60 if ( valerie_tokeniser_count( cmd_arg->tokeniser ) == 5 )
61 {
62 in = atof( valerie_tokeniser_get_string( cmd_arg->tokeniser, 3 ) );
63 out = atof( valerie_tokeniser_get_string( cmd_arg->tokeniser, 4 ) );
64 }
65 if ( miracle_unit_load( unit, fullname, in, out, flush ) != valerie_ok )
66 return RESPONSE_BAD_FILE;
67 }
68 return RESPONSE_SUCCESS;
69 }
70
71 int miracle_list( command_argument cmd_arg )
72 {
73 miracle_unit unit = miracle_get_unit( cmd_arg->unit );
74
75 if ( unit != NULL )
76 {
77 miracle_unit_report_list( unit, cmd_arg->response );
78 return RESPONSE_SUCCESS;
79 }
80
81 return RESPONSE_INVALID_UNIT;
82 }
83
84 static int parse_clip( command_argument cmd_arg, int arg )
85 {
86 miracle_unit unit = miracle_get_unit(cmd_arg->unit);
87 int clip = miracle_unit_get_current_clip( unit );
88
89 if ( valerie_tokeniser_count( cmd_arg->tokeniser ) > arg )
90 {
91 char *token = valerie_tokeniser_get_string( cmd_arg->tokeniser, arg );
92 if ( token[ 0 ] == '+' )
93 clip += atoi( token + 1 );
94 else if ( token[ 0 ] == '-' )
95 clip -= atoi( token + 1 );
96 else
97 clip = atoi( token );
98 }
99
100 return clip;
101 }
102
103 int miracle_insert( command_argument cmd_arg )
104 {
105 miracle_unit unit = miracle_get_unit(cmd_arg->unit);
106 char *filename = (char*) cmd_arg->argument;
107 char fullname[1024];
108
109 if ( filename[0] == '/' )
110 filename++;
111
112 snprintf( fullname, 1023, "%s%s", cmd_arg->root_dir, filename );
113
114 if (unit == NULL)
115 return RESPONSE_INVALID_UNIT;
116 else
117 {
118 long in = -1, out = -1;
119 int index = parse_clip( cmd_arg, 3 );
120
121 if ( valerie_tokeniser_count( cmd_arg->tokeniser ) == 6 )
122 {
123 in = atoi( valerie_tokeniser_get_string( cmd_arg->tokeniser, 4 ) );
124 out = atoi( valerie_tokeniser_get_string( cmd_arg->tokeniser, 5 ) );
125 }
126
127 switch( miracle_unit_insert( unit, fullname, index, in, out ) )
128 {
129 case valerie_ok:
130 return RESPONSE_SUCCESS;
131 default:
132 return RESPONSE_BAD_FILE;
133 }
134 }
135 return RESPONSE_SUCCESS;
136 }
137
138 int miracle_remove( command_argument cmd_arg )
139 {
140 miracle_unit unit = miracle_get_unit(cmd_arg->unit);
141
142 if (unit == NULL)
143 return RESPONSE_INVALID_UNIT;
144 else
145 {
146 int index = parse_clip( cmd_arg, 2 );
147
148 if ( miracle_unit_remove( unit, index ) != valerie_ok )
149 return RESPONSE_BAD_FILE;
150 }
151 return RESPONSE_SUCCESS;
152 }
153
154 int miracle_clean( command_argument cmd_arg )
155 {
156 miracle_unit unit = miracle_get_unit(cmd_arg->unit);
157
158 if (unit == NULL)
159 return RESPONSE_INVALID_UNIT;
160 else
161 {
162 if ( miracle_unit_clean( unit ) != valerie_ok )
163 return RESPONSE_BAD_FILE;
164 }
165 return RESPONSE_SUCCESS;
166 }
167
168 int miracle_move( command_argument cmd_arg )
169 {
170 miracle_unit unit = miracle_get_unit(cmd_arg->unit);
171
172 if ( unit != NULL )
173 {
174 if ( valerie_tokeniser_count( cmd_arg->tokeniser ) > 2 )
175 {
176 int src = parse_clip( cmd_arg, 2 );
177 int dest = parse_clip( cmd_arg, 3 );
178
179 if ( miracle_unit_move( unit, src, dest ) != valerie_ok )
180 return RESPONSE_BAD_FILE;
181 }
182 else
183 {
184 return RESPONSE_MISSING_ARG;
185 }
186 }
187 else
188 {
189 return RESPONSE_INVALID_UNIT;
190 }
191
192 return RESPONSE_SUCCESS;
193 }
194
195 int miracle_append( command_argument cmd_arg )
196 {
197 miracle_unit unit = miracle_get_unit(cmd_arg->unit);
198 char *filename = (char*) cmd_arg->argument;
199 char fullname[1024];
200
201 if ( filename[0] == '/' )
202 filename++;
203
204 snprintf( fullname, 1023, "%s%s", cmd_arg->root_dir, filename );
205
206 if (unit == NULL)
207 return RESPONSE_INVALID_UNIT;
208 else
209 {
210 double in = -1, out = -1;
211 if ( valerie_tokeniser_count( cmd_arg->tokeniser ) == 5 )
212 {
213 in = atof( valerie_tokeniser_get_string( cmd_arg->tokeniser, 3 ) );
214 out = atof( valerie_tokeniser_get_string( cmd_arg->tokeniser, 4 ) );
215 }
216 switch ( miracle_unit_append( unit, fullname, in, out ) )
217 {
218 case valerie_ok:
219 return RESPONSE_SUCCESS;
220 default:
221 return RESPONSE_BAD_FILE;
222 }
223 }
224 return RESPONSE_SUCCESS;
225 }
226
227 int miracle_play( command_argument cmd_arg )
228 {
229 miracle_unit unit = miracle_get_unit(cmd_arg->unit);
230
231 if ( unit == NULL )
232 {
233 return RESPONSE_INVALID_UNIT;
234 }
235 else
236 {
237 int speed = 1000;
238 if ( valerie_tokeniser_count( cmd_arg->tokeniser ) == 3 )
239 speed = atoi( valerie_tokeniser_get_string( cmd_arg->tokeniser, 2 ) );
240 miracle_unit_play( unit, speed );
241 }
242
243 return RESPONSE_SUCCESS;
244 }
245
246 int miracle_stop( command_argument cmd_arg )
247 {
248 miracle_unit unit = miracle_get_unit(cmd_arg->unit);
249 if ( unit == NULL )
250 return RESPONSE_INVALID_UNIT;
251 else
252 miracle_unit_play( unit, 0 );
253 return RESPONSE_SUCCESS;
254 }
255
256 int miracle_pause( command_argument cmd_arg )
257 {
258 miracle_unit unit = miracle_get_unit(cmd_arg->unit);
259 if ( unit == NULL )
260 return RESPONSE_INVALID_UNIT;
261 else
262 miracle_unit_play( unit, 0 );
263 return RESPONSE_SUCCESS;
264 }
265
266 int miracle_rewind( command_argument cmd_arg )
267 {
268 miracle_unit unit = miracle_get_unit(cmd_arg->unit);
269 if ( unit == NULL )
270 return RESPONSE_INVALID_UNIT;
271 else
272 miracle_unit_play( unit, -2000 );
273 return RESPONSE_SUCCESS;
274 }
275
276 int miracle_step( command_argument cmd_arg )
277 {
278 miracle_unit unit = miracle_get_unit(cmd_arg->unit);
279
280 if (unit == NULL)
281 return RESPONSE_INVALID_UNIT;
282 else
283 {
284 miracle_unit_play( unit, 0 );
285 miracle_unit_step( unit, *(int*) cmd_arg->argument );
286 }
287 return RESPONSE_SUCCESS;
288 }
289
290 int miracle_goto( command_argument cmd_arg )
291 {
292 miracle_unit unit = miracle_get_unit(cmd_arg->unit);
293 int clip = parse_clip( cmd_arg, 3 );
294
295 if (unit == NULL || miracle_unit_is_offline(unit))
296 return RESPONSE_INVALID_UNIT;
297 else
298 miracle_unit_change_position( unit, clip, *(int*) cmd_arg->argument );
299 return RESPONSE_SUCCESS;
300 }
301
302 int miracle_ff( command_argument cmd_arg )
303 {
304 miracle_unit unit = miracle_get_unit(cmd_arg->unit);
305 if ( unit == NULL )
306 return RESPONSE_INVALID_UNIT;
307 else
308 miracle_unit_play( unit, 2000 );
309 return RESPONSE_SUCCESS;
310 }
311
312 int miracle_set_in_point( command_argument cmd_arg )
313 {
314 /*
315 dv_unit unit = miracle_get_unit(cmd_arg->unit);
316 int clip = parse_clip( cmd_arg, 3 );
317
318 if (unit == NULL || dv_unit_is_offline(unit))
319 return RESPONSE_INVALID_UNIT;
320 else
321 {
322 int position = *(int *) cmd_arg->argument;
323
324 switch( dv_unit_set_clip_in( unit, clip, position ) )
325 {
326 case -1:
327 return RESPONSE_BAD_FILE;
328 case -2:
329 return RESPONSE_OUT_OF_RANGE;
330 }
331 }
332 */
333 return RESPONSE_SUCCESS;
334 }
335
336 int miracle_set_out_point( command_argument cmd_arg )
337 {
338 /*
339 dv_unit unit = miracle_get_unit(cmd_arg->unit);
340 int clip = parse_clip( cmd_arg, 3 );
341
342 if (unit == NULL || dv_unit_is_offline(unit))
343 return RESPONSE_INVALID_UNIT;
344 else
345 {
346 int position = *(int *) cmd_arg->argument;
347
348 switch( dv_unit_set_clip_out( unit, clip, position ) )
349 {
350 case -1:
351 return RESPONSE_BAD_FILE;
352 case -2:
353 return RESPONSE_OUT_OF_RANGE;
354 }
355 }
356 */
357 return RESPONSE_SUCCESS;
358 }
359
360 int miracle_get_unit_status( command_argument cmd_arg )
361 {
362 valerie_status_t status;
363 int error = miracle_unit_get_status( miracle_get_unit( cmd_arg->unit ), &status );
364
365 if ( error == -1 )
366 return RESPONSE_INVALID_UNIT;
367 else
368 {
369 char text[ 10240 ];
370 valerie_response_printf( cmd_arg->response, sizeof( text ), valerie_status_serialise( &status, text, sizeof( text ) ) );
371 return RESPONSE_SUCCESS_1;
372 }
373 return 0;
374 }
375
376
377 int miracle_set_unit_property( command_argument cmd_arg )
378 {
379 /*
380 dv_unit unit = miracle_get_unit(cmd_arg->unit);
381
382 if (unit == NULL)
383 return RESPONSE_INVALID_UNIT;
384 else
385 {
386 char *key = (char*) cmd_arg->argument;
387 char *value = NULL;
388
389 value = strchr( key, '=' );
390 if (value == NULL)
391 return RESPONSE_OUT_OF_RANGE;
392 value[0] = 0;
393 value++;
394 miracle_log( LOG_DEBUG, "USET %s = %s", key, value );
395 if ( strncasecmp( key, "eof", 1024) == 0 )
396 {
397 if ( strncasecmp( value, "pause", 1024) == 0)
398 dv_unit_set_eof_action( unit, dv_player_pause );
399 else if ( strncasecmp( value, "loop", 1024) == 0)
400 dv_unit_set_eof_action( unit, dv_player_loop );
401 else if ( strncasecmp( value, "stop", 1024) == 0)
402 dv_unit_set_eof_action( unit, dv_player_terminate );
403 else if ( strncasecmp( value, "clean", 1024) == 0)
404 dv_unit_set_eof_action( unit, dv_player_clean_loop );
405 else
406 return RESPONSE_OUT_OF_RANGE;
407 }
408 else if ( strncasecmp( key, "points", 1024) == 0 )
409 {
410 if ( strncasecmp( value, "use", 1024) == 0)
411 dv_unit_set_mode( unit, dv_clip_mode_restricted );
412 else if ( strncasecmp( value, "ignore", 1024) == 0)
413 dv_unit_set_mode( unit, dv_clip_mode_unrestricted );
414 else
415 return RESPONSE_OUT_OF_RANGE;
416 }
417 else if ( strncasecmp( key, "syt_offset", 1024) == 0 )
418 {
419 dv_unit_set_syt_offset( unit, atoi( value ) );
420 }
421 else if ( strncasecmp( key, "cip_n", 1024) == 0 )
422 {
423 dv_unit_set_cip_n( unit, atoi( value ) );
424 }
425 else if ( strncasecmp( key, "cip_d", 1024) == 0 )
426 {
427 dv_unit_set_cip_d( unit, atoi( value ) );
428 }
429 else if ( strncasecmp( key, "size", 1024) == 0 )
430 {
431 dv_unit_set_buffer_size( unit, atoi( value ) );
432 }
433 else if ( strncasecmp( key, "n_frames", 1024) == 0 )
434 {
435 dv_unit_set_n_frames( unit, atoi( value ) );
436 }
437 else if ( strncasecmp( key, "n_fill", 1024) == 0 )
438 {
439 dv_unit_set_n_fill( unit, atoi( value ) );
440 }
441 else
442 return RESPONSE_OUT_OF_RANGE;
443 }
444 */
445 return RESPONSE_SUCCESS;
446 }
447
448 int miracle_get_unit_property( command_argument cmd_arg )
449 {
450 /*
451 dv_unit unit = miracle_get_unit(cmd_arg->unit);
452
453 if (unit == NULL)
454 return RESPONSE_INVALID_UNIT;
455 else
456 {
457 char *key = (char*) cmd_arg->argument;
458
459 if ( strncasecmp( key, "eof", 1024) == 0 )
460 {
461 switch ( dv_unit_get_eof_action( unit ) )
462 {
463 case dv_player_pause:
464 dv_response_write( cmd_arg->response, "pause", strlen("pause") );
465 break;
466 case dv_player_loop:
467 dv_response_write( cmd_arg->response, "loop", strlen("loop") );
468 break;
469 case dv_player_terminate:
470 dv_response_write( cmd_arg->response, "stop", strlen("stop") );
471 break;
472 case dv_player_clean_loop:
473 dv_response_write( cmd_arg->response, "clean", strlen("clean") );
474 break;
475 }
476 return RESPONSE_SUCCESS_1;
477 }
478 else if ( strncasecmp( key, "points", 1024) == 0 )
479 {
480 if ( dv_unit_get_mode( unit ) == dv_clip_mode_restricted )
481 dv_response_write( cmd_arg->response, "use", strlen("use") );
482 else
483 dv_response_write( cmd_arg->response, "ignore", strlen("ignore") );
484 return RESPONSE_SUCCESS_1;
485 }
486 else if ( strncasecmp( key, "syt_offset", 1024) == 0 )
487 {
488 dv_response_printf( cmd_arg->response, 1024, "%d\n",
489 dv_unit_get_syt_offset( unit ) );
490 return RESPONSE_SUCCESS_1;
491 }
492 else if ( strncasecmp( key, "cip_n", 1024) == 0 )
493 {
494 dv_response_printf( cmd_arg->response, 1024, "%d\n",
495 dv_unit_get_cip_n( unit ) );
496 return RESPONSE_SUCCESS_1;
497 }
498 else if ( strncasecmp( key, "cip_d", 1024) == 0 )
499 {
500 dv_response_printf( cmd_arg->response, 1024, "%d\n",
501 dv_unit_get_cip_d( unit ) );
502 return RESPONSE_SUCCESS_1;
503 }
504 else if ( strncasecmp( key, "size", 1024) == 0 )
505 {
506 dv_response_printf( cmd_arg->response, 1024, "%d\n",
507 dv_unit_get_buffer_size( unit ) );
508 return RESPONSE_SUCCESS_1;
509 }
510 else if ( strncasecmp( key, "n_frames", 1024) == 0 )
511 {
512 dv_response_printf( cmd_arg->response, 1024, "%d\n",
513 dv_unit_get_n_frames( unit ) );
514 return RESPONSE_SUCCESS_1;
515 }
516 else if ( strncasecmp( key, "n_fill", 1024) == 0 )
517 {
518 dv_response_printf( cmd_arg->response, 1024, "%d\n",
519 dv_unit_get_n_fill( unit ) );
520 return RESPONSE_SUCCESS_1;
521 }
522 else if ( strncasecmp( key, "all", 1024 ) == 0 )
523 {
524 switch ( dv_unit_get_eof_action( unit ) )
525 {
526 case dv_player_pause:
527 dv_response_write( cmd_arg->response, "eof=pause\n", strlen("pause") );
528 break;
529 case dv_player_loop:
530 dv_response_write( cmd_arg->response, "eof=loop\n", strlen("loop") );
531 break;
532 case dv_player_terminate:
533 dv_response_write( cmd_arg->response, "eof=stop\n", strlen("stop") );
534 break;
535 case dv_player_clean_loop:
536 dv_response_write( cmd_arg->response, "eof=clean\n", strlen("clean") );
537 break;
538 }
539 if ( dv_unit_get_mode( unit ) == dv_clip_mode_restricted )
540 dv_response_write( cmd_arg->response, "points=use\n", strlen("use") );
541 else
542 dv_response_write( cmd_arg->response, "points=ignore\n", strlen("ignore") );
543 dv_response_printf( cmd_arg->response, 1024, "syt_offset=%d\n", dv_unit_get_syt_offset( unit ) );
544 dv_response_printf( cmd_arg->response, 1024, "cip_n=%d\n", dv_unit_get_cip_n( unit ) );
545 dv_response_printf( cmd_arg->response, 1024, "cip_d=%d\n", dv_unit_get_cip_d( unit ) );
546 dv_response_printf( cmd_arg->response, 1024, "size=%d\n", dv_unit_get_buffer_size( unit ) );
547 dv_response_printf( cmd_arg->response, 1024, "n_frames=%d\n", dv_unit_get_n_frames( unit ) );
548 dv_response_printf( cmd_arg->response, 1024, "n_fill=%d\n", dv_unit_get_n_fill( unit ) );
549 }
550 }
551 */
552 return RESPONSE_SUCCESS;
553 }
554
555
556 int miracle_transfer( command_argument cmd_arg )
557 {
558 /*
559 dv_unit src_unit = miracle_get_unit(cmd_arg->unit);
560 int dest_unit_id = -1;
561 char *string = (char*) cmd_arg->argument;
562 if ( string != NULL && ( string[ 0 ] == 'U' || string[ 0 ] == 'u' ) && strlen( string ) > 1 )
563 dest_unit_id = atoi( string + 1 );
564
565 if ( src_unit != NULL && dest_unit_id != -1 )
566 {
567 dv_unit dest_unit = miracle_get_unit( dest_unit_id );
568 if ( dest_unit != NULL && !dv_unit_is_offline(dest_unit) && dest_unit != src_unit )
569 {
570 dv_unit_transfer( dest_unit, src_unit );
571 return RESPONSE_SUCCESS;
572 }
573 }
574 */
575 return RESPONSE_INVALID_UNIT;
576 }
my melted branch