struct itbl_entry *
itbl_add_reg (int yyprocessor, int yytype, char *regname,
int regnum)
{
return alloc_entry (get_processor (yyprocessor), get_type (yytype), regname,
(unsigned long) regnum);
}
int
itbl_disassemble (char *s, unsigned long insn)
{
e_processor processor;
struct itbl_entry *e;
struct itbl_field *f;
if (!ITBL_IS_INSN (insn))
return 0; /* error */
processor = get_processor (ITBL_DECODE_PNUM (insn));
/* find entry in list */
e = find_entry_byval (processor, e_insn, insn, 0);
if (!e)
return 0; /* opcode not in table; invalid instruction */
strcpy (s, e->name);
/* Parse insn's args (if any). */
for (f = e->fields; f; f = f->next) /* for each arg, ... */
{
struct itbl_entry *r;
unsigned long value;
char s_value[20];
if (f == e->fields) /* First operand is preceded by tab. */
strcat (s, "\t");
else /* ','s separate following operands. */
strcat (s, ",");
value = extract_range (insn, f->range);
/* n should be in form $n or 0xhhh (are symbol names valid?? */
switch (f->type)
{
case e_dreg:
case e_creg:
case e_greg:
/* Accept either a string name
or '$' followed by the register number. */
r = find_entry_byval (e->processor, f->type, value, &f->range);
if (r)
strcat (s, r->name);
else
{
sprintf (s_value, "$%lu", value);
strcat (s, s_value);
}
break;
case e_addr:
/* Use assembler's symbol table to find symbol. */
/* FIXME!! Do we need this? If so, what about relocs?? */
/* If not a symbol, fall through to IMMED. */
case e_immed:
sprintf (s_value, "0x%lx", value);
strcat (s, s_value);
break;
default:
return 0; /* error; invalid field spec */
}
}
return 1; /* Done! */
}
void ColorSpaceManager::to_scene_linear(ustring colorspace,
T *pixels,
size_t width,
size_t height,
size_t depth,
bool compress_as_srgb)
{
#ifdef WITH_OCIO
const OCIO::Processor *processor = (const OCIO::Processor *)get_processor(colorspace);
if (processor) {
if (compress_as_srgb) {
/* Compress output as sRGB. */
for (size_t z = 0; z < depth; z++) {
processor_apply_pixels<T, true>(processor, &pixels[z * width * height], width, height);
}
}
else {
/* Write output as scene linear directly. */
for (size_t z = 0; z < depth; z++) {
processor_apply_pixels<T>(processor, &pixels[z * width * height], width, height);
}
}
}
#else
(void)colorspace;
(void)pixels;
(void)width;
(void)height;
(void)depth;
(void)compress_as_srgb;
#endif
}
struct itbl_entry *
itbl_add_insn (int yyprocessor, char *name, unsigned long value,
int sbit, int ebit, unsigned long flags)
{
struct itbl_entry *e;
e = alloc_entry (get_processor (yyprocessor), e_insn, name, value);
if (e)
{
e->range.sbit = sbit;
e->range.ebit = ebit;
e->flags = flags;
itbl_num_opcodes++;
}
return e;
}
request_handler
(
apache::thrift::server::TServer& server,
boost::shared_ptr<apache::thrift::transport::TTransport> input,
boost::shared_ptr<apache::thrift::transport::TTransport> output
) : event_handler( server.getEventHandler() )
{
inputTransport = server.getInputTransportFactory()->getTransport( input );
outputTransport = server.getOutputTransportFactory()->getTransport( output );
inputProtocol = server.getInputProtocolFactory()->getProtocol( inputTransport );
outputProtocol = server.getOutputProtocolFactory()->getProtocol( outputTransport );
if ( event_handler )
conn_ctx = event_handler->createContext( inputProtocol, outputProtocol );
else
#ifdef BOOST_NO_CXX11_NULLPTR
conn_ctx = 0;
#else
conn_ctx = nullptr;
#endif
processor = get_processor( server, inputProtocol, outputProtocol, inputTransport );
}
void ColorSpaceManager::is_builtin_colorspace(ustring colorspace,
bool &is_scene_linear,
bool &is_srgb)
{
#ifdef WITH_OCIO
const OCIO::Processor *processor = (const OCIO::Processor *)get_processor(colorspace);
if (!processor) {
is_scene_linear = false;
is_srgb = false;
return;
}
is_scene_linear = true;
is_srgb = true;
for (int i = 0; i < 256; i++) {
float v = i / 255.0f;
float cR[3] = {v, 0, 0};
float cG[3] = {0, v, 0};
float cB[3] = {0, 0, v};
float cW[3] = {v, v, v};
processor->applyRGB(cR);
processor->applyRGB(cG);
processor->applyRGB(cB);
processor->applyRGB(cW);
/* Make sure that there is no channel crosstalk. */
if (fabsf(cR[1]) > 1e-5f || fabsf(cR[2]) > 1e-5f || fabsf(cG[0]) > 1e-5f ||
fabsf(cG[2]) > 1e-5f || fabsf(cB[0]) > 1e-5f || fabsf(cB[1]) > 1e-5f) {
is_scene_linear = false;
is_srgb = false;
break;
}
/* Make sure that the three primaries combine linearly. */
if (!compare_floats(cR[0], cW[0], 1e-6f, 64) || !compare_floats(cG[1], cW[1], 1e-6f, 64) ||
!compare_floats(cB[2], cW[2], 1e-6f, 64)) {
is_scene_linear = false;
is_srgb = false;
break;
}
/* Make sure that the three channels behave identically. */
if (!compare_floats(cW[0], cW[1], 1e-6f, 64) || !compare_floats(cW[1], cW[2], 1e-6f, 64)) {
is_scene_linear = false;
is_srgb = false;
break;
}
float out_v = average(make_float3(cW[0], cW[1], cW[2]));
if (!compare_floats(v, out_v, 1e-6f, 64)) {
is_scene_linear = false;
}
if (!compare_floats(color_srgb_to_linear(v), out_v, 1e-6f, 64)) {
is_srgb = false;
}
}
#else
(void)colorspace;
is_scene_linear = false;
is_srgb = false;
#endif
}
ustring ColorSpaceManager::detect_known_colorspace(ustring colorspace,
const char *file_format,
bool is_float)
{
if (colorspace == u_colorspace_auto) {
/* Auto detect sRGB or raw if none specified. */
if (is_float) {
bool srgb = (colorspace == "sRGB" || colorspace == "GammaCorrected" ||
(colorspace.empty() &&
(strcmp(file_format, "png") == 0 || strcmp(file_format, "tiff") == 0 ||
strcmp(file_format, "dpx") == 0 || strcmp(file_format, "jpeg2000") == 0)));
return srgb ? u_colorspace_srgb : u_colorspace_raw;
}
else {
return u_colorspace_srgb;
}
}
else if (colorspace == u_colorspace_srgb || colorspace == u_colorspace_raw) {
/* Builtin colorspaces. */
return colorspace;
}
else {
/* Use OpenColorIO. */
#ifdef WITH_OCIO
{
thread_scoped_lock cache_lock(cache_colorspaces_mutex);
/* Cached lookup. */
if (cached_colorspaces.find(colorspace) != cached_colorspaces.end()) {
return cached_colorspaces[colorspace];
}
}
/* Detect if it matches a simple builtin colorspace. */
bool is_scene_linear, is_srgb;
is_builtin_colorspace(colorspace, is_scene_linear, is_srgb);
thread_scoped_lock cache_lock(cache_colorspaces_mutex);
if (is_scene_linear) {
VLOG(1) << "Colorspace " << colorspace.string() << " is no-op";
cached_colorspaces[colorspace] = u_colorspace_raw;
return u_colorspace_raw;
}
else if (is_srgb) {
VLOG(1) << "Colorspace " << colorspace.string() << " is sRGB";
cached_colorspaces[colorspace] = u_colorspace_srgb;
return u_colorspace_srgb;
}
/* Verify if we can convert from the requested color space. */
if (!get_processor(colorspace)) {
OCIO::ConstConfigRcPtr config = OCIO::GetCurrentConfig();
if (!config || !config->getColorSpace(colorspace.c_str())) {
VLOG(1) << "Colorspace " << colorspace.c_str() << " not found, using raw instead";
}
else {
VLOG(1) << "Colorspace " << colorspace.c_str()
<< " can't be converted to scene_linear, using raw instead";
}
cached_colorspaces[colorspace] = u_colorspace_raw;
return u_colorspace_raw;
}
/* Convert to/from colorspace with OpenColorIO. */
VLOG(1) << "Colorspace " << colorspace.string() << " handled through OpenColorIO";
cached_colorspaces[colorspace] = colorspace;
return colorspace;
#else
VLOG(1) << "Colorspace " << colorspace.c_str() << " not available, built without OpenColorIO";
return u_colorspace_raw;
#endif
}
}
