00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022 #ifndef __JackRequest__
00023 #define __JackRequest__
00024
00025 #include "JackPort.h"
00026 #include "JackChannelTransaction.h"
00027 #include "JackError.h"
00028 #include <stdio.h>
00029
00030 namespace Jack
00031 {
00032
00033 #define CheckRes(res) {if (res < 0) return res;}
00034
00039 struct JackRequest
00040 {
00041
00042 public:
00043
00044 typedef enum {
00045 kRegisterPort = 1,
00046 kUnRegisterPort = 2,
00047 kConnectPorts = 3,
00048 kDisconnectPorts = 4,
00049 kSetTimeBaseClient = 5,
00050 kActivateClient = 6,
00051 kDeactivateClient = 7,
00052 kDisconnectPort = 8,
00053 kSetClientCapabilities = 9,
00054 kGetPortConnections = 10,
00055 kGetPortNConnections = 11,
00056
00057 kReleaseTimebase = 12,
00058 kSetTimebaseCallback = 13,
00059
00060 kSetBufferSize = 20,
00061 kSetFreeWheel = 21,
00062 kClientNew = 22,
00063 kClientClose = 23,
00064 kConnectNamePorts = 24,
00065 kDisconnectNamePorts = 25,
00066
00067 kNotification = 26
00068 } RequestType;
00069
00070 RequestType fType;
00071
00072 JackRequest()
00073 {}
00074
00075 JackRequest(RequestType type): fType(type)
00076 {}
00077
00078 virtual ~JackRequest()
00079 {}
00080
00081 virtual int Read(JackChannelTransaction* trans)
00082 {
00083 return trans->Read(&fType, sizeof(RequestType));
00084 }
00085
00086 virtual int Write(JackChannelTransaction* trans)
00087 {
00088 return trans->Write(&fType, sizeof(RequestType));
00089 }
00090
00091 };
00092
00097 struct JackResult
00098 {
00099
00100 int fResult;
00101
00102 JackResult(): fResult( -1)
00103 {}
00104 JackResult(int status): fResult(status)
00105 {}
00106 virtual ~JackResult()
00107 {}
00108
00109 virtual int Read(JackChannelTransaction* trans)
00110 {
00111 return trans->Read(&fResult, sizeof(int));
00112 }
00113
00114 virtual int Write(JackChannelTransaction* trans)
00115 {
00116 return trans->Write(&fResult, sizeof(int));
00117 }
00118 };
00119
00124 struct JackClientNewRequest : public JackRequest
00125 {
00126
00127 char fName[JACK_CLIENT_NAME_SIZE + 1];
00128
00129 JackClientNewRequest()
00130 {}
00131 JackClientNewRequest(const char* name): JackRequest(JackRequest::kClientNew)
00132 {
00133 snprintf(fName, sizeof(fName), "%s", name);
00134 }
00135
00136 int Read(JackChannelTransaction* trans)
00137 {
00138 return trans->Read(&fName, JACK_CLIENT_NAME_SIZE + 1);
00139 }
00140
00141 int Write(JackChannelTransaction* trans)
00142 {
00143 CheckRes(JackRequest::Write(trans));
00144 return trans->Write(&fName, JACK_CLIENT_NAME_SIZE + 1);
00145 }
00146 };
00147
00152 struct JackClientNewResult : public JackResult
00153 {
00154
00155 int fSharedEngine;
00156 int fSharedClient;
00157 int fSharedGraph;
00158 uint32_t fProtocolVersion;
00159
00160 JackClientNewResult()
00161 :fSharedEngine(-1), fSharedClient(-1), fSharedGraph(-1), fProtocolVersion(0)
00162 {}
00163 JackClientNewResult(int32_t status, int index1, int index2, int index3)
00164 : JackResult(status), fSharedEngine(index1), fSharedClient(index2), fSharedGraph(index3), fProtocolVersion(0)
00165 {}
00166
00167 int Read(JackChannelTransaction* trans)
00168 {
00169 CheckRes(JackResult::Read(trans));
00170 CheckRes(trans->Read(&fSharedEngine, sizeof(int)));
00171 CheckRes(trans->Read(&fSharedClient, sizeof(int)));
00172 CheckRes(trans->Read(&fSharedGraph, sizeof(int)));
00173 CheckRes(trans->Read(&fProtocolVersion, sizeof(uint32_t)));
00174 return 0;
00175 }
00176
00177 int Write(JackChannelTransaction* trans)
00178 {
00179 CheckRes(JackResult::Write(trans));
00180 CheckRes(trans->Write(&fSharedEngine, sizeof(int)));
00181 CheckRes(trans->Write(&fSharedClient, sizeof(int)));
00182 CheckRes(trans->Write(&fSharedGraph, sizeof(int)));
00183 CheckRes(trans->Write(&fProtocolVersion, sizeof(uint32_t)));
00184 return 0;
00185 }
00186 };
00187
00192 struct JackClientCloseRequest : public JackRequest
00193 {
00194
00195 int fRefNum;
00196
00197 JackClientCloseRequest()
00198 {}
00199 JackClientCloseRequest(int refnum): JackRequest(JackRequest::kClientClose), fRefNum(refnum)
00200 {}
00201
00202 int Read(JackChannelTransaction* trans)
00203 {
00204 return trans->Read(&fRefNum, sizeof(int));
00205 }
00206
00207 int Write(JackChannelTransaction* trans)
00208 {
00209 CheckRes(JackRequest::Write(trans));
00210 return trans->Write(&fRefNum, sizeof(int));
00211 }
00212 };
00213
00218 struct JackActivateRequest : public JackRequest
00219 {
00220
00221 int fRefNum;
00222
00223 JackActivateRequest()
00224 {}
00225 JackActivateRequest(int refnum): JackRequest(JackRequest::kActivateClient), fRefNum(refnum)
00226 {}
00227
00228 int Read(JackChannelTransaction* trans)
00229 {
00230 return trans->Read(&fRefNum, sizeof(int));
00231 }
00232
00233 int Write(JackChannelTransaction* trans)
00234 {
00235 CheckRes(JackRequest::Write(trans));
00236 return trans->Write(&fRefNum, sizeof(int));
00237 }
00238
00239 };
00240
00245 struct JackDeactivateRequest : public JackRequest
00246 {
00247
00248 int fRefNum;
00249
00250 JackDeactivateRequest()
00251 {}
00252 JackDeactivateRequest(int refnum): JackRequest(JackRequest::kDeactivateClient), fRefNum(refnum)
00253 {}
00254
00255 int Read(JackChannelTransaction* trans)
00256 {
00257 return trans->Read(&fRefNum, sizeof(int));
00258 }
00259
00260 int Write(JackChannelTransaction* trans)
00261 {
00262 CheckRes(JackRequest::Write(trans));
00263 return trans->Write(&fRefNum, sizeof(int));
00264 }
00265
00266 };
00267
00272 struct JackPortRegisterRequest : public JackRequest
00273 {
00274
00275 int fRefNum;
00276 char fName[JACK_PORT_NAME_SIZE + 1];
00277 char fPortType[JACK_PORT_TYPE_SIZE + 1];
00278 unsigned int fFlags;
00279 unsigned int fBufferSize;
00280
00281 JackPortRegisterRequest()
00282 {}
00283 JackPortRegisterRequest(int refnum, const char* name, const char* port_type, unsigned int flags, unsigned int buffer_size)
00284 : JackRequest(JackRequest::kRegisterPort), fRefNum(refnum), fFlags(flags), fBufferSize(buffer_size)
00285 {
00286 strcpy(fName, name);
00287 strcpy(fPortType, port_type);
00288 }
00289
00290 int Read(JackChannelTransaction* trans)
00291 {
00292 CheckRes(trans->Read(&fRefNum, sizeof(int)));
00293 CheckRes(trans->Read(&fName, JACK_PORT_NAME_SIZE + 1));
00294 CheckRes(trans->Read(&fPortType, JACK_PORT_TYPE_SIZE + 1));
00295 CheckRes(trans->Read(&fFlags, sizeof(unsigned int)));
00296 CheckRes(trans->Read(&fBufferSize, sizeof(unsigned int)));
00297 return 0;
00298 }
00299
00300 int Write(JackChannelTransaction* trans)
00301 {
00302 CheckRes(JackRequest::Write(trans));
00303 CheckRes(trans->Write(&fRefNum, sizeof(int)));
00304 CheckRes(trans->Write(&fName, JACK_PORT_NAME_SIZE + 1));
00305 CheckRes(trans->Write(&fPortType, JACK_PORT_TYPE_SIZE + 1));
00306 CheckRes(trans->Write(&fFlags, sizeof(unsigned int)));
00307 CheckRes(trans->Write(&fBufferSize, sizeof(unsigned int)));
00308 return 0;
00309 }
00310 };
00311
00316 struct JackPortRegisterResult : public JackResult
00317 {
00318
00319 jack_port_id_t fPortIndex;
00320
00321 JackPortRegisterResult(): fPortIndex(NO_PORT)
00322 {}
00323
00324 int Read(JackChannelTransaction* trans)
00325 {
00326 CheckRes(JackResult::Read(trans));
00327 return trans->Read(&fPortIndex, sizeof(jack_port_id_t));
00328 }
00329
00330 int Write(JackChannelTransaction* trans)
00331 {
00332 CheckRes(JackResult::Write(trans));
00333 return trans->Write(&fPortIndex, sizeof(jack_port_id_t));
00334 }
00335 };
00336
00341 struct JackPortUnRegisterRequest : public JackRequest
00342 {
00343
00344 int fRefNum;
00345 int fPortIndex;
00346
00347 JackPortUnRegisterRequest()
00348 {}
00349 JackPortUnRegisterRequest(int refnum, int index): JackRequest(JackRequest::kUnRegisterPort), fRefNum(refnum), fPortIndex(index)
00350 {}
00351
00352 int Read(JackChannelTransaction* trans)
00353 {
00354 CheckRes(trans->Read(&fRefNum, sizeof(int)));
00355 CheckRes(trans->Read(&fPortIndex, sizeof(int)));
00356 return 0;
00357 }
00358
00359 int Write(JackChannelTransaction* trans)
00360 {
00361 CheckRes(JackRequest::Write(trans));
00362 CheckRes(trans->Write(&fRefNum, sizeof(int)));
00363 CheckRes(trans->Write(&fPortIndex, sizeof(int)));
00364 return 0;
00365 }
00366 };
00367
00372 struct JackPortConnectNameRequest : public JackRequest
00373 {
00374
00375 int fRefNum;
00376 char fSrc[JACK_PORT_NAME_SIZE + 1];
00377 char fDst[JACK_PORT_NAME_SIZE + 1];
00378
00379 JackPortConnectNameRequest()
00380 {}
00381 JackPortConnectNameRequest(int refnum, const char* src_name, const char* dst_name): JackRequest(JackRequest::kConnectNamePorts), fRefNum(refnum)
00382 {
00383 strcpy(fSrc, src_name);
00384 strcpy(fDst, dst_name);
00385 }
00386
00387 int Read(JackChannelTransaction* trans)
00388 {
00389 CheckRes(trans->Read(&fRefNum, sizeof(int)));
00390 CheckRes(trans->Read(&fSrc, JACK_PORT_NAME_SIZE + 1));
00391 CheckRes(trans->Read(&fDst,JACK_PORT_NAME_SIZE + 1));
00392 return 0;
00393
00394 }
00395
00396 int Write(JackChannelTransaction* trans)
00397 {
00398 CheckRes(JackRequest::Write(trans));
00399 CheckRes(trans->Write(&fRefNum, sizeof(int)));
00400 CheckRes(trans->Write(&fSrc, JACK_PORT_NAME_SIZE + 1));
00401 CheckRes(trans->Write(&fDst, JACK_PORT_NAME_SIZE + 1));
00402 return 0;
00403 }
00404 };
00405
00410 struct JackPortDisconnectNameRequest : public JackRequest
00411 {
00412
00413 int fRefNum;
00414 char fSrc[JACK_PORT_NAME_SIZE + 1];
00415 char fDst[JACK_PORT_NAME_SIZE + 1];
00416
00417 JackPortDisconnectNameRequest()
00418 {}
00419 JackPortDisconnectNameRequest(int refnum, const char* src_name, const char* dst_name): JackRequest(JackRequest::kDisconnectNamePorts), fRefNum(refnum)
00420 {
00421 strcpy(fSrc, src_name);
00422 strcpy(fDst, dst_name);
00423 }
00424
00425 int Read(JackChannelTransaction* trans)
00426 {
00427 CheckRes(trans->Read(&fRefNum, sizeof(int)));
00428 CheckRes(trans->Read(&fSrc, JACK_PORT_NAME_SIZE + 1));
00429 CheckRes(trans->Read(&fDst, JACK_PORT_NAME_SIZE + 1));
00430 return 0;
00431 }
00432
00433 int Write(JackChannelTransaction* trans)
00434 {
00435 CheckRes(JackRequest::Write(trans));
00436 CheckRes(trans->Write(&fRefNum, sizeof(int)));
00437 CheckRes(trans->Write(&fSrc, JACK_PORT_NAME_SIZE + 1));
00438 CheckRes(trans->Write(&fDst, JACK_PORT_NAME_SIZE + 1));
00439 return 0;
00440 }
00441 };
00442
00447 struct JackPortConnectRequest : public JackRequest
00448 {
00449
00450 int fRefNum;
00451 jack_port_id_t fSrc;
00452 jack_port_id_t fDst;
00453
00454 JackPortConnectRequest()
00455 {}
00456 JackPortConnectRequest(int refnum, jack_port_id_t src, jack_port_id_t dst): JackRequest(JackRequest::kConnectPorts), fRefNum(refnum), fSrc(src), fDst(dst)
00457 {}
00458
00459 int Read(JackChannelTransaction* trans)
00460 {
00461 CheckRes(trans->Read(&fRefNum, sizeof(int)));
00462 CheckRes(trans->Read(&fSrc, sizeof(jack_port_id_t)));
00463 CheckRes(trans->Read(&fDst, sizeof(jack_port_id_t)));
00464 return 0;
00465 }
00466
00467 int Write(JackChannelTransaction* trans)
00468 {
00469 CheckRes(JackRequest::Write(trans));
00470 CheckRes(trans->Write(&fRefNum, sizeof(int)));
00471 CheckRes(trans->Write(&fSrc, sizeof(jack_port_id_t)));
00472 CheckRes(trans->Write(&fDst, sizeof(jack_port_id_t)));
00473 return 0;
00474 }
00475 };
00476
00477
00482 struct JackPortDisconnectRequest : public JackRequest
00483 {
00484
00485 int fRefNum;
00486 jack_port_id_t fSrc;
00487 jack_port_id_t fDst;
00488
00489 JackPortDisconnectRequest()
00490 {}
00491 JackPortDisconnectRequest(int refnum, jack_port_id_t src, jack_port_id_t dst): JackRequest(JackRequest::kDisconnectPorts), fRefNum(refnum), fSrc(src), fDst(dst)
00492 {}
00493
00494 int Read(JackChannelTransaction* trans)
00495 {
00496 CheckRes(trans->Read(&fRefNum, sizeof(int)));
00497 CheckRes(trans->Read(&fSrc, sizeof(jack_port_id_t)));
00498 CheckRes(trans->Read(&fDst, sizeof(jack_port_id_t)));
00499 return 0;
00500 }
00501
00502 int Write(JackChannelTransaction* trans)
00503 {
00504 CheckRes(JackRequest::Write(trans));
00505 CheckRes(trans->Write(&fRefNum, sizeof(int)));
00506 CheckRes(trans->Write(&fSrc, sizeof(jack_port_id_t)));
00507 CheckRes(trans->Write(&fDst, sizeof(jack_port_id_t)));
00508 return 0;
00509
00510 }
00511 };
00512
00517 struct JackSetBufferSizeRequest : public JackRequest
00518 {
00519
00520 jack_nframes_t fBufferSize;
00521
00522 JackSetBufferSizeRequest()
00523 {}
00524 JackSetBufferSizeRequest(jack_nframes_t buffer_size): JackRequest(JackRequest::kSetBufferSize), fBufferSize(buffer_size)
00525 {}
00526
00527 int Read(JackChannelTransaction* trans)
00528 {
00529 return trans->Read(&fBufferSize, sizeof(jack_nframes_t));
00530 }
00531
00532 int Write(JackChannelTransaction* trans)
00533 {
00534 CheckRes(JackRequest::Write(trans));
00535 return trans->Write(&fBufferSize, sizeof(jack_nframes_t));
00536 }
00537 };
00538
00543 struct JackSetFreeWheelRequest : public JackRequest
00544 {
00545
00546 int fOnOff;
00547
00548 JackSetFreeWheelRequest()
00549 {}
00550 JackSetFreeWheelRequest(int onoff): JackRequest(JackRequest::kSetFreeWheel), fOnOff(onoff)
00551 {}
00552
00553 int Read(JackChannelTransaction* trans)
00554 {
00555 return trans->Read(&fOnOff, sizeof(int));
00556 }
00557
00558 int Write(JackChannelTransaction* trans)
00559 {
00560 CheckRes(JackRequest::Write(trans));
00561 return trans->Write(&fOnOff, sizeof(int));
00562 }
00563 };
00564
00569 struct JackReleaseTimebaseRequest : public JackRequest
00570 {
00571
00572 int fRefNum;
00573
00574 JackReleaseTimebaseRequest()
00575 {}
00576 JackReleaseTimebaseRequest(int refnum): JackRequest(JackRequest::kReleaseTimebase), fRefNum(refnum)
00577 {}
00578
00579 int Read(JackChannelTransaction* trans)
00580 {
00581 return trans->Read(&fRefNum, sizeof(int));
00582 }
00583
00584 int Write(JackChannelTransaction* trans)
00585 {
00586 CheckRes(JackRequest::Write(trans));
00587 return trans->Write(&fRefNum, sizeof(int));
00588 }
00589 };
00590
00595 struct JackSetTimebaseCallbackRequest : public JackRequest
00596 {
00597
00598 int fRefNum;
00599 int fConditionnal;
00600
00601 JackSetTimebaseCallbackRequest()
00602 {}
00603 JackSetTimebaseCallbackRequest(int refnum, int conditional): JackRequest(JackRequest::kSetTimebaseCallback), fRefNum(refnum), fConditionnal(conditional)
00604 {}
00605
00606 int Read(JackChannelTransaction* trans)
00607 {
00608 CheckRes(trans->Read(&fRefNum, sizeof(int)));
00609 return trans->Read(&fConditionnal, sizeof(int));
00610 }
00611
00612 int Write(JackChannelTransaction* trans)
00613 {
00614 CheckRes(JackRequest::Write(trans));
00615 CheckRes(trans->Write(&fRefNum, sizeof(int)));
00616 return trans->Write(&fConditionnal, sizeof(int));
00617 }
00618 };
00619
00624 struct JackClientNotificationRequest : public JackRequest
00625 {
00626
00627 int fRefNum;
00628 int fNotify;
00629 int fValue;
00630
00631 JackClientNotificationRequest()
00632 {}
00633 JackClientNotificationRequest(int refnum, int notify, int value)
00634 : JackRequest(JackRequest::kNotification), fRefNum(refnum), fNotify(notify), fValue(value)
00635 {}
00636
00637 int Read(JackChannelTransaction* trans)
00638 {
00639 CheckRes(trans->Read(&fRefNum, sizeof(int)));
00640 CheckRes(trans->Read(&fNotify, sizeof(int)));
00641 CheckRes(trans->Read(&fValue, sizeof(int)));
00642 return 0;
00643 }
00644
00645 int Write(JackChannelTransaction* trans)
00646 {
00647 CheckRes(JackRequest::Write(trans));
00648 CheckRes(trans->Write(&fRefNum, sizeof(int)));
00649 CheckRes(trans->Write(&fNotify, sizeof(int)));
00650 CheckRes(trans->Write(&fValue, sizeof(int)));
00651 return 0;
00652 }
00653
00654 };
00655
00660 struct JackClientNotification
00661 {
00662 char fName[JACK_CLIENT_NAME_SIZE + 1];
00663 int fRefNum;
00664 int fNotify;
00665 int fValue;
00666 int fSync;
00667
00668 JackClientNotification(): fNotify( -1), fValue( -1)
00669 {}
00670 JackClientNotification(const char* name, int refnum, int notify, int sync, int value)
00671 : fRefNum(refnum), fNotify(notify), fValue(value), fSync(sync)
00672 {
00673 snprintf(fName, sizeof(fName), "%s", name);
00674 }
00675
00676 int Read(JackChannelTransaction* trans)
00677 {
00678 CheckRes(trans->Read(&fName, JACK_CLIENT_NAME_SIZE + 1));
00679 CheckRes(trans->Read(&fRefNum, sizeof(int)));
00680 CheckRes(trans->Read(&fNotify, sizeof(int)));
00681 CheckRes(trans->Read(&fValue, sizeof(int)));
00682 CheckRes(trans->Read(&fSync, sizeof(int)));
00683 return 0;
00684 }
00685
00686 int Write(JackChannelTransaction* trans)
00687 {
00688 CheckRes(trans->Write(&fName, JACK_CLIENT_NAME_SIZE + 1));
00689 CheckRes(trans->Write(&fRefNum, sizeof(int)));
00690 CheckRes(trans->Write(&fNotify, sizeof(int)));
00691 CheckRes(trans->Write(&fValue, sizeof(int)));
00692 CheckRes(trans->Write(&fSync, sizeof(int)));
00693 return 0;
00694 }
00695
00696 };
00697
00698 }
00699
00700 #endif