← Back to branch summary

~ubuntu-branches/debian/sid/jackd2/sid

« back to all changes in this revision

Viewing changes to common/JackControlAPI.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Adrian Knoth
  • Date: 2011-03-31 13:54:50 UTC
  • mfrom: (1.1.3 upstream) (2.1.4 experimental)
  • Revision ID: james.westby@ubuntu.com-20110331135450-zafc1di024kzeu31
Tags: 1.9.7~dfsg-1
* New upstream version 1.9.7 (ALSA resume, new latency API)
* Build with --mixed on i386 to be compatible with amd64.
* Don't patch jack_connect for fast consecutive calls anymore, it's now
  using the same code as in jackd1 and waits for the port connection to
  appear.

Show diffs side-by-side

added added

removed removed

Lines of Context:
common/JackControlAPI.cpp
47
47
 
48
48
using namespace Jack;
49
49
 
 
50
#define SELF_CONNECT_MODE_ALLOW_CHAR                  ' '
 
51
#define SELF_CONNECT_MODE_FAIL_EXTERNAL_ONLY_CHAR     'E'
 
52
#define SELF_CONNECT_MODE_IGNORE_EXTERNAL_ONLY_CHAR   'e'
 
53
#define SELF_CONNECT_MODE_FAIL_ALL_CHAR               'A'
 
54
#define SELF_CONNECT_MODE_IGNORE_ALL_CHAR             'a'
 
55
#define SELF_CONNECT_MODES_COUNT              5
 
56
 
50
57
struct jackctl_server
51
58
{
52
59
    JSList * drivers;
78
85
    /* int32_t, msecs; if zero, use period size. */
79
86
    union jackctl_parameter_value client_timeout;
80
87
    union jackctl_parameter_value default_client_timeout;
81
 
    
 
88
 
82
89
    /* uint32_t, clock source type */
83
90
    union jackctl_parameter_value clock_source;
84
91
    union jackctl_parameter_value default_clock_source;
85
 
   
 
92
 
86
93
    /* uint32_t, max port number */
87
94
    union jackctl_parameter_value port_max;
88
95
    union jackctl_parameter_value default_port_max;
89
 
    
 
96
 
90
97
    /* bool */
91
98
    union jackctl_parameter_value replace_registry;
92
99
    union jackctl_parameter_value default_replace_registry;
94
101
    /* bool, synchronous or asynchronous engine mode */
95
102
    union jackctl_parameter_value sync;
96
103
    union jackctl_parameter_value default_sync;
 
104
 
 
105
    /* char enum, self connect mode mode */
 
106
    union jackctl_parameter_value self_connect_mode;
 
107
    union jackctl_parameter_value default_self_connect_mode;
 
108
    jack_driver_param_value_enum_t self_connect_mode_possible_values[SELF_CONNECT_MODES_COUNT];
 
109
    jack_driver_param_constraint_desc_t self_connect_mode_constraint;
97
110
};
98
111
 
99
112
struct jackctl_driver
366
379
    }
367
380
 
368
381
    while (descriptor_node_ptr != NULL)
369
 
    {     
 
382
    {
370
383
        internal_ptr = (struct jackctl_internal *)malloc(sizeof(struct jackctl_internal));
371
384
        if (internal_ptr == NULL)
372
385
        {
450
463
jackctl_setup_signals(
451
464
    unsigned int flags)
452
465
{
453
 
        if ((waitEvent = CreateEvent(NULL, FALSE, FALSE, NULL)) == NULL) {
 
466
    if ((waitEvent = CreateEvent(NULL, FALSE, FALSE, NULL)) == NULL) {
454
467
        jack_error("CreateEvent fails err = %ld", GetLastError());
455
468
        return 0;
456
469
    }
457
470
 
458
 
        (void) signal(SIGINT, do_nothing_handler);
 
471
    (void) signal(SIGINT, do_nothing_handler);
459
472
    (void) signal(SIGABRT, do_nothing_handler);
460
473
    (void) signal(SIGTERM, do_nothing_handler);
461
474
 
462
 
        return (sigset_t)waitEvent;
 
475
    return (sigset_t)waitEvent;
463
476
}
464
477
 
465
478
void jackctl_wait_signals(sigset_t signals)
466
479
{
467
 
        if (WaitForSingleObject(waitEvent, INFINITE) != WAIT_OBJECT_0) {
 
480
    if (WaitForSingleObject(waitEvent, INFINITE) != WAIT_OBJECT_0) {
468
481
        jack_error("WaitForSingleObject fails err = %ld", GetLastError());
469
482
    }
470
483
}
539
552
     * explicitly reset it
540
553
     */
541
554
 
542
 
     pthread_sigmask(SIG_BLOCK, &signals, 0);
 
555
    pthread_sigmask(SIG_BLOCK, &signals, 0);
543
556
 
544
557
    /* install a do-nothing handler because otherwise pthreads
545
558
       behaviour is undefined when we enter sigwait.
745
758
    {
746
759
        goto fail_free_parameters;
747
760
    }
748
 
    
 
761
 
749
762
    value.ui = PORT_NUM;
750
763
    if (jackctl_add_parameter(
751
764
          &server_ptr->parameters,
788
801
        goto fail_free_parameters;
789
802
    }
790
803
 
 
804
    server_ptr->self_connect_mode_constraint.flags = JACK_CONSTRAINT_FLAG_STRICT | JACK_CONSTRAINT_FLAG_FAKE_VALUE;
 
805
    server_ptr->self_connect_mode_constraint.constraint.enumeration.count = SELF_CONNECT_MODES_COUNT;
 
806
    server_ptr->self_connect_mode_constraint.constraint.enumeration.possible_values_array = server_ptr->self_connect_mode_possible_values;
 
807
 
 
808
    server_ptr->self_connect_mode_possible_values[0].value.c = SELF_CONNECT_MODE_ALLOW_CHAR;
 
809
    strcpy(server_ptr->self_connect_mode_possible_values[0].short_desc, "Don't restrict self connect requests");
 
810
 
 
811
    server_ptr->self_connect_mode_possible_values[1].value.c = SELF_CONNECT_MODE_FAIL_EXTERNAL_ONLY_CHAR ;
 
812
    strcpy(server_ptr->self_connect_mode_possible_values[1].short_desc, "Fail self connect requests to external ports only");
 
813
 
 
814
    server_ptr->self_connect_mode_possible_values[2].value.c = SELF_CONNECT_MODE_IGNORE_EXTERNAL_ONLY_CHAR;
 
815
    strcpy(server_ptr->self_connect_mode_possible_values[2].short_desc, "Ignore self connect requests to external ports only");
 
816
 
 
817
    server_ptr->self_connect_mode_possible_values[3].value.c = SELF_CONNECT_MODE_FAIL_ALL_CHAR;
 
818
    strcpy(server_ptr->self_connect_mode_possible_values[3].short_desc, "Fail all self connect requests");
 
819
 
 
820
    server_ptr->self_connect_mode_possible_values[4].value.c = SELF_CONNECT_MODE_IGNORE_ALL_CHAR;
 
821
    strcpy(server_ptr->self_connect_mode_possible_values[4].short_desc, "Ignore all self connect requests");
 
822
 
 
823
    value.c = SELF_CONNECT_MODE_ALLOW_CHAR;
 
824
    if (jackctl_add_parameter(
 
825
            &server_ptr->parameters,
 
826
            "self-connect-mode",
 
827
            "Self connect mode.",
 
828
            "Whether JACK clients are allowed to connect their own ports",
 
829
            JackParamChar,
 
830
            &server_ptr->self_connect_mode,
 
831
            &server_ptr->default_self_connect_mode,
 
832
            value,
 
833
            &server_ptr->self_connect_mode_constraint) == NULL)
 
834
    {
 
835
        goto fail_free_parameters;
 
836
    }
 
837
 
791
838
    JackServerGlobals::on_device_acquire = on_device_acquire;
792
839
    JackServerGlobals::on_device_release = on_device_release;
793
840
 
795
842
    {
796
843
        goto fail_free_parameters;
797
844
    }
798
 
    
 
845
 
799
846
    /* Allowed to fail */
800
847
    jackctl_internals_load(server_ptr);
801
848
 
826
873
EXPORT bool jackctl_server_stop(jackctl_server *server_ptr)
827
874
{
828
875
    server_ptr->engine->Stop();
 
876
    return true;
 
877
}
 
878
 
 
879
EXPORT bool jackctl_server_close(jackctl_server *server_ptr)
 
880
{
829
881
    server_ptr->engine->Close();
830
882
    delete server_ptr->engine;
831
883
 
853
905
}
854
906
 
855
907
EXPORT bool
856
 
jackctl_server_start(
 
908
jackctl_server_open(
857
909
    jackctl_server *server_ptr,
858
910
    jackctl_driver *driver_ptr)
859
911
{
860
912
    int rc;
 
913
    JackSelfConnectMode self_connect_mode;
861
914
 
862
915
    rc = jack_register_server(server_ptr->name.str, server_ptr->replace_registry.b);
863
916
    switch (rc)
882
935
 
883
936
    if (!server_ptr->realtime.b && server_ptr->client_timeout.i == 0)
884
937
        server_ptr->client_timeout.i = 500; /* 0.5 sec; usable when non realtime. */
885
 
    
 
938
 
886
939
    /* check port max value before allocating server */
887
940
    if (server_ptr->port_max.ui > PORT_NUM_MAX) {
888
941
        jack_error("JACK server started with too much ports %d (when port max can be %d)", server_ptr->port_max.ui, PORT_NUM_MAX);
889
942
        goto fail;
890
943
    }
891
944
 
 
945
    switch (server_ptr->self_connect_mode.c)
 
946
    {
 
947
    case SELF_CONNECT_MODE_ALLOW_CHAR:
 
948
        self_connect_mode = JackSelfConnectAllow;
 
949
        break;
 
950
    case SELF_CONNECT_MODE_FAIL_EXTERNAL_ONLY_CHAR:
 
951
        self_connect_mode = JackSelfConnectFailExternalOnly;
 
952
        break;
 
953
    case SELF_CONNECT_MODE_IGNORE_EXTERNAL_ONLY_CHAR:
 
954
        self_connect_mode = JackSelfConnectIgnoreExternalOnly;
 
955
        break;
 
956
    case SELF_CONNECT_MODE_FAIL_ALL_CHAR:
 
957
        self_connect_mode = JackSelfConnectFailAll;
 
958
        break;
 
959
    case SELF_CONNECT_MODE_IGNORE_ALL_CHAR:
 
960
        self_connect_mode = JackSelfConnectIgnoreAll;
 
961
        break;
 
962
    default:
 
963
        self_connect_mode = JACK_DEFAULT_SELF_CONNECT_MODE;
 
964
    }
 
965
 
892
966
    /* get the engine/driver started */
893
967
    server_ptr->engine = new JackServer(
894
968
        server_ptr->sync.b,
896
970
        server_ptr->client_timeout.i,
897
971
        server_ptr->realtime.b,
898
972
        server_ptr->realtime_priority.i,
899
 
        server_ptr->port_max.ui,                                
 
973
        server_ptr->port_max.ui,
900
974
        server_ptr->verbose.b,
901
975
        (jack_timer_type_t)server_ptr->clock_source.ui,
 
976
        self_connect_mode,
902
977
        server_ptr->name.str);
903
978
    if (server_ptr->engine == NULL)
904
979
    {
913
988
        goto fail_delete;
914
989
    }
915
990
 
916
 
    rc = server_ptr->engine->Start();
917
 
    if (rc < 0)
918
 
    {
919
 
        jack_error("JackServer::Start() failed with %d", rc);
920
 
        goto fail_close;
921
 
    }
922
 
 
923
991
    return true;
924
992
 
925
 
fail_close:
926
 
    server_ptr->engine->Close();
927
 
 
928
993
fail_delete:
929
994
    delete server_ptr->engine;
930
995
    server_ptr->engine = NULL;
946
1011
    return false;
947
1012
}
948
1013
 
 
1014
EXPORT bool
 
1015
jackctl_server_start(
 
1016
    jackctl_server *server_ptr)
 
1017
{
 
1018
    int rc = server_ptr->engine->Start();
 
1019
    bool result = rc >= 0;
 
1020
    if (! result)
 
1021
    {
 
1022
        jack_error("JackServer::Start() failed with %d", rc);
 
1023
    }
 
1024
    return result;
 
1025
}
 
1026
 
949
1027
EXPORT const char * jackctl_driver_get_name(jackctl_driver *driver_ptr)
950
1028
{
951
1029
    return driver_ptr->desc_ptr->name;
1179
1257
{
1180
1258
    int status;
1181
1259
    if (server_ptr->engine != NULL) {
1182
 
        server_ptr->engine->InternalClientLoad(internal->desc_ptr->name, internal->desc_ptr->name, internal->set_parameters, JackNullOption, &internal->refnum, &status);
 
1260
        server_ptr->engine->InternalClientLoad2(internal->desc_ptr->name, internal->desc_ptr->name, internal->set_parameters, JackNullOption, &internal->refnum, -1, &status);
1183
1261
        return (internal->refnum > 0);
1184
1262
    } else {
1185
1263
        return false;
1192
1270
{
1193
1271
    int status;
1194
1272
    if (server_ptr->engine != NULL && internal->refnum > 0) {
 
1273
        // Client object is internally kept in JackEngine, and will be desallocated in InternalClientUnload
1195
1274
        return ((server_ptr->engine->GetEngine()->InternalClientUnload(internal->refnum, &status)) == 0);
1196
1275
    } else {
1197
1276
        return false;
1201
1280
EXPORT bool jackctl_server_add_slave(jackctl_server * server_ptr, jackctl_driver * driver_ptr)
1202
1281
{
1203
1282
    if (server_ptr->engine != NULL) {
1204
 
        driver_ptr->info = server_ptr->engine->AddSlave(driver_ptr->desc_ptr, driver_ptr->set_parameters);
1205
 
        return (driver_ptr->info != 0);
 
1283
        if (server_ptr->engine->IsRunning()) {
 
1284
            jack_error("cannot add a slave in a running server");
 
1285
            return false;
 
1286
        } else {
 
1287
            driver_ptr->info = server_ptr->engine->AddSlave(driver_ptr->desc_ptr, driver_ptr->set_parameters);
 
1288
            return (driver_ptr->info != 0);
 
1289
        }
1206
1290
    } else {
1207
1291
        return false;
1208
1292
    }
1211
1295
EXPORT bool jackctl_server_remove_slave(jackctl_server * server_ptr, jackctl_driver * driver_ptr)
1212
1296
{
1213
1297
    if (server_ptr->engine != NULL) {
1214
 
        server_ptr->engine->RemoveSlave(driver_ptr->info);
1215
 
        delete driver_ptr->info;
1216
 
        return true;
 
1298
        if (server_ptr->engine->IsRunning()) {
 
1299
            jack_error("cannot remove a slave from a running server");
 
1300
            return false;
 
1301
        } else {
 
1302
            server_ptr->engine->RemoveSlave(driver_ptr->info);
 
1303
            delete driver_ptr->info;
 
1304
            return true;
 
1305
        }
1217
1306
    } else {
1218
1307
        return false;
1219
1308
    }