← Back to branch summary

~ubuntu-branches/ubuntu/quantal/jackd2/quantal

« back to all changes in this revision

Viewing changes to .pc/0000_sync_upstream_VCS.patch/posix/JackPosixSemaphore.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Reinhard Tartler, Adrian Knoth, Reinhard Tartler, Jonas Smedegaard
  • Date: 2010-06-19 18:54:29 UTC
  • Revision ID: james.westby@ubuntu.com-20100619185429-zhbhh0mqvukgzx0l
Tags: 1.9.5~dfsg-15
http://bugs.debian.org/586257
[ Adrian Knoth ]
* Also provide the shlibs file for libjack-jackd2-0
* Fix FTBFS on sparc64 (Closes: #586257)

[ Reinhard Tartler ]
* jackd must not be a virtual package, use 'jack-daemon' for that
* add breaks/replaces on old libjack0
* change shlibsfile to prefer jackd2's libjack
* use conflicts instead of breaks. libjack-jackd2-0 has file conflicts
  with libjack0 and will keep it

[ Jonas Smedegaard ]
* Update control file.

Show diffs side-by-side

added added

removed removed

Lines of Context:
.pc/0000_sync_upstream_VCS.patch/posix/JackPosixSemaphore.cpp
 
1
/*
 
2
Copyright (C) 2004-2008 Grame
 
3
 
 
4
This program is free software; you can redistribute it and/or modify
 
5
it under the terms of the GNU Lesser General Public License as published by
 
6
the Free Software Foundation; either version 2.1 of the License, or
 
7
(at your option) any later version.
 
8
 
 
9
This program is distributed in the hope that it will be useful,
 
10
but WITHOUT ANY WARRANTY; without even the implied warranty of
 
11
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
12
GNU Lesser General Public License for more details.
 
13
 
 
14
You should have received a copy of the GNU Lesser General Public License
 
15
along with this program; if not, write to the Free Software
 
16
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 
17
 
 
18
*/
 
19
 
 
20
#include "JackPosixSemaphore.h"
 
21
#include "JackTools.h"
 
22
#include "JackConstants.h"
 
23
#include "JackError.h"
 
24
#include <fcntl.h>
 
25
#include <stdio.h>
 
26
#include <sys/time.h>
 
27
 
 
28
namespace Jack
 
29
{
 
30
 
 
31
void JackPosixSemaphore::BuildName(const char* client_name, const char* server_name, char* res)
 
32
{
 
33
    char ext_client_name[JACK_CLIENT_NAME_SIZE + 1];
 
34
    JackTools::RewriteName(client_name, ext_client_name);
 
35
    sprintf(res, "jack_sem.%d_%s_%s", JackTools::GetUID(), server_name, ext_client_name);
 
36
}
 
37
 
 
38
bool JackPosixSemaphore::Signal()
 
39
{
 
40
    int res;
 
41
 
 
42
    if (!fSemaphore) {
 
43
        jack_error("JackPosixSemaphore::Signal name = %s already desallocated!!", fName);
 
44
        return false;
 
45
    }
 
46
 
 
47
    if (fFlush)
 
48
        return true;
 
49
 
 
50
    if ((res = sem_post(fSemaphore)) != 0) {
 
51
        jack_error("JackPosixSemaphore::Signal name = %s err = %s", fName, strerror(errno));
 
52
    }
 
53
    return (res == 0);
 
54
}
 
55
 
 
56
bool JackPosixSemaphore::SignalAll()
 
57
{
 
58
    int res;
 
59
 
 
60
    if (!fSemaphore) {
 
61
        jack_error("JackPosixSemaphore::SignalAll name = %s already desallocated!!", fName);
 
62
        return false;
 
63
    }
 
64
 
 
65
    if (fFlush)
 
66
        return true;
 
67
 
 
68
    if ((res = sem_post(fSemaphore)) != 0) {
 
69
        jack_error("JackPosixSemaphore::SignalAll name = %s err = %s", fName, strerror(errno));
 
70
    }
 
71
    return (res == 0);
 
72
}
 
73
 
 
74
/*
 
75
bool JackPosixSemaphore::Wait()
 
76
{
 
77
    int res;
 
78
 
 
79
    if (!fSemaphore) {
 
80
        jack_error("JackPosixSemaphore::Wait name = %s already desallocated!!", fName);
 
81
        return false;
 
82
    }
 
83
 
 
84
    if ((res = sem_wait(fSemaphore)) != 0) {
 
85
        jack_error("JackPosixSemaphore::Wait name = %s err = %s", fName, strerror(errno));
 
86
    }
 
87
    return (res == 0);
 
88
}
 
89
*/
 
90
 
 
91
bool JackPosixSemaphore::Wait()
 
92
{
 
93
    int res;
 
94
 
 
95
    while ((res = sem_wait(fSemaphore) < 0)) {
 
96
        jack_error("JackPosixSemaphore::Wait name = %s err = %s", fName, strerror(errno));
 
97
        if (errno != EINTR)
 
98
            break;
 
99
    }
 
100
    return (res == 0);
 
101
}
 
102
 
 
103
#if (_POSIX_C_SOURCE >= 200112L || _XOPEN_SOURCE >= 600) // glibc feature test
 
104
 
 
105
bool JackPosixSemaphore::TimedWait(long usec) 
 
106
{
 
107
        int res;
 
108
        struct timeval now;
 
109
        timespec time;
 
110
 
 
111
        if (!fSemaphore) {
 
112
                jack_error("JackPosixSemaphore::TimedWait name = %s already desallocated!!", fName);
 
113
                return false;
 
114
        }
 
115
        gettimeofday(&now, 0);
 
116
        time.tv_sec = now.tv_sec + usec / 1000000;
 
117
    long tv_usec = (now.tv_usec + (usec % 1000000));
 
118
    time.tv_sec += tv_usec / 1000000;
 
119
    time.tv_nsec = (tv_usec % 1000000) * 1000;
 
120
 
 
121
    if ((res = sem_timedwait(fSemaphore, &time)) != 0) {
 
122
        jack_error("JackPosixSemaphore::TimedWait err = %s", strerror(errno));
 
123
        jack_log("now %ld %ld ", now.tv_sec, now.tv_usec);
 
124
        jack_log("next %ld %ld ", time.tv_sec, time.tv_nsec/1000);
 
125
    }
 
126
    return (res == 0);
 
127
}
 
128
 
 
129
#else
 
130
#warning "JackPosixSemaphore::TimedWait is not supported: Jack in SYNC mode with JackPosixSemaphore will not run properly !!"
 
131
 
 
132
bool JackPosixSemaphore::TimedWait(long usec)
 
133
{
 
134
        return Wait();
 
135
}
 
136
#endif
 
137
 
 
138
// Server side : publish the semaphore in the global namespace
 
139
bool JackPosixSemaphore::Allocate(const char* name, const char* server_name, int value)
 
140
{
 
141
    BuildName(name, server_name, fName);
 
142
    jack_log("JackPosixSemaphore::Allocate name = %s val = %ld", fName, value);
 
143
 
 
144
    if ((fSemaphore = sem_open(fName, O_CREAT, 0777, value)) == (sem_t*)SEM_FAILED) {
 
145
        jack_error("Allocate: can't check in named semaphore name = %s err = %s", fName, strerror(errno));
 
146
        return false;
 
147
    } else {
 
148
        return true;
 
149
    }
 
150
}
 
151
 
 
152
// Client side : get the published semaphore from server
 
153
bool JackPosixSemaphore::ConnectInput(const char* name, const char* server_name)
 
154
{
 
155
    BuildName(name, server_name, fName);
 
156
    jack_log("JackPosixSemaphore::Connect %s", fName);
 
157
 
 
158
    // Temporary...
 
159
    if (fSemaphore) {
 
160
        jack_log("Already connected name = %s", name);
 
161
        return true;
 
162
    }
 
163
 
 
164
    if ((fSemaphore = sem_open(fName, O_CREAT)) == (sem_t*)SEM_FAILED) {
 
165
        jack_error("Connect: can't connect named semaphore name = %s err = %s", fName, strerror(errno));
 
166
        return false;
 
167
    } else {
 
168
        int val = 0;
 
169
        sem_getvalue(fSemaphore, &val);
 
170
        jack_log("JackPosixSemaphore::Connect sem_getvalue %ld", val);
 
171
        return true;
 
172
    }
 
173
}
 
174
 
 
175
bool JackPosixSemaphore::Connect(const char* name, const char* server_name)
 
176
{
 
177
    return ConnectInput(name, server_name);
 
178
}
 
179
 
 
180
bool JackPosixSemaphore::ConnectOutput(const char* name, const char* server_name)
 
181
{
 
182
    return ConnectInput(name, server_name);
 
183
}
 
184
 
 
185
bool JackPosixSemaphore::Disconnect()
 
186
{
 
187
    jack_log("JackPosixSemaphore::Disconnect %s", fName);
 
188
 
 
189
    if (fSemaphore) {
 
190
        if (sem_close(fSemaphore) != 0) {
 
191
            jack_error("Disconnect: can't disconnect named semaphore name = %s err = %s", fName, strerror(errno));
 
192
            return false;
 
193
        } else {
 
194
            fSemaphore = NULL;
 
195
            return true;
 
196
        }
 
197
    } else {
 
198
        return true;
 
199
    }
 
200
}
 
201
 
 
202
// Server side : destroy the semaphore
 
203
void JackPosixSemaphore::Destroy()
 
204
{
 
205
    if (fSemaphore != NULL) {
 
206
        jack_log("JackPosixSemaphore::Destroy");
 
207
        sem_unlink(fName);
 
208
        if (sem_close(fSemaphore) != 0) {
 
209
            jack_error("Destroy: can't destroy semaphore name = %s err = %s", fName, strerror(errno));
 
210
        }
 
211
        fSemaphore = NULL;
 
212
    } else {
 
213
        jack_error("JackPosixSemaphore::Destroy semaphore == NULL");
 
214
    }
 
215
}
 
216
 
 
217
} // end of namespace
 
218