Switch commoncpp2 to ucommon to solve dependency conflicts.
libccrtp was depending on commoncpp2, and have been replaced by a version
depending on ucommon as well.
diff --git a/jni/libucommon/sources/corelib/bitmap.cpp b/jni/libucommon/sources/corelib/bitmap.cpp
new file mode 100644
index 0000000..2c7e7c9
--- /dev/null
+++ b/jni/libucommon/sources/corelib/bitmap.cpp
@@ -0,0 +1,162 @@
+// Copyright (C) 2006-2010 David Sugar, Tycho Softworks.
+//
+// This file is part of GNU C++ uCommon.
+//
+// GNU uCommon C++ is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published
+// by the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// GNU uCommon C++ is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with GNU uCommon C++. If not, see <http://www.gnu.org/licenses/>.
+
+#include <ucommon-config.h>
+#include <ucommon/export.h>
+#include <ucommon/bitmap.h>
+#include <stdlib.h>
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+
+using namespace UCOMMON_NAMESPACE;
+
+bitmap::bitmap(size_t count)
+{
+ size_t mem = count / 8;
+ size = count;
+ bus = BMALLOC;
+
+ if(count % 8)
+ ++mem;
+
+ addr.a = ::malloc(mem);
+ clear();
+}
+
+bitmap::bitmap(void *ptr, size_t count, bus_t access)
+{
+ assert(ptr != NULL);
+ assert(access >= BMIN && access <= BMAX);
+ addr.a = ptr;
+ bus = access;
+}
+
+bitmap::~bitmap()
+{
+ if(bus == BMALLOC && addr.b)
+ ::free(addr.b);
+ addr.b = NULL;
+}
+
+unsigned bitmap::memsize(void) const
+{
+ switch(bus) {
+ case B64:
+ return 64;
+ case B32:
+ return 32;
+ case B16:
+ return 16;
+ default:
+ return 8;
+ }
+}
+
+void bitmap::set(size_t offset, bool bit)
+{
+ unsigned bs = memsize();
+ size_t pos = offset / bs;
+ unsigned rem = offset % bs;
+ uint64_t b64;
+ uint32_t b32;
+ uint16_t b16;
+ uint8_t b8;
+
+ if(offset >= size)
+ return;
+
+ switch(bus) {
+ case B64:
+ b64 = ((uint64_t)(1))<<rem;
+ if(bit)
+ addr.d[pos] |= b64;
+ else
+ addr.d[pos] &= ~b64;
+ break;
+ case B32:
+ b32 = 1<<rem;
+ if(bit)
+ addr.l[pos] |= b32;
+ else
+ addr.l[pos] &= ~b32;
+ break;
+ case B16:
+ b16 = 1<<rem;
+ if(bit)
+ addr.w[pos] |= b16;
+ else
+ addr.w[pos] &= ~b16;
+ break;
+ default:
+ b8 = 1<<rem;
+ if(bit)
+ addr.b[pos] |= b8;
+ else
+ addr.b[pos] &= ~b8;
+ break;
+ }
+}
+
+bool bitmap::get(size_t offset) const
+{
+ unsigned bs = memsize();
+ size_t pos = offset / bs;
+ unsigned rem = offset % bs;
+
+ if(offset >= size)
+ return false;
+
+ switch(bus) {
+#if !defined(_MSC_VER) || _MSC_VER >= 1400
+ case B64:
+ return (addr.d[pos] & 1ll<<rem) > 0;
+#endif
+ case B32:
+ return (addr.l[pos] & 1l<<rem) > 0;
+ case B16:
+ return (addr.w[pos] & 1<<rem) > 0;
+ default:
+ return (addr.b[pos] & 1<<rem) > 0;
+ }
+}
+
+void bitmap::clear(void)
+{
+ unsigned bs = memsize();
+
+ if(size % bs)
+ ++size;
+
+ while(size--) {
+ switch(bus) {
+#if !defined(_MSC_VER) || _MSC_VER >= 1400
+ case B64:
+ *(addr.d++) = 0ll;
+ break;
+#endif
+ case B32:
+ *(addr.l++) = 0l;
+ break;
+ case B16:
+ *(addr.w++) = 0;
+ break;
+ default:
+ *(addr.b++) = 0;
+ }
+ }
+}