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 ( strlen( cmd_arg->root_dir ) && 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                 int32_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                 int32_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                 miracle_unit_terminate( unit );
 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         miracle_unit unit = miracle_get_unit(cmd_arg->unit);
 315         int clip = parse_clip( cmd_arg, 3 );
 316
 317         if ( unit == NULL )
 318                 return RESPONSE_INVALID_UNIT;
 319         else
 320         {
 321                 int position = *(int *) cmd_arg->argument;
 322
 323                 switch( miracle_unit_set_clip_in( unit, clip, position ) )
 324                 {
 325                         case -1:
 326                                 return RESPONSE_BAD_FILE;
 327                         case -2:
 328                                 return RESPONSE_OUT_OF_RANGE;
 329                 }
 330         }
 331         return RESPONSE_SUCCESS;
 332 }
 333
 334 int miracle_set_out_point( command_argument cmd_arg )
 335 {
 336         miracle_unit unit = miracle_get_unit(cmd_arg->unit);
 337         int clip = parse_clip( cmd_arg, 3 );
 338
 339         if ( unit == NULL )
 340                 return RESPONSE_INVALID_UNIT;
 341         else
 342         {
 343                 int position = *(int *) cmd_arg->argument;
 344
 345                 switch( miracle_unit_set_clip_out( unit, clip, position ) )
 346                 {
 347                         case -1:
 348                                 return RESPONSE_BAD_FILE;
 349                         case -2:
 350                                 return RESPONSE_OUT_OF_RANGE;
 351                 }
 352         }
 353
 354         return RESPONSE_SUCCESS;
 355 }
 356
 357 int miracle_get_unit_status( command_argument cmd_arg )
 358 {
 359         valerie_status_t status;
 360         int error = miracle_unit_get_status( miracle_get_unit( cmd_arg->unit ), &status );
 361
 362         if ( error == -1 )
 363                 return RESPONSE_INVALID_UNIT;
 364         else
 365         {
 366                 char text[ 10240 ];
 367                 valerie_response_printf( cmd_arg->response, sizeof( text ), valerie_status_serialise( &status, text, sizeof( text ) ) );
 368                 return RESPONSE_SUCCESS_1;
 369         }
 370         return 0;
 371 }
 372
 373
 374 int miracle_set_unit_property( command_argument cmd_arg )
 375 {
 376         miracle_unit unit = miracle_get_unit(cmd_arg->unit);
 377         char *name_value = (char*) cmd_arg->argument;
 378         if (unit == NULL)
 379                 return RESPONSE_INVALID_UNIT;
 380         else
 381                 miracle_unit_set( unit, name_value );
 382         return RESPONSE_SUCCESS;
 383 }
 384
 385 int miracle_get_unit_property( command_argument cmd_arg )
 386 {
 387         miracle_unit unit = miracle_get_unit(cmd_arg->unit);
 388         char *name = (char*) cmd_arg->argument;
 389         char *value = miracle_unit_get( unit, name );
 390         if (unit == NULL)
 391                 return RESPONSE_INVALID_UNIT;
 392         else if ( value != NULL )
 393                 valerie_response_printf( cmd_arg->response, 1024, "%s\n", value );
 394         return RESPONSE_SUCCESS;
 395 }
 396
 397
 398 int miracle_transfer( command_argument cmd_arg )
 399 {
 400         miracle_unit src_unit = miracle_get_unit(cmd_arg->unit);
 401         int dest_unit_id = -1;
 402         char *string = (char*) cmd_arg->argument;
 403         if ( string != NULL && ( string[ 0 ] == 'U' || string[ 0 ] == 'u' ) && strlen( string ) > 1 )
 404                 dest_unit_id = atoi( string + 1 );
 405
 406         if ( src_unit != NULL && dest_unit_id != -1 )
 407         {
 408                 miracle_unit dest_unit = miracle_get_unit( dest_unit_id );
 409                 if ( dest_unit != NULL && !miracle_unit_is_offline(dest_unit) && dest_unit != src_unit )
 410                 {
 411                         miracle_unit_transfer( dest_unit, src_unit );
 412                         return RESPONSE_SUCCESS;
 413                 }
 414         }
 415         return RESPONSE_INVALID_UNIT;
 416 }