Ref<Image> Image::load_from_data (const Ptr<IData> data) {
static Stopwatch t;
static unsigned count = 0; ++count;
Ref<Image> loaded_image;
Shared<Buffer> buffer;
t.start();
buffer = data->buffer();
switch (buffer->mimetype()) {
case IMAGE_JPEG:
loaded_image = load_jpeg_image(data);
break;
case IMAGE_PNG:
loaded_image = load_png_image(data);
break;
//case Data::IMAGE_DDS:
// loaded_image = load_ddsimage(data);
default:
logger()->log(LOG_ERROR, "Could not load image: Unsupported image format.");
}
t.pause();
logger()->log(LOG_INFO, LogBuffer() << "*** Total time to load " << count << " images: " << t.time() << "s");
return loaded_image;
}
void ns2ClassA_memberFunction_9(int nargout, mxArray *out[], int nargin, const mxArray *in[])
{
typedef boost::shared_ptr<ns2::ClassA> Shared;
checkArguments("memberFunction",nargout,nargin-1,0);
Shared obj = unwrap_shared_ptr<ns2::ClassA>(in[0], "ptr_ns2ClassA");
out[0] = wrap< double >(obj->memberFunction());
}
CC_FILE_ERROR FileIOFilter::SaveToFile( ccHObject* entities,
const QString& filename,
SaveParameters& parameters,
Shared filter)
{
if (!entities || filename.isEmpty() || !filter)
return CC_FERR_BAD_ARGUMENT;
//if the file name has no extension, we had a default one!
QString completeFileName(filename);
if (QFileInfo(filename).suffix().isEmpty())
completeFileName += QString(".%1").arg(filter->getDefaultExtension());
CC_FILE_ERROR result = CC_FERR_NO_ERROR;
try
{
result = filter->saveToFile(entities, completeFileName, parameters);
}
catch(...)
{
ccLog::Warning(QString("[I/O] CC has caught an unhandled exception while saving file '%1'").arg(filename));
result = CC_FERR_CONSOLE_ERROR;
}
if (result == CC_FERR_NO_ERROR)
{
ccLog::Print(QString("[I/O] File '%1' saved successfully").arg(filename));
}
else
{
DisplayErrorMessage(result,"saving",filename);
}
return result;
}
int main()
{
Shared<Car> a;
auto age1 = a.execute([](Car & c) -> unsigned { return c.increment_age(); });
auto age2 = a.execute([](Car & c) -> unsigned { return c.increment_age(); });
auto age3 = a.execute([](Car & c) -> unsigned { return c.increment_age(); });
std::cout << age1.get() << ", " << age2.get() << ", " << age3.get() << std::endl;
}
void ns2ClassA_nsArg_10(int nargout, mxArray *out[], int nargin, const mxArray *in[])
{
typedef boost::shared_ptr<ns2::ClassA> Shared;
checkArguments("nsArg",nargout,nargin-1,1);
Shared obj = unwrap_shared_ptr<ns2::ClassA>(in[0], "ptr_ns2ClassA");
ns1::ClassB& arg = *unwrap_shared_ptr< ns1::ClassB >(in[1], "ptr_ns1ClassB");
out[0] = wrap< int >(obj->nsArg(arg));
}
/// Create a buffer from a given input stream
BufferedData::BufferedData (std::istream & stream)
{
Shared<DynamicBuffer> buffer = new DynamicBuffer;
buffer->append(std::istreambuf_iterator<char>(stream), std::istreambuf_iterator<char>());
_buffer = buffer;
}
void ns2ClassA_nsReturn_11(int nargout, mxArray *out[], int nargin, const mxArray *in[])
{
typedef boost::shared_ptr<ns2::ns3::ClassB> SharedClassB;
typedef boost::shared_ptr<ns2::ClassA> Shared;
checkArguments("nsReturn",nargout,nargin-1,1);
Shared obj = unwrap_shared_ptr<ns2::ClassA>(in[0], "ptr_ns2ClassA");
double q = unwrap< double >(in[1]);
out[0] = wrap_shared_ptr(SharedClassB(new ns2::ns3::ClassB(obj->nsReturn(q))),"ns2.ns3.ClassB", false);
}
void Dictionary::deserialize (Ref<IData> data)
{
Shared<Buffer> buffer = data->buffer();
std::size_t offset = 0;
while (offset < buffer->size()) {
KeyT key = TypeSerialization<TI_STRING>::read_from_buffer(*buffer, offset);
_values[key] = Value::read_from_buffer(*buffer, offset);
}
}
static Ref<Image> load_jpeg_image (const Ptr<IData> data) {
jpeg_decompress_struct cinfo;
jpeg_error_mgr jerr;
Ref<Image> result_image;
DataType data_type = DataType::BYTE;
Shared<Buffer> buffer = data->buffer();
unsigned width, height;
try {
//memset (&cinfo, 0, sizeof (cinfo));
memset (&jerr, 0, sizeof (jerr));
cinfo.err = jpeg_std_error(&jerr);
jpeg_create_decompress(&cinfo);
jpeg_memory_src(&cinfo, buffer->begin(), buffer->size());
jpeg_read_header(&cinfo, TRUE);
width = cinfo.image_width;
height = cinfo.image_height;
unsigned row_width = 0;
PixelFormat pixel_format;
if (cinfo.jpeg_color_space == JCS_GRAYSCALE) {
row_width = width;
pixel_format = PixelFormat::L;
} else {
row_width = 3 * width;
pixel_format = PixelFormat::RGB;
}
result_image = new Image(Vec2u(width, height), pixel_format, data_type);
ByteT *line = result_image->data();
jpeg_start_decompress(&cinfo);
// read jpeg image
while (cinfo.output_scanline < cinfo.output_height) {
jpeg_read_scanlines(&cinfo, &line, 1);
line += row_width;
}
jpeg_finish_decompress(&cinfo);
jpeg_destroy_decompress(&cinfo);
} catch (std::exception &e) {
}
return result_image;
};
Ref<Object> Sound::Loader::load_from_data (const Ptr<IData> data, const ILoader * loader)
{
Shared<Buffer> buffer = data->buffer();
Mimetype mt = buffer->mimetype();
if (mt == AUDIO_XWAV) {
return load_wave_data(data);
} else {
throw LoadError("Could not load audio data");
}
}
int main()
{
Shared shlib;
Static stlib;
std::cout << "Static library subtract(5, 3): ";
std::cout << stlib.subtract(5, 3) << std::endl;
std::cout << "Shared library add(4, 5): ";
std::cout << shlib.add(4, 5) << std::endl;
return EXIT_SUCCESS;
}
Shared<Buffer> Program::info_log() {
GLint length;
property(GL_INFO_LOG_LENGTH, &length);
if (length > 0) {
Shared<MutableBuffer> buffer = PackedBuffer::new_buffer(length);
glGetProgramInfoLog(_handle, length, NULL, (GLchar *)buffer->begin());
return buffer;
} else {
return NULL;
}
}
Shared<ui::Font> FontAsset::createFont() const
{
Shared<Texture2D> atlasTex = Shared<Texture2D>::alloc();
atlasTex->alloc();
atlasTex->set_texels(atlas, 0);
return Shared<ui::Font>::alloc(
std::move(atlasTex),
entries,
defaultEntry,
lineHeight,
tabWidth,
spaceWidth);
}
void init(
const Shared & shared,
const Group & group,
rng_t & rng) {
Shared post = shared.plus_group(group);
mean = sample_gamma(rng, post.alpha, 1.f / post.inv_beta);
}
Future<bool> CoordinatorProcess::checkLearnPhase(const Action& action)
{
// Make sure that the local replica has learned the newly written
// log entry. Since messages are delivered and dispatched in order
// locally, we should always have the new entry learned by now.
return replica->missing(action.position());
}
void init(
const Shared & shared,
const Group & group,
rng_t & rng) {
Shared post = shared.plus_group(group);
beta = sample_beta(rng, post.alpha, post.beta);
}
void setupMappings()
{
char key[256];
if (getpid() != MEMSRV_PID)
{
/* Load the mounts and process table. */
mounts.load(FILE_SYSTEM_MOUNT_KEY, MAX_MOUNTS);
procs.load(USER_PROCESS_KEY, MAX_PROCS);
/* Format FileDescriptor key. */
snprintf(key, sizeof(key), "%s%u", FILE_DESCRIPTOR_KEY, getpid());
/* Then load the FileDescriptor table. */
files.load(key, FILE_DESCRIPTOR_MAX);
}
}
foreach (Owned<Plugin> _plugin, plugins) {
Shared<Plugin> plugin = _plugin.share();
if (pluginsByName.contains(plugin->name())) {
LOG(WARNING) << "Multiple URI fetcher plugins register "
<< "under name '" << plugin->name() << "'";
}
pluginsByName[plugin->name()] = plugin;
foreach (const string& scheme, plugin->schemes()) {
if (pluginsByScheme.contains(scheme)) {
LOG(WARNING) << "Multiple URI fetcher plugins register "
<< "URI scheme '" << scheme << "'";
}
pluginsByScheme[scheme] = plugin;
}
}
float score_data(
const Shared & shared,
rng_t &) const {
Shared post = shared.plus_group(*this);
float score = fast_lgamma(shared.alpha + shared.beta)
- fast_lgamma(post.alpha + post.beta);
score += fast_lgamma(post.alpha) - fast_lgamma(shared.alpha);
score += fast_lgamma(post.beta) - fast_lgamma(shared.beta);
return score;
}
float score_data(
const Shared & shared,
rng_t &) const {
Shared post = shared.plus_group(*this);
float score = fast_lgamma(post.alpha) - fast_lgamma(shared.alpha);
score += shared.alpha * fast_log(shared.inv_beta)
- post.alpha * fast_log(post.inv_beta);
score += -log_prod;
return score;
}
void init(
const Shared & shared,
const Group & group,
rng_t &) {
Shared post = shared.plus_group(group);
score_coeff = -fast_log(1.f + post.inv_beta);
score = -fast_lgamma(post.alpha)
+ post.alpha * (fast_log(post.inv_beta) + score_coeff);
post_alpha = post.alpha;
}
void FileIOFilter::Register(Shared filter)
{
if (!filter)
{
assert(false);
return;
}
//filters are uniquely recognized by their 'file filter' string
QStringList fileFilters = filter->getFileFilters(true);
QString filterName = filter->getDefaultExtension().toUpper();
for (FilterContainer::const_iterator it=s_ioFilters.begin(); it!=s_ioFilters.end(); ++it)
{
bool error = false;
if (*it == filter)
{
ccLog::Warning(QString("[FileIOFilter::Register] I/O filter '%1' is already registered").arg(filterName));
error = true;
}
else
{
//we are going to compare the file filters as they should remain unique!
QStringList otherFilters = (*it)->getFileFilters(true);
for (int i=0; i<fileFilters.size(); ++i)
{
if (otherFilters.contains(fileFilters[i]))
{
QString otherFilterName = (*it)->getDefaultExtension().toUpper();;
ccLog::Warning(QString("[FileIOFilter::Register] Internal error: file filter '%1' of filter '%2' is already handled by another filter ('%3')!").arg(fileFilters[i]).arg(filterName).arg(otherFilterName));
error = true;
break;
}
}
}
if (error)
return;
}
//insert filter
s_ioFilters.push_back(filter);
}
bool Program::link()
{
glLinkProgram(_handle);
GLint status;
property(GL_LINK_STATUS, &status);
glGetProgramiv(_handle, GL_LINK_STATUS, &status);
if (status == 0) {
// Something went wrong...
Shared<Buffer> log = info_log();
LogBuffer buffer;
buffer << "Error linking program:" << std::endl;
buffer << StringT(log->begin(), log->end()) << std::endl;
logger()->log(LOG_ERROR, buffer);
}
return status != 0;
}
void init(
const Shared & shared,
const Group & group,
rng_t &) {
Shared post = shared.plus_group(group);
post_beta = post.beta;
alpha = post.alpha + shared.r;
score = fast_lgamma(post.alpha + post.beta)
- fast_lgamma(post.alpha)
- fast_lgamma(post.beta)
+ fast_lgamma(alpha);
}
TEST(OwnedTest, Share)
{
Foo* foo = new Foo();
foo->set(42);
Owned<Foo> owned(foo);
EXPECT_EQ(42, owned->get());
EXPECT_EQ(42, (*owned).get());
EXPECT_EQ(42, owned.get()->get());
Shared<Foo> shared = owned.share();
EXPECT_EQ(NULL, owned.get());
EXPECT_TRUE(shared.unique());
EXPECT_EQ(42, shared->get());
EXPECT_EQ(42, (*shared).get());
EXPECT_EQ(42, shared.get()->get());
{
Shared<Foo> shared2(shared);
EXPECT_EQ(42, shared2->get());
EXPECT_EQ(42, (*shared2).get());
EXPECT_EQ(42, shared2.get()->get());
EXPECT_FALSE(shared.unique());
EXPECT_FALSE(shared2.unique());
}
EXPECT_TRUE(shared.unique());
}
GLenum ShaderManager::compile(GLenum type, const Buffer * buffer)
{
GLuint shader = glCreateShader(type);
const GLchar * source = (GLchar*)buffer->begin();
GLint length = (GLint)buffer->size();
glShaderSource(shader, 1, &source, &length);
check_graphics_error();
glCompileShader(shader);
check_graphics_error();
GLint log_length;
glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &log_length);
if (log_length > 0) {
Shared<MutableBuffer> buffer = PackedBuffer::new_buffer(log_length);
glGetShaderInfoLog(shader, (GLsizei)buffer->size(), (GLsizei*)&log_length, (GLchar*)buffer->begin());
LogBuffer log_buffer;
log_buffer << "Error compiling shader:" << std::endl;
log_buffer << buffer->begin() << std::endl;
logger()->log(LOG_ERROR, log_buffer);
}
GLint status;
glGetShaderiv(shader, GL_COMPILE_STATUS, &status);
if (status == 0) {
logger()->log(LOG_ERROR, "Shader compilation failed!");
glDeleteShader(shader);
return 0;
}
check_graphics_error();
return shader;
}
float score_value(
const Shared & shared,
const Value & value,
rng_t &) const {
Shared post = shared.plus_group(*this);
float alpha = post.alpha + shared.r;
float beta = post.beta + value;
float score = fast_lgamma(post.alpha + post.beta)
- fast_lgamma(alpha + beta);
score += fast_lgamma(alpha) - fast_lgamma(post.alpha);
score += fast_lgamma(beta) - fast_lgamma(post.beta);
return score;
}
float score_data(
const Shared & shared,
const std::vector<Group> & groups,
rng_t &) const {
const float alpha_part = fast_lgamma(shared.alpha);
const float beta_part = shared.alpha * fast_log(shared.inv_beta);
float score = 0;
for (auto const & group : groups) {
if (group.count) {
Shared post = shared.plus_group(group);
score += fast_lgamma(post.alpha) - alpha_part;
score += beta_part - post.alpha * fast_log(post.inv_beta);
score += -group.log_prod;
}
}
return score;
}
float score_data(
const Shared & shared,
const std::vector<Group> & groups,
rng_t &) const {
const float shared_part = fast_lgamma(shared.alpha + shared.beta)
- fast_lgamma(shared.alpha)
- fast_lgamma(shared.beta);
float score = 0;
for (auto const & group : groups) {
if (group.count) {
Shared post = shared.plus_group(group);
score += fast_lgamma(post.alpha)
+ fast_lgamma(post.beta)
- fast_lgamma(post.alpha + post.beta);
score += shared_part;
}
}
return score;
}
const char * read_bytes (unsigned length) {
unsigned prev_offset = offset;
offset += length;
return (const char*)(buffer->begin() + prev_offset);
}
