android/JackAndroidSemaphore.cpp

   1 /*
   2 Copyright (C) 2004-2008 Grame
   3 Copyright (C) 2013 Samsung Electronics
   4
   5 This program is free software; you can redistribute it and/or modify
   6 it under the terms of the GNU Lesser General Public License as published by
   7 the Free Software Foundation; either version 2.1 of the License, or
   8 (at your option) any later version.
   9
  10 This program is distributed in the hope that it will be useful,
  11 but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 GNU Lesser General Public License for more details.
  14
  15 You should have received a copy of the GNU Lesser General Public License
  16 along with this program; if not, write to the Free Software
  17 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  18
  19 */
  20
  21 #include "JackAndroidSemaphore.h"
  22 #include "JackTools.h"
  23 #include "JackConstants.h"
  24 #include "JackError.h"
  25 #include <fcntl.h>
  26 #include <stdio.h>
  27 #include <sys/time.h>
  28 #include "IAndroidShm.h"
  29 #include "shm.h"
  30 #include "android/Shm.h"  //android extension of shm.h
  31
  32 namespace Jack
  33 {
  34
  35 pthread_mutex_t JackAndroidSemaphore::mutex = PTHREAD_MUTEX_INITIALIZER;
  36
  37 void JackAndroidSemaphore::BuildName(const char* client_name, const char* server_name, char* res, int size)
  38 {
  39     char ext_client_name[SYNC_MAX_NAME_SIZE + 1];
  40     JackTools::RewriteName(client_name, ext_client_name);
  41     if (getenv("JACK_PROMISCUOUS_SERVER")) {
  42         snprintf(res, size, "jack_sem.%s_%s", server_name, ext_client_name);
  43     } else {
  44         snprintf(res, size, "jack_sem.%d_%s_%s", JackTools::GetUID(), server_name, ext_client_name);
  45     }
  46 }
  47
  48 bool JackAndroidSemaphore::Signal()
  49 {
  50     int res;
  51
  52     if (!fSemaphore) {
  53         jack_error("JackAndroidSemaphore::Signal name = %s already deallocated!!", fName);
  54         return false;
  55     }
  56
  57     if (fFlush)
  58         return true;
  59
  60     if ((res = sem_post(fSemaphore)) != 0) {
  61         jack_error("JackAndroidSemaphore::Signal name = %s err = %s", fName, strerror(errno));
  62     }
  63     return (res == 0);
  64 }
  65
  66 bool JackAndroidSemaphore::SignalAll()
  67 {
  68     int res;
  69
  70     if (!fSemaphore) {
  71         jack_error("JackAndroidSemaphore::SignalAll name = %s already deallocated!!", fName);
  72         return false;
  73     }
  74
  75     if (fFlush)
  76         return true;
  77
  78     if ((res = sem_post(fSemaphore)) != 0) {
  79         jack_error("JackAndroidSemaphore::SignalAll name = %s err = %s", fName, strerror(errno));
  80     }
  81     return (res == 0);
  82 }
  83
  84 /*
  85 bool JackAndroidSemaphore::Wait()
  86 {
  87     int res;
  88
  89     if (!fSemaphore) {
  90         jack_error("JackAndroidSemaphore::Wait name = %s already deallocated!!", fName);
  91         return false;
  92     }
  93
  94     if ((res = sem_wait(fSemaphore)) != 0) {
  95         jack_error("JackAndroidSemaphore::Wait name = %s err = %s", fName, strerror(errno));
  96     }
  97     return (res == 0);
  98 }
  99 */
 100
 101 bool JackAndroidSemaphore::Wait()
 102 {
 103     int res;
 104
 105     while ((res = sem_wait(fSemaphore) < 0)) {
 106         jack_error("JackAndroidSemaphore::Wait name = %s err = %s", fName, strerror(errno));
 107         if (errno != EINTR) {
 108             break;
 109         }
 110     }
 111     return (res == 0);
 112 }
 113
 114 bool JackAndroidSemaphore::TimedWait(long usec)
 115 {
 116     int res;
 117     struct timeval now;
 118     timespec time;
 119
 120     if (!fSemaphore) {
 121         jack_error("JackAndroidSemaphore::TimedWait name = %s already deallocated!!", fName);
 122         return false;
 123     }
 124     gettimeofday(&now, 0);
 125     time.tv_sec = now.tv_sec + usec / 1000000;
 126     long tv_usec = (now.tv_usec + (usec % 1000000));
 127     time.tv_sec += tv_usec / 1000000;
 128     time.tv_nsec = (tv_usec % 1000000) * 1000;
 129
 130     while ((res = sem_timedwait(fSemaphore, &time)) < 0) {
 131         jack_error("JackAndroidSemaphore::TimedWait err = %s", strerror(errno));
 132         jack_log("JackAndroidSemaphore::TimedWait now : %ld %ld ", now.tv_sec, now.tv_usec);
 133         jack_log("JackAndroidSemaphore::TimedWait next : %ld %ld ", time.tv_sec, time.tv_nsec/1000);
 134         if (errno == ETIMEDOUT) {
 135             timespec ts;
 136             clock_gettime(CLOCK_REALTIME, &ts);
 137             ts.tv_sec = time.tv_sec - ts.tv_sec;
 138             ts.tv_nsec = time.tv_nsec - ts.tv_nsec;
 139             if (ts.tv_nsec < 0) {
 140                 ts.tv_nsec += 1000000000;
 141                 ts.tv_sec  -= 1;
 142             }
 143             if (ts.tv_sec < 0 || ts.tv_nsec < 0) {
 144                 jack_error("JackAndroidSemaphore::TimedWait time may changed or client killed already! wait again!");
 145                 gettimeofday(&now, 0);
 146                 time.tv_sec = now.tv_sec + usec / 1000000;
 147                 long tv_usec = (now.tv_usec + (usec % 1000000));
 148                 time.tv_sec += tv_usec / 1000000;
 149                 time.tv_nsec = (tv_usec % 1000000) * 1000;
 150                 if ((res = sem_timedwait(fSemaphore, &time)) < 0) {
 151                     jack_error("JackAndroidSemaphore::TimedWait err = %s", strerror(errno));
 152                     jack_log("JackAndroidSemaphore::TimedWait now : %ld %ld ", now.tv_sec, now.tv_usec);
 153                     jack_log("JackAndroidSemaphore::TimedWait next : %ld %ld ", time.tv_sec, time.tv_nsec/1000);
 154                 }
 155             }
 156         }
 157         if (errno != EINTR) {
 158             break;
 159         }
 160     }
 161     return (res == 0);
 162 }
 163
 164 // Server side : publish the semaphore in the global namespace
 165 bool JackAndroidSemaphore::Allocate(const char* name, const char* server_name, int value)
 166 {
 167     pthread_mutex_lock (&mutex);
 168     BuildName(name, server_name, fName, sizeof(fName));
 169     jack_log("JackAndroidSemaphore::Allocate name = %s val = %ld", fName, value);
 170
 171         android::sp<android::IAndroidShm> service = android::Shm::getShmService();
 172         if(service == NULL){
 173                 jack_error("shm service is null");
 174                 return false;
 175         }
 176     fSemaphoreMemory = service->InitSemaphore(fName);
 177     if(fSemaphoreMemory != NULL){
 178         fSemaphore = (sem_t*)(fSemaphoreMemory->getBase());
 179     }
 180
 181     if(fSemaphore == NULL) {
 182         jack_error("Allocate: can't check in named semaphore name = %s err = %s", fName, strerror(errno));
 183         pthread_mutex_unlock (&mutex);
 184         return false;
 185     } else {
 186         sem_init(fSemaphore, 1, 0);
 187         jack_log("sem_init()");
 188         pthread_mutex_unlock (&mutex);
 189         return true;
 190     }
 191 }
 192
 193 // Client side : get the published semaphore from server
 194 bool JackAndroidSemaphore::ConnectInput(const char* name, const char* server_name)
 195 {
 196     pthread_mutex_lock (&mutex);
 197     BuildName(name, server_name, fName, sizeof(fName));
 198     jack_log("JackAndroidSemaphore::Connect name = %s", fName);
 199
 200     // Temporary...
 201     if (fSemaphore) {
 202         jack_log("Already connected name = %s", name);
 203         pthread_mutex_unlock (&mutex);
 204         return true;
 205     }
 206
 207         android::sp<android::IAndroidShm> service = android::Shm::getShmService();
 208         if(service == NULL){
 209                 jack_error("shm service is null");
 210                 return false;
 211         }
 212
 213     fSemaphoreMemory = service->InitSemaphore(fName);
 214     if(fSemaphoreMemory != NULL){
 215         fSemaphore = (sem_t*)(fSemaphoreMemory->getBase());
 216     }
 217
 218     if(fSemaphore == NULL) {
 219         jack_error("Connect: can't connect named semaphore name = %s err = %s", fName, strerror(errno));
 220         pthread_mutex_unlock (&mutex);
 221         return false;
 222     } else {
 223         int val = 0;
 224         sem_getvalue(fSemaphore, &val);
 225         jack_log("JackAndroidSemaphore::Connect sem_getvalue %ld", val);
 226         pthread_mutex_unlock (&mutex);
 227         return true;
 228     }
 229 }
 230
 231 bool JackAndroidSemaphore::Connect(const char* name, const char* server_name)
 232 {
 233     return ConnectInput(name, server_name);
 234 }
 235
 236 bool JackAndroidSemaphore::ConnectOutput(const char* name, const char* server_name)
 237 {
 238     return ConnectInput(name, server_name);
 239 }
 240
 241 bool JackAndroidSemaphore::Disconnect()
 242 {
 243     if (fSemaphore) {
 244         jack_log("JackAndroidSemaphore::Disconnect name = %s", fName);
 245         fSemaphore = NULL;
 246     }
 247     return true;
 248 }
 249
 250 // Server side : destroy the semaphore
 251 void JackAndroidSemaphore::Destroy()
 252 {
 253     if (fSemaphore != NULL) {
 254         jack_log("JackAndroidSemaphore::Disconnect name = %s", fName);
 255         fSemaphore = NULL;
 256     } else {
 257         jack_error("JackAndroidSemaphore::Destroy semaphore == NULL");
 258     }
 259 }
 260
 261 } // end of namespace
 262