← Back to branch summary

~ubuntu-branches/ubuntu/raring/ecasound2.2/raring

« back to all changes in this revision

Viewing changes to libecasound/eca-control.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Junichi Uekawa
  • Date: 2009-05-06 15:18:46 UTC
  • mfrom: (5.1.1 squeeze)
  • Revision ID: james.westby@ubuntu.com-20090506151846-dvp8mirqmxwhve66
Tags: 2.6.0-1
http://bugs.debian.org/526535
* New upstream release
- 08_fix_header_install: remove
- 07_configure_in_maintainer_mode: update
- do not install manpage copies, and just install symlinks for
  ecatools.1
* Build-Depend on texlive-latex-recommended too for ecrm1000 font.
  (closes: #526535)

Show diffs side-by-side

added added

removed removed

Lines of Context:
libecasound/eca-control.cpp
56
56
#include "audiofx_ladspa.h"
57
57
#include "preset.h"
58
58
#include "sample-specs.h"
 
59
#include "jack-connections.h"
59
60
 
60
61
#include "eca-version.h"
61
62
#include "eca-error.h"
93
94
  ECA_LOG_MSG(ECA_LOGGER::system_objects, "ECA_CONTROL destructor");
94
95
}
95
96
 
96
 
void ECA_CONTROL::command(const string& cmd)
 
97
void ECA_CONTROL::command(const string& cmd_and_args)
97
98
{
98
99
  clear_last_values();
99
100
  clear_action_arguments();
100
101
 
101
 
  ECA_LOG_MSG(ECA_LOGGER::user_objects, "command: " + cmd);
102
 
 
103
 
  vector<string> cmds = kvu_string_to_tokens_quoted(cmd);
104
 
  vector<string>::iterator p = cmds.begin();
105
 
  if (p != cmds.end()) {
106
 
 
 
102
  ECA_LOG_MSG(ECA_LOGGER::user_objects, "processing cmd and arg: " + cmd_and_args);
 
103
 
 
104
  vector<string> tokens = kvu_string_to_tokens_quoted(cmd_and_args);
 
105
  vector<string>::iterator cmd = tokens.begin();
 
106
  if (cmd != tokens.end()) {
107
107
    const std::map<std::string,int>& cmdmap = ECA_IAMODE_PARSER::registered_commands();
108
 
    if (cmdmap.find(*p) == cmdmap.end()) {
 
108
    if (cmdmap.find(*cmd) == cmdmap.end()) {
109
109
      // ---
110
110
      // *p is not recognized as a iamode command
111
111
      // ---
112
 
      if (p->size() > 0 && (*p)[0] == '-') {
 
112
      if (cmd->size() > 0 && (*cmd)[0] == '-') {
113
113
        //  std::cerr << "Note! Direct use of EOS-options (-prefix:arg1,...,argN)" << " as iactive-mode commands is considered deprecated. " << "\tUse the notation 'cs-option -prefix:a,b,x' instead." << std::endl;
114
 
        if (*p == "-i")
 
114
        if (*cmd == "-i")
115
115
          ECA_LOG_MSG(ECA_LOGGER::info, 
116
116
                      "WARNING: syntax variant '-i file.ext' not supported, please use 'ai-add file.ext' instead.");
117
 
        else if (*p == "-o")
 
117
        else if (*cmd == "-o")
118
118
          ECA_LOG_MSG(ECA_LOGGER::info, 
119
119
                      "WARNING: syntax variant '-o file.ext' not supported, please use 'ai-add file.ext' instead.");
120
 
        else
121
 
          chainsetup_option(cmd);
 
120
        else {
 
121
          ECA_LOG_MSG(ECA_LOGGER::user_objects, "passiong to cs-option: " + cmd_and_args);
 
122
          chainsetup_option(cmd_and_args);
 
123
        }
122
124
      }
123
125
      else {
124
126
        set_last_error("Unknown command!");
125
127
      }
126
128
    }
127
129
    else {
128
 
      int action_id = ECA_IAMODE_PARSER::command_to_action_id(*p);
 
130
      int action_id = ECA_IAMODE_PARSER::command_to_action_id(*cmd);
129
131
      if (action_id == ec_help) {
130
132
        show_controller_help();
131
133
      }
132
134
      else {
133
 
        string first = *p;
134
 
        ++p;
135
 
        if (p != cmds.end()) {
136
 
          set_action_argument(kvu_vector_to_string(vector<string> (p, cmds.end()), " "));
 
135
        vector<string>::iterator args = cmd + 1;
 
136
        if (args != tokens.end()) {
 
137
          set_action_argument(vector<string> (args, tokens.end()));
137
138
        }
138
139
        action(action_id);
139
140
      }
143
144
 
144
145
void ECA_CONTROL::set_action_argument(const string& s)
145
146
{
 
147
  action_args_rep.resize(0);
 
148
  action_args_rep.push_back(s);
 
149
  action_arg_f_set_rep = false;
 
150
}
 
151
 
 
152
void ECA_CONTROL::set_action_argument(const std::vector<std::string>& s)
 
153
{
146
154
  action_args_rep = s;
147
155
  action_arg_f_set_rep = false;
148
156
}
168
176
{
169
177
  if (action_arg_f_set_rep == true)
170
178
    return action_arg_f_rep;
171
 
 
172
 
  return atof(action_args_rep.c_str());
 
179
  
 
180
  if (action_args_rep.size() == 0)
 
181
    return 0.0f;
 
182
 
 
183
  return atof(action_args_rep[0].c_str());
 
184
}
 
185
 
 
186
string ECA_CONTROL::first_action_argument_as_string(void) const
 
187
{
 
188
  if (action_args_rep.size() == 0)
 
189
    return std::string();
 
190
 
 
191
  return action_args_rep[0];
 
192
}
 
193
 
 
194
const vector<string>& ECA_CONTROL::action_arguments_as_vector(void) const
 
195
{
 
196
  return action_args_rep;
 
197
}
 
198
 
 
199
int ECA_CONTROL::first_action_argument_as_int(void) const
 
200
{
 
201
  if (action_args_rep.size() == 0)
 
202
    return 0;
 
203
 
 
204
  return atoi(action_args_rep[0].c_str());
173
205
}
174
206
 
175
207
long int ECA_CONTROL::first_action_argument_as_long_int(void) const
176
208
{
177
 
  return atol(action_args_rep.c_str());
 
209
  if (action_args_rep.size() == 0)
 
210
    return 0;
 
211
 
 
212
  return atol(action_args_rep[0].c_str());
178
213
}
179
214
 
180
215
SAMPLE_SPECS::sample_pos_t ECA_CONTROL::first_action_argument_as_samples(void) const
181
216
{
 
217
  if (action_args_rep.size() == 0)
 
218
    return 0;
 
219
 
182
220
#ifdef HAVE_ATOLL
183
 
  return atoll(action_args_rep.c_str());
 
221
  return atoll(action_args_rep[0].c_str());
184
222
#else
185
 
  return atol(action_args_rep.c_str());
 
223
  return atol(action_args_rep[0].c_str());
186
224
#endif
187
225
}
188
226
 
239
277
 
240
278
  /* case 1: action requiring arguments, but not arguments available */
241
279
  if (action_arg_f_set_rep == false && 
242
 
      action_args_rep.size() == 0 &&
 
280
      first_action_argument_as_string().size() == 0 &&
243
281
      action_requires_params(action_id)) {
244
282
    set_last_error("Can't perform requested action; argument omitted.");
245
283
    action_ok = false;
345
383
    }
346
384
  case ec_debug:
347
385
    {
348
 
      int level = atoi(action_args_rep.c_str());
 
386
      int level = first_action_argument_as_int();
349
387
      ECA_LOGGER::instance().set_log_level_bitmask(level);
350
388
      set_last_string("Debug level set to " + kvu_numtostr(level) + ".");
351
389
      break;
352
390
    }
353
391
  case ec_resource_file:
354
392
    {
355
 
      session_repp->interpret_general_option(string("-R:") + action_args_rep);
 
393
      session_repp->interpret_general_option(string("-R:") + 
 
394
                                             first_action_argument_as_string());
356
395
      break;
357
396
    }
358
397
 
361
400
    // ---
362
401
  case ec_cs_add:
363
402
    {
364
 
      add_chainsetup(action_args_rep);
 
403
      add_chainsetup(first_action_argument_as_string());
365
404
      break;
366
405
    }
367
406
  case ec_cs_remove: { remove_chainsetup(); break; }
368
407
  case ec_cs_list: { set_last_string_list(chainsetup_names()); break; }
369
 
  case ec_cs_select: { select_chainsetup(action_args_rep); break; }
 
408
  case ec_cs_select: { select_chainsetup(first_action_argument_as_string()); break; }
370
409
  case ec_cs_selected: { set_last_string(selected_chainsetup()); break; }
371
410
  case ec_cs_index_select: { 
372
 
    if (action_args_rep.size() > 0) {
373
 
      select_chainsetup_by_index(atoi(action_args_rep.c_str()));
 
411
    if (first_action_argument_as_string().size() > 0) {
 
412
      select_chainsetup_by_index(first_action_argument_as_int());
374
413
    }
375
414
    break; 
376
415
  }
377
416
  case ec_cs_edit: { edit_chainsetup(); break; }
378
 
  case ec_cs_load: { load_chainsetup(action_args_rep); break; }
 
417
  case ec_cs_load: { load_chainsetup(first_action_argument_as_string()); break; }
379
418
  case ec_cs_save: { save_chainsetup(""); break; }
380
 
  case ec_cs_save_as: { save_chainsetup(action_args_rep); break; }
 
419
  case ec_cs_save_as: { save_chainsetup(first_action_argument_as_string()); break; }
381
420
  case ec_cs_is_valid: { 
382
421
    if (is_valid() == true) 
383
422
      set_last_integer(1);
397
436
    }
398
437
  case ec_cs_connected: { set_last_string(connected_chainsetup()); break; }
399
438
  case ec_cs_disconnect: { disconnect_chainsetup(); break; }
400
 
  case ec_cs_set_param: { set_chainsetup_parameter(action_args_rep); break; }
401
 
  case ec_cs_set_audio_format: { set_chainsetup_sample_format(action_args_rep); break; }
 
439
  case ec_cs_set_param: { set_chainsetup_parameter(first_action_argument_as_string()); break; }
 
440
  case ec_cs_set_audio_format: { set_chainsetup_sample_format(first_action_argument_as_string()); break; }
402
441
  case ec_cs_status: { 
403
442
    set_last_string(chainsetup_status()); 
404
443
    break; 
424
463
  case ec_cs_toggle_loop: { toggle_chainsetup_looping(); break; } 
425
464
  case ec_cs_option: 
426
465
    {
427
 
      vector<string> temp = kvu_string_to_tokens_quoted(action_args_rep);
428
 
      selected_chainsetup_repp->interpret_options(temp);
 
466
      selected_chainsetup_repp->interpret_options(action_arguments_as_vector());
429
467
      if (selected_chainsetup_repp->interpret_result() != true) {
430
468
        set_last_error(selected_chainsetup_repp->interpret_result_verbose());
431
469
      }
435
473
  // ---
436
474
  // Chains
437
475
  // ---
438
 
  case ec_c_add: { add_chains(kvu_string_to_vector(action_args_rep, ',')); break; }
 
476
  case ec_c_add: { add_chains(kvu_string_to_vector(first_action_argument_as_string(), ',')); break; }
439
477
  case ec_c_remove: { remove_chains(); break; }
440
478
  case ec_c_list: { set_last_string_list(chain_names()); break; }
441
 
  case ec_c_select: { select_chains(kvu_string_to_vector(action_args_rep, ',')); break; }
 
479
  case ec_c_select: { select_chains(kvu_string_to_vector(first_action_argument_as_string(), ',')); break; }
442
480
  case ec_c_selected: { set_last_string_list(selected_chains()); break; }
443
 
  case ec_c_index_select: { select_chains_by_index(kvu_string_to_int_vector(action_args_rep, ',')); break; }
444
 
  case ec_c_deselect: { deselect_chains(kvu_string_to_vector(action_args_rep, ',')); break; }
 
481
  case ec_c_index_select: { select_chains_by_index(kvu_string_to_int_vector(first_action_argument_as_string(), ',')); break; }
 
482
  case ec_c_deselect: { deselect_chains(kvu_string_to_vector(first_action_argument_as_string(), ',')); break; }
445
483
  case ec_c_select_add: 
446
484
    { 
447
 
      select_chains(kvu_string_to_vector(action_args_rep + "," +
 
485
      select_chains(kvu_string_to_vector(first_action_argument_as_string() + "," +
448
486
                                         kvu_vector_to_string(selected_chains(), ","), ',')); 
449
487
      break; 
450
488
    }
456
494
        set_last_error("When renaming chains, only one chain canbe selected.");
457
495
      }
458
496
      else {
459
 
        rename_chain(action_args_rep); 
 
497
        rename_chain(first_action_argument_as_string()); 
460
498
      }
461
499
      break;
462
500
    }
483
521
    // ---
484
522
    // Audio input objects
485
523
    // ---
486
 
  case ec_ai_add: { add_audio_input(action_args_rep); break; }
 
524
  case ec_ai_add: { add_audio_input(first_action_argument_as_string()); break; }
487
525
  case ec_ai_describe: { set_last_string(ECA_OBJECT_FACTORY::audio_object_to_eos(selected_audio_input_repp, "i")); break; }
488
526
  case ec_ai_remove: { remove_audio_input(); break; }
489
527
  case ec_ai_list: { set_last_string_list(audio_input_names()); break; }
490
 
  case ec_ai_select: { select_audio_input(action_args_rep); break; }
 
528
  case ec_ai_select: { select_audio_input(first_action_argument_as_string()); break; }
491
529
  case ec_ai_selected: { set_last_string(get_audio_input()->label()); break; }
492
530
  case ec_ai_index_select: { 
493
 
    if (action_args_rep.size() > 0) {
494
 
        select_audio_input_by_index(atoi(action_args_rep.c_str()));
 
531
    if (first_action_argument_as_string().size() > 0) {
 
532
        select_audio_input_by_index(first_action_argument_as_int());
495
533
    }
496
534
    break; 
497
535
  }
527
565
    // ---
528
566
    // Audio output objects
529
567
    // ---
530
 
  case ec_ao_add: { if (action_args_rep.size() == 0) add_default_output(); else add_audio_output(action_args_rep); break; }
 
568
  case ec_ao_add: { if (first_action_argument_as_string().size() == 0) add_default_output(); else add_audio_output(first_action_argument_as_string()); break; }
531
569
  case ec_ao_add_default: { add_default_output(); break; }
532
570
  case ec_ao_describe: { set_last_string(ECA_OBJECT_FACTORY::audio_object_to_eos(selected_audio_output_repp, "o")); break; }
533
571
  case ec_ao_remove: { remove_audio_output(); break; }
534
572
  case ec_ao_list: { set_last_string_list(audio_output_names()); break; }
535
 
  case ec_ao_select: { select_audio_output(action_args_rep); break; }
 
573
  case ec_ao_select: { select_audio_output(first_action_argument_as_string()); break; }
536
574
  case ec_ao_selected: { set_last_string(get_audio_output()->label()); break; }
537
575
  case ec_ao_index_select: { 
538
 
    if (action_args_rep.size() > 0) {
539
 
      select_audio_output_by_index(atoi(action_args_rep.c_str()));
540
 
    }
 
576
    select_audio_output_by_index(first_action_argument_as_int());
541
577
    break; 
542
578
  }
543
579
  case ec_ao_attach: { attach_audio_output(); break; }
570
606
    // ---
571
607
    // Chain operators
572
608
    // ---
573
 
  case ec_cop_add: { add_chain_operator(action_args_rep); break; }
 
609
  case ec_cop_add: { add_chain_operator(first_action_argument_as_string()); break; }
574
610
  case ec_cop_describe: 
575
611
    { 
576
612
      const CHAIN_OPERATOR *t = get_chain_operator();
579
615
    }
580
616
  case ec_cop_remove: { remove_chain_operator(); break; }
581
617
  case ec_cop_list: { set_last_string_list(chain_operator_names()); break; }
582
 
  case ec_cop_select: { select_chain_operator(atoi((action_args_rep).c_str())); break; }
 
618
  case ec_cop_select: { select_chain_operator(first_action_argument_as_int()); break; }
583
619
  case ec_cop_selected: { set_last_integer(selected_chain_operator()); break; }
584
620
  case ec_cop_set: 
585
621
    { 
586
 
      vector<string> a = kvu_string_to_vector(action_args_rep, ',');
 
622
      vector<string> a = kvu_string_to_vector(first_action_argument_as_string(), ',');
587
623
      if (a.size() < 3) {
588
624
        set_last_error("Not enough parameters!");
589
625
        break;
611
647
    // Chain operator parameters
612
648
    // ---
613
649
  case ec_copp_list: { set_last_string_list(chain_operator_parameter_names()); break; }
614
 
  case ec_copp_select: { select_chain_operator_parameter(atoi((action_args_rep).c_str())); break; }
 
650
  case ec_copp_select: { select_chain_operator_parameter(first_action_argument_as_int()); break; }
615
651
  case ec_copp_selected: { set_last_integer(selected_chain_operator_parameter()); break; }
616
652
  case ec_copp_set: { set_chain_operator_parameter(first_action_argument_as_float()); break; }
617
653
  case ec_copp_get: { set_last_float(get_chain_operator_parameter()); break; }
619
655
    // ---
620
656
    // Controllers
621
657
    // ---
622
 
  case ec_ctrl_add: { add_controller(action_args_rep); break; }
 
658
  case ec_ctrl_add: { add_controller(first_action_argument_as_string()); break; }
623
659
  case ec_ctrl_describe: 
624
660
    { 
625
661
      const GENERIC_CONTROLLER *t = get_controller();
628
664
    }
629
665
  case ec_ctrl_remove: { remove_controller(); break; }
630
666
  case ec_ctrl_list: { set_last_string_list(controller_names()); break; }
631
 
  case ec_ctrl_select: { select_controller(atoi((action_args_rep).c_str())); break; }
 
667
  case ec_ctrl_select: { select_controller(first_action_argument_as_int()); break; }
632
668
  case ec_ctrl_selected: { set_last_integer(selected_controller()); break; }
633
669
  case ec_ctrl_status: 
634
670
    { 
641
677
    // Controller parameters
642
678
    // ---
643
679
  case ec_ctrlp_list: { set_last_string_list(controller_parameter_names()); break; }
644
 
  case ec_ctrlp_select: { select_controller_parameter(atoi((action_args_rep).c_str())); break; }
 
680
  case ec_ctrlp_select: { select_controller_parameter(first_action_argument_as_int()); break; }
645
681
  case ec_ctrlp_selected: { set_last_integer(selected_controller_parameter()); break; }
646
682
  case ec_ctrlp_get: { set_last_float(get_controller_parameter()); break; }
647
683
  case ec_ctrlp_set: { set_controller_parameter(first_action_argument_as_float()); break; }
674
710
    wellformed_mode_rep = true;
675
711
    break; 
676
712
  }
677
 
  case ec_int_set_float_to_string_precision: { set_float_to_string_precision(atoi(action_args_rep.c_str())); break; }
678
 
  case ec_int_set_log_history_length: { ECA_LOGGER::instance().set_log_history_length(atoi(action_args_rep.c_str())); break; }
 
713
  case ec_int_set_float_to_string_precision: { set_float_to_string_precision(first_action_argument_as_int()); break; }
 
714
  case ec_int_set_log_history_length: { ECA_LOGGER::instance().set_log_history_length(first_action_argument_as_int()); break; }
679
715
  case ec_int_version_string: { set_last_string(ecasound_library_version); break; }
680
716
  case ec_int_version_lib_current: { set_last_integer(ecasound_library_version_current); break; }
681
717
  case ec_int_version_lib_revision: { set_last_integer(ecasound_library_version_revision); break; }
684
720
  // ---
685
721
  // Dump commands
686
722
  // ---
687
 
  case ec_dump_target: { ctrl_dump_rep.set_dump_target(action_args_rep); break; }
 
723
  case ec_dump_target: { ctrl_dump_rep.set_dump_target(first_action_argument_as_string()); break; }
688
724
  case ec_dump_status: { ctrl_dump_rep.dump_status(); break; }
689
725
  case ec_dump_position: { ctrl_dump_rep.dump_position(); break; }
690
726
  case ec_dump_length: { ctrl_dump_rep.dump_length(); break; }
700
736
  case ec_dump_ao_open_state: { ctrl_dump_rep.dump_audio_output_open_state(); break; }
701
737
  case ec_dump_cop_value: 
702
738
    { 
703
 
      vector<string> temp = kvu_string_to_tokens_quoted(action_args_rep);
 
739
      vector<string> temp = kvu_string_to_vector(first_action_argument_as_string(), ',');
704
740
      if (temp.size() > 1) {
705
741
        ctrl_dump_rep.dump_chain_operator_value(atoi(temp[0].c_str()),
706
742
                                                atoi(temp[1].c_str()));
707
743
      }
708
744
      break; 
709
745
    }
 
746
 
 
747
    // ---
 
748
    // Commands with external dependencies
 
749
    // ---
 
750
#if ECA_COMPILE_JACK
 
751
  case ec_jack_connect: 
 
752
    {
 
753
      const vector<string>& params = action_arguments_as_vector();
 
754
      if (params.size() >= 2) 
 
755
        JACK_CONNECTIONS::connect(params[0].c_str(), params[1].c_str());
 
756
      break;
 
757
    }
 
758
  case ec_jack_disconnect:   
 
759
    {
 
760
      const vector<string>& params = action_arguments_as_vector();
 
761
      if (params.size() >= 2) 
 
762
        JACK_CONNECTIONS::disconnect(params[0].c_str(), params[1].c_str());
 
763
      break;
 
764
    }
 
765
  case ec_jack_list_connections:   
 
766
    {
 
767
      string foo;
 
768
      if (JACK_CONNECTIONS::list_connections(&foo) == true)
 
769
        set_last_string(foo);
 
770
      else
 
771
        set_last_error("Unable to a list of JACK connections.");
 
772
      break;
 
773
    }
 
774
#endif
 
775
 
710
776
  } // <-- switch-case
711
777
 
 
778
 
712
779
  if (action_reconnect == true) {
713
780
    if (is_selected() == false ||
714
781
        is_valid() == false) {
779
846
  string result;
780
847
  vector<CHAIN*>::const_iterator chain_citer;
781
848
 
782
 
  result += "\n -> Objects: " + kvu_numtostr(cs->inputs.size());
 
849
  result += "\n -> Objects..: " + kvu_numtostr(cs->inputs.size());
783
850
  result += " inputs, " + kvu_numtostr(cs->outputs.size());
784
851
  result += " outputs, " + kvu_numtostr(cs->chains.size());
785
852
  result += " chains";
786
853
 
787
854
  // FIXME: add explanations on why the chainsetup cannot be
788
855
  //        connected
 
856
  
 
857
  result += "\n -> State....: ";
789
858
 
790
859
  if (cs->is_locked()) {
791
 
    result += "\n -> State:   connected to engine (engine status: ";
 
860
    result += "connected to engine (engine status: ";
792
861
    result += engine_status() + ")";
793
862
  }
794
863
  else if (cs->is_enabled() && is_engine_started() == true) {
795
 
    result += "\n -> State:   connected (engine status: ";
 
864
    result += "connected (engine status: ";
796
865
    result += engine_status() + ")";
797
866
  }
798
867
  else if (cs->is_enabled())
799
 
    result += "\n -> State:   connected (engine not yet running)";
 
868
    result += "connected (engine not yet running)";
800
869
  else if (cs->is_valid()) 
801
 
    result += "\n -> State:   valid (can be connected)";
 
870
    result += "valid (can be connected)";
802
871
  else
803
 
    result += "\n -> State:   not valid (cannot be connected)";
 
872
    result += "not valid (cannot be connected)";
804
873
  
805
 
  result += "\n -> Position:  ";
 
874
  result += "\n -> Position.:  ";
806
875
  result += kvu_numtostr(cs->position_in_seconds_exact(), 3);
807
876
  result += " / ";
808
877
  if (cs->length_set())
810
879
  else
811
880
    result += "inf";
812
881
 
813
 
  result += "\n -> Options: ";
 
882
  result += "\n -> Options..: ";
814
883
  result += cs->options_to_string();
815
884
 
816
885
  for(chain_citer = cs->chains.begin();