JackRequest.h

00001 
00002 
00003 /*
00004     Copyright (C) 2001 Paul Davis 
00005  
00006     This program is free software; you can redistribute it and/or modify
00007     it under the terms of the GNU General Public License as published by
00008     the Free Software Foundation; either version 2 of the License, or
00009     (at your option) any later version.
00010  
00011     This program is distributed in the hope that it will be useful,
00012     but WITHOUT ANY WARRANTY; without even the implied warranty of
00013     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00014     GNU General Public License for more details.
00015  
00016     You should have received a copy of the GNU General Public License
00017     along with this program; if not, write to the Free Software
00018     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
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 } // end of namespace
00699 
00700 #endif

Generated on Wed Jan 10 11:42:46 2007 for Jackdmp by  doxygen 1.4.5