void SqliteDatabaseConnector::openDatabase()
{
#if defined(HAVE_SQLITE3_H)
int rc;
if (get_read_write_mode())
{
// attempt to open read-write, no create
rc = sqlite3_open_v2(get_database_filename().c_str(),
&db,
SQLITE_OPEN_READWRITE,
NULL);
if (rc != SQLITE_OK) {
// attempt to open read-write, create
rc = sqlite3_open_v2(get_database_filename().c_str(),
&db,
SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE,
NULL);
logger << WARN << "Created new language model database: " << get_database_filename() << endl;
}
if (rc == SQLITE_OK) {
// create n-gram tables up to specified cardinality if they
// don't yet exist
for (size_t cardinality = 1;
cardinality <= get_cardinality ();
cardinality++)
{
createNgramTable(cardinality);
}
}
}
else
{
// open read-only, no create
rc = sqlite3_open_v2(get_database_filename().c_str(),
&db,
SQLITE_OPEN_READONLY,
NULL);
}
// throw exception if database cannot be opened/created
if (rc != SQLITE_OK) {
std::string error = sqlite3_errmsg(db);
logger << ERROR << "Unable to create/open database: " << get_database_filename() << endl;
throw SqliteDatabaseConnectorException(PRESAGE_SQLITE_OPEN_DATABASE_ERROR, error);
}
#elif defined(HAVE_SQLITE_H)
char* errormsg = 0;
db = sqlite_open(get_database_filename().c_str(), 0, &errormsg);
if (db == 0) {
std::string error;
if (errormsg != 0) {
error = errormsg;
}
#ifdef HAVE_STDLIB_H
free(errormsg);
#endif
logger << ERROR << "Unable to open database: " << get_database_filename() << " : " << endl;
throw SqliteDatabaseConnectorException(error);
}
#endif
}
/**
* Helper function for storing 1D, 2D, 3D whole and subimages into texture
* memory.
* The source of the image data may be user memory or a PBO. In the later
* case, we'll map the PBO, copy from it, then unmap it.
*/
static void
store_texsubimage(struct gl_context *ctx,
struct gl_texture_image *texImage,
GLint xoffset, GLint yoffset, GLint zoffset,
GLint width, GLint height, GLint depth,
GLenum format, GLenum type, const GLvoid *pixels,
const struct gl_pixelstore_attrib *packing,
const char *caller)
{
const GLbitfield mapMode = get_read_write_mode(format, texImage->TexFormat);
const GLenum target = texImage->TexObject->Target;
GLboolean success = GL_FALSE;
GLuint dims, slice, numSlices = 1, sliceOffset = 0;
GLint srcImageStride = 0;
const GLubyte *src;
assert(xoffset + width <= texImage->Width);
assert(yoffset + height <= texImage->Height);
assert(zoffset + depth <= texImage->Depth);
switch (target) {
case GL_TEXTURE_1D:
dims = 1;
break;
case GL_TEXTURE_2D_ARRAY:
case GL_TEXTURE_CUBE_MAP_ARRAY:
case GL_TEXTURE_3D:
dims = 3;
break;
default:
dims = 2;
}
/* get pointer to src pixels (may be in a pbo which we'll map here) */
src = (const GLubyte *)
_mesa_validate_pbo_teximage(ctx, dims, width, height, depth,
format, type, pixels, packing, caller);
if (!src)
return;
/* compute slice info (and do some sanity checks) */
switch (target) {
case GL_TEXTURE_2D:
case GL_TEXTURE_RECTANGLE:
case GL_TEXTURE_CUBE_MAP:
case GL_TEXTURE_EXTERNAL_OES:
/* one image slice, nothing special needs to be done */
break;
case GL_TEXTURE_1D:
assert(height == 1);
assert(depth == 1);
assert(yoffset == 0);
assert(zoffset == 0);
break;
case GL_TEXTURE_1D_ARRAY:
assert(depth == 1);
assert(zoffset == 0);
numSlices = height;
sliceOffset = yoffset;
height = 1;
yoffset = 0;
srcImageStride = _mesa_image_row_stride(packing, width, format, type);
break;
case GL_TEXTURE_2D_ARRAY:
numSlices = depth;
sliceOffset = zoffset;
depth = 1;
zoffset = 0;
srcImageStride = _mesa_image_image_stride(packing, width, height,
format, type);
break;
case GL_TEXTURE_3D:
/* we'll store 3D images as a series of slices */
numSlices = depth;
sliceOffset = zoffset;
srcImageStride = _mesa_image_image_stride(packing, width, height,
format, type);
break;
case GL_TEXTURE_CUBE_MAP_ARRAY:
numSlices = depth;
sliceOffset = zoffset;
srcImageStride = _mesa_image_image_stride(packing, width, height,
format, type);
break;
default:
_mesa_warning(ctx, "Unexpected target 0x%x in store_texsubimage()", target);
return;
}
assert(numSlices == 1 || srcImageStride != 0);
for (slice = 0; slice < numSlices; slice++) {
GLubyte *dstMap;
GLint dstRowStride;
ctx->Driver.MapTextureImage(ctx, texImage,
slice + sliceOffset,
xoffset, yoffset, width, height,
mapMode, &dstMap, &dstRowStride);
if (dstMap) {
/* Note: we're only storing a 2D (or 1D) slice at a time but we need
* to pass the right 'dims' value so that GL_UNPACK_SKIP_IMAGES is
* used for 3D images.
*/
success = _mesa_texstore(ctx, dims, texImage->_BaseFormat,
texImage->TexFormat,
dstRowStride,
&dstMap,
width, height, 1, /* w, h, d */
format, type, src, packing);
ctx->Driver.UnmapTextureImage(ctx, texImage, slice + sliceOffset);
}
src += srcImageStride;
if (!success)
break;
}
if (!success)
_mesa_error(ctx, GL_OUT_OF_MEMORY, "%s", caller);
_mesa_unmap_teximage_pbo(ctx, packing);
}
