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 } }