int assemble_send_targets(pdu_t *pdu, uint8_t *val) { negotiation_parameter_t par; uint8_t *buf; int len; par.key = K_SendTargets; par.list_num = 1; par.val.sval = val; len = parameter_size(&par); if ((buf = malloc(len, M_TEMP, M_WAITOK)) == NULL) { DEBOUT(("*** Out of memory in assemble_send_targets\n")); return ISCSI_STATUS_NO_RESOURCES; } pdu->temp_data = buf; pdu->temp_data_len = len; if (put_parameter(buf, len, &par) == 0) return ISCSI_STATUS_PARAMETER_INVALID; return 0; }
static __inline unsigned put_par_block(uint8_t *buf, unsigned len, negotiation_parameter_t *pars, int n) { unsigned cc; int i; for (cc = 0, i = 0; i < n; i++) { cc += put_parameter(&buf[cc], len - cc, pars++); if (cc >= len) { break; } } return cc; }
status_t get_driver_settings_string(void *_handle, char *buffer, size_t *_bufferSize, bool flat) { settings_handle *handle = (settings_handle *)_handle; size_t bufferSize = *_bufferSize; int32 i; if (!check_handle(handle) || !buffer || *_bufferSize == 0) return B_BAD_VALUE; for (i = 0; i < handle->settings.parameter_count; i++) { put_parameter(&buffer, &bufferSize, &handle->settings.parameters[i], 0, flat); } *_bufferSize -= bufferSize; return bufferSize >= 0 ? B_OK : B_BUFFER_OVERFLOW; }
static bool put_parameter(char **_buffer, size_t *_bufferSize, struct driver_parameter *parameter, int32 level, bool flat) { int32 i; if (!flat) put_level_space(_buffer, _bufferSize, level); put_string(_buffer, _bufferSize, parameter->name); if (flat && parameter->value_count > 0) put_chars(_buffer, _bufferSize, " ="); for (i = 0; i < parameter->value_count; i++) { put_char(_buffer, _bufferSize, ' '); put_string(_buffer, _bufferSize, parameter->values[i]); } if (parameter->parameter_count > 0) { put_chars(_buffer, _bufferSize, " {"); if (!flat) put_char(_buffer, _bufferSize, '\n'); for (i = 0; i < parameter->parameter_count; i++) { put_parameter(_buffer, _bufferSize, ¶meter->parameters[i], level + 1, flat); if (parameter->parameters[i].parameter_count == 0) put_chars(_buffer, _bufferSize, flat ? "; " : "\n"); } if (!flat) put_level_space(_buffer, _bufferSize, level); put_chars(_buffer, _bufferSize, flat ? "}" : "}\n"); } return *_bufferSize >= 0; }
bool TIFFOutput::open (const std::string &name, const ImageSpec &userspec, OpenMode mode) { if (mode == AppendMIPLevel) { error ("%s does not support MIP levels", format_name()); return false; } close (); // Close any already-opened file m_spec = userspec; // Stash the spec // Check for things this format doesn't support if (m_spec.width < 1 || m_spec.height < 1) { error ("Image resolution must be at least 1x1, you asked for %d x %d", m_spec.width, m_spec.height); return false; } if (m_spec.depth < 1) m_spec.depth = 1; // Open the file #ifdef _WIN32 std::wstring wname = Strutil::utf8_to_utf16 (name); m_tif = TIFFOpenW (wname.c_str(), mode == AppendSubimage ? "a" : "w"); #else m_tif = TIFFOpen (name.c_str(), mode == AppendSubimage ? "a" : "w"); #endif if (! m_tif) { error ("Can't open \"%s\" for output.", name.c_str()); return false; } TIFFSetField (m_tif, TIFFTAG_XPOSITION, (float)m_spec.x); TIFFSetField (m_tif, TIFFTAG_YPOSITION, (float)m_spec.y); TIFFSetField (m_tif, TIFFTAG_IMAGEWIDTH, m_spec.width); TIFFSetField (m_tif, TIFFTAG_IMAGELENGTH, m_spec.height); if ((m_spec.full_width != 0 || m_spec.full_height != 0) && (m_spec.full_width != m_spec.width || m_spec.full_height != m_spec.height)) { TIFFSetField (m_tif, TIFFTAG_PIXAR_IMAGEFULLWIDTH, m_spec.full_width); TIFFSetField (m_tif, TIFFTAG_PIXAR_IMAGEFULLLENGTH, m_spec.full_height); } if (m_spec.tile_width) { TIFFSetField (m_tif, TIFFTAG_TILEWIDTH, m_spec.tile_width); TIFFSetField (m_tif, TIFFTAG_TILELENGTH, m_spec.tile_height); } else { // Scanline images must set rowsperstrip TIFFSetField (m_tif, TIFFTAG_ROWSPERSTRIP, 32); } TIFFSetField (m_tif, TIFFTAG_SAMPLESPERPIXEL, m_spec.nchannels); int orientation = m_spec.get_int_attribute("Orientation", 1); TIFFSetField (m_tif, TIFFTAG_ORIENTATION, orientation); int bps, sampformat; switch (m_spec.format.basetype) { case TypeDesc::INT8: bps = 8; sampformat = SAMPLEFORMAT_INT; break; case TypeDesc::UINT8: bps = 8; sampformat = SAMPLEFORMAT_UINT; break; case TypeDesc::INT16: bps = 16; sampformat = SAMPLEFORMAT_INT; break; case TypeDesc::UINT16: bps = 16; sampformat = SAMPLEFORMAT_UINT; break; case TypeDesc::HALF: // Silently change requests for unsupported 'half' to 'float' m_spec.set_format (TypeDesc::FLOAT); case TypeDesc::FLOAT: bps = 32; sampformat = SAMPLEFORMAT_IEEEFP; break; case TypeDesc::DOUBLE: bps = 64; sampformat = SAMPLEFORMAT_IEEEFP; break; default: // Everything else, including UNKNOWN -- default to 8 bit bps = 8; sampformat = SAMPLEFORMAT_UINT; m_spec.set_format (TypeDesc::UINT8); break; } TIFFSetField (m_tif, TIFFTAG_BITSPERSAMPLE, bps); TIFFSetField (m_tif, TIFFTAG_SAMPLEFORMAT, sampformat); int photo = (m_spec.nchannels > 1 ? PHOTOMETRIC_RGB : PHOTOMETRIC_MINISBLACK); TIFFSetField (m_tif, TIFFTAG_PHOTOMETRIC, photo); // ExtraSamples tag if (m_spec.nchannels > 3) { bool unass = m_spec.get_int_attribute("oiio:UnassociatedAlpha", 0); short e = m_spec.nchannels-3; std::vector<unsigned short> extra (e); for (int c = 0; c < e; ++c) { if (m_spec.alpha_channel == (c+3)) extra[c] = unass ? EXTRASAMPLE_UNASSALPHA : EXTRASAMPLE_ASSOCALPHA; else extra[c] = EXTRASAMPLE_UNSPECIFIED; } TIFFSetField (m_tif, TIFFTAG_EXTRASAMPLES, e, &extra[0]); } // Default to LZW compression if no request came with the user spec if (! m_spec.find_attribute("compression")) m_spec.attribute ("compression", "lzw"); ImageIOParameter *param; const char *str = NULL; // Did the user request separate planar configuration? m_planarconfig = PLANARCONFIG_CONTIG; if ((param = m_spec.find_attribute("planarconfig", TypeDesc::STRING)) || (param = m_spec.find_attribute("tiff:planarconfig", TypeDesc::STRING))) { str = *(char **)param->data(); if (str && Strutil::iequals (str, "separate")) { m_planarconfig = PLANARCONFIG_SEPARATE; if (! m_spec.tile_width) { // I can only seem to make separate planarconfig work when // rowsperstrip is 1. TIFFSetField (m_tif, TIFFTAG_ROWSPERSTRIP, 1); } } } TIFFSetField (m_tif, TIFFTAG_PLANARCONFIG, m_planarconfig); // Automatically set date field if the client didn't supply it. if (! m_spec.find_attribute("DateTime")) { time_t now; time (&now); struct tm mytm; Sysutil::get_local_time (&now, &mytm); std::string date = Strutil::format ("%4d:%02d:%02d %2d:%02d:%02d", mytm.tm_year+1900, mytm.tm_mon+1, mytm.tm_mday, mytm.tm_hour, mytm.tm_min, mytm.tm_sec); m_spec.attribute ("DateTime", date); } if (Strutil::iequals (m_spec.get_string_attribute ("oiio:ColorSpace"), "sRGB")) m_spec.attribute ("Exif:ColorSpace", 1); // Deal with all other params for (size_t p = 0; p < m_spec.extra_attribs.size(); ++p) put_parameter (m_spec.extra_attribs[p].name().string(), m_spec.extra_attribs[p].type(), m_spec.extra_attribs[p].data()); std::vector<char> iptc; encode_iptc_iim (m_spec, iptc); if (iptc.size()) { iptc.resize ((iptc.size()+3) & (0xffff-3)); // round up TIFFSetField (m_tif, TIFFTAG_RICHTIFFIPTC, iptc.size()/4, &iptc[0]); } std::string xmp = encode_xmp (m_spec, true); if (! xmp.empty()) TIFFSetField (m_tif, TIFFTAG_XMLPACKET, xmp.size(), xmp.c_str()); TIFFCheckpointDirectory (m_tif); // Ensure the header is written early m_checkpointTimer.start(); // Initialize the to the fileopen time m_checkpointItems = 0; // Number of tiles or scanlines we've written return true; }
bool TIFFOutput::open (const std::string &name, const ImageSpec &userspec, OpenMode mode) { if (mode == AppendMIPLevel) { error ("%s does not support MIP levels", format_name()); return false; } close (); // Close any already-opened file m_spec = userspec; // Stash the spec // Check for things this format doesn't support if (m_spec.width < 1 || m_spec.height < 1) { error ("Image resolution must be at least 1x1, you asked for %d x %d", m_spec.width, m_spec.height); return false; } if (m_spec.tile_width) { if (m_spec.tile_width % 16 != 0 || m_spec.tile_height % 16 != 0 || m_spec.tile_height == 0) { error("Tile size must be a multiple of 16, you asked for %d x %d", m_spec.tile_width, m_spec.tile_height); return false; } } if (m_spec.depth < 1) m_spec.depth = 1; // Open the file #ifdef _WIN32 std::wstring wname = Strutil::utf8_to_utf16 (name); m_tif = TIFFOpenW (wname.c_str(), mode == AppendSubimage ? "a" : "w"); #else m_tif = TIFFOpen (name.c_str(), mode == AppendSubimage ? "a" : "w"); #endif if (! m_tif) { error ("Can't open \"%s\" for output.", name.c_str()); return false; } // N.B. Clamp position at 0... TIFF is internally incapable of having // negative origin. TIFFSetField (m_tif, TIFFTAG_XPOSITION, (float)std::max (0, m_spec.x)); TIFFSetField (m_tif, TIFFTAG_YPOSITION, (float)std::max (0, m_spec.y)); TIFFSetField (m_tif, TIFFTAG_IMAGEWIDTH, m_spec.width); TIFFSetField (m_tif, TIFFTAG_IMAGELENGTH, m_spec.height); if ((m_spec.full_width != 0 || m_spec.full_height != 0) && (m_spec.full_width != m_spec.width || m_spec.full_height != m_spec.height)) { TIFFSetField (m_tif, TIFFTAG_PIXAR_IMAGEFULLWIDTH, m_spec.full_width); TIFFSetField (m_tif, TIFFTAG_PIXAR_IMAGEFULLLENGTH, m_spec.full_height); } if (m_spec.tile_width) { TIFFSetField (m_tif, TIFFTAG_TILEWIDTH, m_spec.tile_width); TIFFSetField (m_tif, TIFFTAG_TILELENGTH, m_spec.tile_height); } else { // Scanline images must set rowsperstrip TIFFSetField (m_tif, TIFFTAG_ROWSPERSTRIP, 32); } TIFFSetField (m_tif, TIFFTAG_SAMPLESPERPIXEL, m_spec.nchannels); int orientation = m_spec.get_int_attribute("Orientation", 1); TIFFSetField (m_tif, TIFFTAG_ORIENTATION, orientation); m_bitspersample = m_spec.get_int_attribute ("oiio:BitsPerSample"); int sampformat; switch (m_spec.format.basetype) { case TypeDesc::INT8: m_bitspersample = 8; sampformat = SAMPLEFORMAT_INT; break; case TypeDesc::UINT8: if (m_bitspersample != 2 && m_bitspersample != 4) m_bitspersample = 8; sampformat = SAMPLEFORMAT_UINT; break; case TypeDesc::INT16: m_bitspersample = 16; sampformat = SAMPLEFORMAT_INT; break; case TypeDesc::UINT16: if (m_bitspersample != 10 && m_bitspersample != 12) m_bitspersample = 16; sampformat = SAMPLEFORMAT_UINT; break; case TypeDesc::INT32: m_bitspersample = 32; sampformat = SAMPLEFORMAT_INT; break; case TypeDesc::UINT32: m_bitspersample = 32; sampformat = SAMPLEFORMAT_UINT; break; case TypeDesc::HALF: #if 0 // Adobe extension, see http://chriscox.org/TIFFTN3d1.pdf // Unfortunately, Nuke 9.0, and probably many other apps we care // about, cannot read 16 bit float TIFFs correctly. Revisit this // again in future releases. (comment added Feb 2015) m_bitspersample = 16; sampformat = SAMPLEFORMAT_IEEEFP; break; #else // Silently change requests for unsupported 'half' to 'float' m_spec.set_format (TypeDesc::FLOAT); #endif case TypeDesc::FLOAT: m_bitspersample = 32; sampformat = SAMPLEFORMAT_IEEEFP; break; case TypeDesc::DOUBLE: m_bitspersample = 64; sampformat = SAMPLEFORMAT_IEEEFP; break; default: // Everything else, including UNKNOWN -- default to 8 bit m_bitspersample = 8; sampformat = SAMPLEFORMAT_UINT; m_spec.set_format (TypeDesc::UINT8); break; } TIFFSetField (m_tif, TIFFTAG_BITSPERSAMPLE, m_bitspersample); TIFFSetField (m_tif, TIFFTAG_SAMPLEFORMAT, sampformat); m_photometric = (m_spec.nchannels > 1 ? PHOTOMETRIC_RGB : PHOTOMETRIC_MINISBLACK); string_view comp = m_spec.get_string_attribute("Compression", "zip"); if (Strutil::iequals (comp, "jpeg") && (m_spec.format != TypeDesc::UINT8 || m_spec.nchannels != 3)) { comp = "zip"; // can't use JPEG for anything but 3xUINT8 } m_compression = tiff_compression_code (comp); TIFFSetField (m_tif, TIFFTAG_COMPRESSION, m_compression); // Use predictor when using compression if (m_compression == COMPRESSION_LZW || m_compression == COMPRESSION_ADOBE_DEFLATE) { if (m_spec.format == TypeDesc::FLOAT || m_spec.format == TypeDesc::DOUBLE || m_spec.format == TypeDesc::HALF) { TIFFSetField (m_tif, TIFFTAG_PREDICTOR, PREDICTOR_FLOATINGPOINT); // N.B. Very old versions of libtiff did not support this // predictor. It's possible that certain apps can't read // floating point TIFFs with this set. But since it's been // documented since 2005, let's take our chances. Comment // out the above line if this is problematic. } else if (m_bitspersample == 8 || m_bitspersample == 16) { // predictors not supported for unusual bit depths (e.g. 10) TIFFSetField (m_tif, TIFFTAG_PREDICTOR, PREDICTOR_HORIZONTAL); } } else if (m_compression == COMPRESSION_JPEG) { TIFFSetField (m_tif, TIFFTAG_JPEGQUALITY, m_spec.get_int_attribute("CompressionQuality", 95)); TIFFSetField (m_tif, TIFFTAG_ROWSPERSTRIP, 64); m_spec.attribute ("tiff:RowsPerStrip", 64); if (m_photometric == PHOTOMETRIC_RGB) { // Compression works so much better when we ask the library to // auto-convert RGB to YCbCr. TIFFSetField (m_tif, TIFFTAG_JPEGCOLORMODE, JPEGCOLORMODE_RGB); m_photometric = PHOTOMETRIC_YCBCR; } } m_outputchans = m_spec.nchannels; if (m_photometric == PHOTOMETRIC_RGB) { // There are a few ways in which we allow allow the user to specify // translation to different photometric types. string_view photo = m_spec.get_string_attribute("tiff:ColorSpace"); if (Strutil::iequals (photo, "CMYK")) { // CMYK: force to 4 channel output, either uint8 or uint16 m_photometric = PHOTOMETRIC_SEPARATED; m_outputchans = 4; TIFFSetField (m_tif, TIFFTAG_SAMPLESPERPIXEL, m_outputchans); if (m_spec.format != TypeDesc::UINT8 || m_spec.format != TypeDesc::UINT16) { m_spec.format = TypeDesc::UINT8; m_bitspersample = 8; TIFFSetField (m_tif, TIFFTAG_BITSPERSAMPLE, m_bitspersample); TIFFSetField (m_tif, TIFFTAG_SAMPLEFORMAT, SAMPLEFORMAT_UINT); } } } TIFFSetField (m_tif, TIFFTAG_PHOTOMETRIC, m_photometric); // ExtraSamples tag if (m_spec.nchannels > 3 && m_photometric != PHOTOMETRIC_SEPARATED) { bool unass = m_spec.get_int_attribute("oiio:UnassociatedAlpha", 0); short e = m_spec.nchannels-3; std::vector<unsigned short> extra (e); for (int c = 0; c < e; ++c) { if (m_spec.alpha_channel == (c+3)) extra[c] = unass ? EXTRASAMPLE_UNASSALPHA : EXTRASAMPLE_ASSOCALPHA; else extra[c] = EXTRASAMPLE_UNSPECIFIED; } TIFFSetField (m_tif, TIFFTAG_EXTRASAMPLES, e, &extra[0]); } ImageIOParameter *param; const char *str = NULL; // Did the user request separate planar configuration? m_planarconfig = PLANARCONFIG_CONTIG; if ((param = m_spec.find_attribute("planarconfig", TypeDesc::STRING)) || (param = m_spec.find_attribute("tiff:planarconfig", TypeDesc::STRING))) { str = *(char **)param->data(); if (str && Strutil::iequals (str, "separate")) m_planarconfig = PLANARCONFIG_SEPARATE; } // Can't deal with the headache of separate image planes when using // bit packing, or CMYK. Just punt by forcing contig in those cases. if (m_bitspersample != spec().format.size()*8 || m_photometric == PHOTOMETRIC_SEPARATED) m_planarconfig = PLANARCONFIG_CONTIG; if (m_planarconfig == PLANARCONFIG_SEPARATE) { if (! m_spec.tile_width) { // I can only seem to make separate planarconfig work when // rowsperstrip is 1. TIFFSetField (m_tif, TIFFTAG_ROWSPERSTRIP, 1); } } TIFFSetField (m_tif, TIFFTAG_PLANARCONFIG, m_planarconfig); // Automatically set date field if the client didn't supply it. if (! m_spec.find_attribute("DateTime")) { time_t now; time (&now); struct tm mytm; Sysutil::get_local_time (&now, &mytm); std::string date = Strutil::format ("%4d:%02d:%02d %2d:%02d:%02d", mytm.tm_year+1900, mytm.tm_mon+1, mytm.tm_mday, mytm.tm_hour, mytm.tm_min, mytm.tm_sec); m_spec.attribute ("DateTime", date); } // Write ICC profile, if we have anything const ImageIOParameter* icc_profile_parameter = m_spec.find_attribute(ICC_PROFILE_ATTR); if (icc_profile_parameter != NULL) { unsigned char *icc_profile = (unsigned char*)icc_profile_parameter->data(); uint32 length = icc_profile_parameter->type().size(); if (icc_profile && length) TIFFSetField (m_tif, TIFFTAG_ICCPROFILE, length, icc_profile); } if (Strutil::iequals (m_spec.get_string_attribute ("oiio:ColorSpace"), "sRGB")) m_spec.attribute ("Exif:ColorSpace", 1); // Deal with missing XResolution or YResolution, or a PixelAspectRatio // that contradicts them. float X_density = m_spec.get_float_attribute ("XResolution", 1.0f); float Y_density = m_spec.get_float_attribute ("YResolution", 1.0f); float aspect = m_spec.get_float_attribute ("PixelAspectRatio", 1.0f); if (X_density < 1.0f || Y_density < 1.0f || aspect*X_density != Y_density) { if (X_density < 1.0f || Y_density < 1.0f) { X_density = Y_density = 1.0f; m_spec.attribute ("ResolutionUnit", "none"); } m_spec.attribute ("XResolution", X_density); m_spec.attribute ("YResolution", X_density * aspect); } // Deal with all other params for (size_t p = 0; p < m_spec.extra_attribs.size(); ++p) put_parameter (m_spec.extra_attribs[p].name().string(), m_spec.extra_attribs[p].type(), m_spec.extra_attribs[p].data()); std::vector<char> iptc; encode_iptc_iim (m_spec, iptc); if (iptc.size()) { iptc.resize ((iptc.size()+3) & (0xffff-3)); // round up TIFFSetField (m_tif, TIFFTAG_RICHTIFFIPTC, iptc.size()/4, &iptc[0]); } std::string xmp = encode_xmp (m_spec, true); if (! xmp.empty()) TIFFSetField (m_tif, TIFFTAG_XMLPACKET, xmp.size(), xmp.c_str()); TIFFCheckpointDirectory (m_tif); // Ensure the header is written early m_checkpointTimer.start(); // Initialize the to the fileopen time m_checkpointItems = 0; // Number of tiles or scanlines we've written m_dither = (m_spec.format == TypeDesc::UINT8) ? m_spec.get_int_attribute ("oiio:dither", 0) : 0; return true; }
bool OpenEXROutput::open (const std::string &name, const ImageSpec &userspec, OpenMode mode) { if (mode == AppendSubimage) { error ("%s does not support subimages", format_name()); return false; } if (mode == AppendMIPLevel && (m_output_scanline || m_output_tiled)) { // Special case for appending to an open file -- we don't need // to close and reopen if (m_spec.tile_width && m_levelmode != Imf::ONE_LEVEL) { // OpenEXR does not support differing tile sizes on different // MIP-map levels. Reject the open() if not using the original // tile sizes. if (userspec.tile_width != m_spec.tile_width || userspec.tile_height != m_spec.tile_height) { error ("OpenEXR tiles must have the same size on all MIPmap levels"); return false; } // Copy the new mip level size. Keep everything else from the // original level. m_spec.width = userspec.width; m_spec.height = userspec.height; // N.B. do we need to copy anything else from userspec? ++m_miplevel; return true; } } m_spec = userspec; // Stash the spec if (m_spec.width < 1 || m_spec.height < 1) { error ("Image resolution must be at least 1x1, you asked for %d x %d", userspec.width, userspec.height); return false; } if (m_spec.depth < 1) m_spec.depth = 1; if (m_spec.depth > 1) { error ("%s does not support volume images (depth > 1)", format_name()); return false; } if (m_spec.full_width <= 0) m_spec.full_width = m_spec.width; if (m_spec.full_height <= 0) m_spec.full_height = m_spec.height; // Force use of one of the three data types that OpenEXR supports switch (m_spec.format.basetype) { case TypeDesc::UINT: m_spec.format = TypeDesc::UINT; break; case TypeDesc::FLOAT: case TypeDesc::DOUBLE: m_spec.format = TypeDesc::FLOAT; break; default: // Everything else defaults to half m_spec.format = TypeDesc::HALF; } Imath::Box2i dataWindow (Imath::V2i (m_spec.x, m_spec.y), Imath::V2i (m_spec.width + m_spec.x - 1, m_spec.height + m_spec.y - 1)); Imath::Box2i displayWindow (Imath::V2i (m_spec.full_x, m_spec.full_y), Imath::V2i (m_spec.full_width+m_spec.full_x-1, m_spec.full_height+m_spec.full_y-1)); m_header = new Imf::Header (displayWindow, dataWindow); // Insert channels into the header. Also give the channels names if // the user botched it. static const char *default_chan_names[] = { "R", "G", "B", "A" }; m_spec.channelnames.resize (m_spec.nchannels); for (int c = 0; c < m_spec.nchannels; ++c) { if (m_spec.channelnames[c].empty()) m_spec.channelnames[c] = (c<4) ? default_chan_names[c] : Strutil::format ("unknown %d", c); TypeDesc format = m_spec.channelformats.size() ? m_spec.channelformats[c] : m_spec.format; Imf::PixelType ptype; switch (format.basetype) { case TypeDesc::UINT: ptype = Imf::UINT; format = TypeDesc::UINT; break; case TypeDesc::FLOAT: case TypeDesc::DOUBLE: ptype = Imf::FLOAT; format = TypeDesc::FLOAT; break; default: // Everything else defaults to half ptype = Imf::HALF; format = TypeDesc::HALF; } #ifdef OPENEXR_VERSION_IS_1_6_OR_LATER // Hint to lossy compression methods that indicates whether // human perception of the quantity represented by this channel // is closer to linear or closer to logarithmic. Compression // methods may optimize image quality by adjusting pixel data // quantization acording to this hint. bool pLinear = Strutil::iequals (m_spec.get_string_attribute ("oiio:ColorSpace", "Linear"), "Linear"); #endif m_pixeltype.push_back (ptype); if (m_spec.channelformats.size()) m_spec.channelformats[c] = format; m_header->channels().insert (m_spec.channelnames[c].c_str(), Imf::Channel(ptype, 1, 1 #ifdef OPENEXR_VERSION_IS_1_6_OR_LATER , pLinear #endif )); } ASSERT (m_pixeltype.size() == (size_t)m_spec.nchannels); // Default to ZIP compression if no request came with the user spec. if (! m_spec.find_attribute("compression")) m_spec.attribute ("compression", "zip"); // Default to increasingY line order, same as EXR. if (! m_spec.find_attribute("openexr:lineOrder")) m_spec.attribute ("openexr:lineOrder", "increasingY"); // Automatically set date field if the client didn't supply it. if (! m_spec.find_attribute("DateTime")) { time_t now; time (&now); struct tm mytm; Sysutil::get_local_time (&now, &mytm); std::string date = Strutil::format ("%4d:%02d:%02d %2d:%02d:%02d", mytm.tm_year+1900, mytm.tm_mon+1, mytm.tm_mday, mytm.tm_hour, mytm.tm_min, mytm.tm_sec); m_spec.attribute ("DateTime", date); } m_nsubimages = 1; m_subimage = 0; m_nmiplevels = 1; m_miplevel = 0; // Figure out if we are a mipmap or an environment map ImageIOParameter *param = m_spec.find_attribute ("textureformat"); const char *textureformat = param ? *(char **)param->data() : NULL; m_levelmode = Imf::ONE_LEVEL; // Default to no MIP-mapping m_roundingmode = m_spec.get_int_attribute ("openexr:roundingmode", Imf::ROUND_DOWN); if (textureformat) { if (Strutil::iequals (textureformat, "Plain Texture")) { m_levelmode = m_spec.get_int_attribute ("openexr:levelmode", Imf::MIPMAP_LEVELS); } else if (Strutil::iequals (textureformat, "CubeFace Environment")) { m_levelmode = m_spec.get_int_attribute ("openexr:levelmode", Imf::MIPMAP_LEVELS); m_header->insert ("envmap", Imf::EnvmapAttribute(Imf::ENVMAP_CUBE)); } else if (Strutil::iequals (textureformat, "LatLong Environment")) { m_levelmode = m_spec.get_int_attribute ("openexr:levelmode", Imf::MIPMAP_LEVELS); m_header->insert ("envmap", Imf::EnvmapAttribute(Imf::ENVMAP_LATLONG)); } else if (Strutil::iequals (textureformat, "Shadow")) { m_levelmode = Imf::ONE_LEVEL; // Force one level for shadow maps } if (m_levelmode == Imf::MIPMAP_LEVELS) { // Compute how many mip levels there will be int w = m_spec.width; int h = m_spec.height; while (w > 1 && h > 1) { if (m_roundingmode == Imf::ROUND_DOWN) { w = w / 2; h = h / 2; } else { w = (w + 1) / 2; h = (h + 1) / 2; } w = std::max (1, w); h = std::max (1, h); ++m_nmiplevels; } } } // Deal with all other params for (size_t p = 0; p < m_spec.extra_attribs.size(); ++p) put_parameter (m_spec.extra_attribs[p].name().string(), m_spec.extra_attribs[p].type(), m_spec.extra_attribs[p].data()); try { m_output_stream = new OpenEXROutputStream (name.c_str()); if (m_spec.tile_width) { m_header->setTileDescription ( Imf::TileDescription (m_spec.tile_width, m_spec.tile_height, Imf::LevelMode(m_levelmode), Imf::LevelRoundingMode(m_roundingmode))); m_output_tiled = new Imf::TiledOutputFile (*m_output_stream, *m_header); } else { m_output_scanline = new Imf::OutputFile (*m_output_stream, *m_header); } } catch (const std::exception &e) { delete m_output_stream; m_output_stream = NULL; error ("OpenEXR exception: %s", e.what()); m_output_scanline = NULL; return false; } if (! m_output_scanline && ! m_output_tiled) { error ("Unknown error opening EXR file"); return false; } return true; }