research.m1stereo.tv/gitweb/ - melted/blob - 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                 int64_t in = -1, out = -1;
  60                 if ( valerie_tokeniser_count( cmd_arg->tokeniser ) == 5 )
  61                 {
  62                         in = atol( valerie_tokeniser_get_string( cmd_arg->tokeniser, 3 ) );
  63                         out = atol( 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                 int64_t in = -1, out = -1;
 211                 if ( valerie_tokeniser_count( cmd_arg->tokeniser ) == 5 )
 212                 {
 213                         in = atol( valerie_tokeniser_get_string( cmd_arg->tokeniser, 3 ) );
 214                         out = atol( 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         {
 253                 miracle_unit_play( unit, 0 );
 254                 miracle_unit_terminate( unit );
 255         }
 256         return RESPONSE_SUCCESS;
 257 }
 258
 259 int miracle_pause( command_argument cmd_arg )
 260 {
 261         miracle_unit unit = miracle_get_unit(cmd_arg->unit);
 262         if ( unit == NULL )
 263                 return RESPONSE_INVALID_UNIT;
 264         else
 265                 miracle_unit_play( unit, 0 );
 266         return RESPONSE_SUCCESS;
 267 }
 268
 269 int miracle_rewind( command_argument cmd_arg )
 270 {
 271         miracle_unit unit = miracle_get_unit(cmd_arg->unit);
 272         if ( unit == NULL )
 273                 return RESPONSE_INVALID_UNIT;
 274         else
 275                 miracle_unit_play( unit, -2000 );
 276         return RESPONSE_SUCCESS;
 277 }
 278
 279 int miracle_step( command_argument cmd_arg )
 280 {
 281         miracle_unit unit = miracle_get_unit(cmd_arg->unit);
 282
 283         if (unit == NULL)
 284                 return RESPONSE_INVALID_UNIT;
 285         else
 286         {
 287                 miracle_unit_play( unit, 0 );
 288                 miracle_unit_step( unit, *(int*) cmd_arg->argument );
 289         }
 290         return RESPONSE_SUCCESS;
 291 }
 292
 293 int miracle_goto( command_argument cmd_arg )
 294 {
 295         miracle_unit unit = miracle_get_unit(cmd_arg->unit);
 296         int clip = parse_clip( cmd_arg, 3 );
 297
 298         if (unit == NULL || miracle_unit_is_offline(unit))
 299                 return RESPONSE_INVALID_UNIT;
 300         else
 301                 miracle_unit_change_position( unit, clip, *(int*) cmd_arg->argument );
 302         return RESPONSE_SUCCESS;
 303 }
 304
 305 int miracle_ff( command_argument cmd_arg )
 306 {
 307         miracle_unit unit = miracle_get_unit(cmd_arg->unit);
 308         if ( unit == NULL )
 309                 return RESPONSE_INVALID_UNIT;
 310         else
 311                 miracle_unit_play( unit, 2000 );
 312         return RESPONSE_SUCCESS;
 313 }
 314
 315 int miracle_set_in_point( command_argument cmd_arg )
 316 {
 317         miracle_unit unit = miracle_get_unit(cmd_arg->unit);
 318         int clip = parse_clip( cmd_arg, 3 );
 319
 320         if ( unit == NULL )
 321                 return RESPONSE_INVALID_UNIT;
 322         else
 323         {
 324                 int position = *(int *) cmd_arg->argument;
 325
 326                 switch( miracle_unit_set_clip_in( unit, clip, position ) )
 327                 {
 328                         case -1:
 329                                 return RESPONSE_BAD_FILE;
 330                         case -2:
 331                                 return RESPONSE_OUT_OF_RANGE;
 332                 }
 333         }
 334         return RESPONSE_SUCCESS;
 335 }
 336
 337 int miracle_set_out_point( command_argument cmd_arg )
 338 {
 339         miracle_unit unit = miracle_get_unit(cmd_arg->unit);
 340         int clip = parse_clip( cmd_arg, 3 );
 341
 342         if ( unit == NULL )
 343                 return RESPONSE_INVALID_UNIT;
 344         else
 345         {
 346                 int position = *(int *) cmd_arg->argument;
 347
 348                 switch( miracle_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         miracle_unit unit = miracle_get_unit(cmd_arg->unit);
 380         char *name_value = (char*) cmd_arg->argument;
 381         if (unit == NULL)
 382                 return RESPONSE_INVALID_UNIT;
 383         else
 384                 miracle_unit_set( unit, name_value );
 385         return RESPONSE_SUCCESS;
 386 }
 387
 388 int miracle_get_unit_property( command_argument cmd_arg )
 389 {
 390         miracle_unit unit = miracle_get_unit(cmd_arg->unit);
 391         char *name = (char*) cmd_arg->argument;
 392         char *value = miracle_unit_get( unit, name );
 393         if (unit == NULL)
 394                 return RESPONSE_INVALID_UNIT;
 395         else if ( value != NULL )
 396                 valerie_response_printf( cmd_arg->response, 1024, "%s\n", value );
 397         return RESPONSE_SUCCESS;
 398 }
 399
 400
 401 int miracle_transfer( command_argument cmd_arg )
 402 {
 403         miracle_unit src_unit = miracle_get_unit(cmd_arg->unit);
 404         int dest_unit_id = -1;
 405         char *string = (char*) cmd_arg->argument;
 406         if ( string != NULL && ( string[ 0 ] == 'U' || string[ 0 ] == 'u' ) && strlen( string ) > 1 )
 407                 dest_unit_id = atoi( string + 1 );
 408
 409         if ( src_unit != NULL && dest_unit_id != -1 )
 410         {
 411                 miracle_unit dest_unit = miracle_get_unit( dest_unit_id );
 412                 if ( dest_unit != NULL && !miracle_unit_is_offline(dest_unit) && dest_unit != src_unit )
 413                 {
 414                         miracle_unit_transfer( dest_unit, src_unit );
 415                         return RESPONSE_SUCCESS;
 416                 }
 417         }
 418         return RESPONSE_INVALID_UNIT;
 419 }