.. _fr.inria.openfx.WriteOIIO:

WriteOIIO node
==============

.. raw:: html

   <!-- Do not edit this file! It is generated automatically by Natron itself. -->

|pluginIcon| 

*This documentation is for version 1.0 of WriteOIIO (fr.inria.openfx.WriteOIIO).*

Description
-----------

Write images using OpenImageIO.

OpenImageIO supports writing the following file formats:

BMP (\*.bmp)

Cineon (\*.cin)

DPX (\*.dpx)

FITS (\*.fits)

HDR/RGBE (\*.hdr)

HEIC/HEIF (\*.heic \*.heif)

Icon (\*.ico)

IFF (\*.iff)

JPEG (\*.jpg \*.jpe \*.jpeg \*.jif \*.jfif \*.jfi)

JPEG-2000 (\*.jp2 \*.j2k)

OpenEXR (\*.exr)

Portable Network Graphics (\*.png)

PNM / Netpbm (\*.pbm \*.pgm \*.ppm)

PSD (\*.psd \*.pdd \*.psb)

RLA (\*.rla)

SGI (\*.sgi \*.rgb \*.rgba \*.bw \*.int \*.inta)

Softimage PIC (\*.pic)

Targa (\*.tga \*.tpic)

TIFF (\*.tif \*.tiff \*.tx \*.env \*.sm \*.vsm)

Zfile (\*.zfile)

Inputs
------

+--------+-------------+----------+
| Input  | Description | Optional |
+========+=============+==========+
| Source |             | No       |
+--------+-------------+----------+

Controls
--------

.. tabularcolumns:: |>{\raggedright}p{0.2\columnwidth}|>{\raggedright}p{0.06\columnwidth}|>{\raggedright}p{0.07\columnwidth}|p{0.63\columnwidth}|

.. cssclass:: longtable

 
| Parameter / script name                         | Type    | Default             | Function                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
 
| Output Components / ``outputComponents``        | Choice  | RGBA                | | Map the input layer to this type of components before writing it to the output file.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
|                                                 |         |                     | | **Alpha**                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
|                                                 |         |                     | | **RGB**                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
|                                                 |         |                     | | **RGBA**                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
 
| File / ``filename``                             | N/A     |                     | The output image sequence/video stream file(s). The string must match the following format: path/sequenceName###.ext where the number of # (hashes) will define the number of digits to append to each file. For example path/mySequence###.jpg will be translated to path/mySequence000.jpg, path/mySequence001.jpg, etc. %d printf-like notation can also be used instead of the hashes, for example path/sequenceName%03d.ext will achieve the same than the example aforementioned. there will be at least 2 digits). The file name may not contain any # (hash) in which case it will be overridden everytimes. Views can be specified using the “long” view notation %V or the “short” notation using %v. |
 
| Overwrite / ``overwrite``                       | Boolean | On                  | Overwrite existing files when rendering.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
 
| Format Type / ``formatType``                    | Choice  | Project Format      | | Determines which rectangle of pixels will be written in output.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
|                                                 |         |                     | | **Input Format (input)**: Renders the pixels included in the input format                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
|                                                 |         |                     | | **Project Format (project)**: Renders the pixels included in the project format                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
|                                                 |         |                     | | **Fixed Format (fixed)**: Renders the pixels included in the format indicated by the Format parameter.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
 
| Format / ``NatronParamFormatChoice``            | Choice  | HD 1920x1080        | | The output format to render                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
|                                                 |         |                     | | **PC_Video 640x480 (PC_Video)**                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
|                                                 |         |                     | | **NTSC 720x486 0.91 (NTSC)**                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
|                                                 |         |                     | | **PAL 720x576 1.09 (PAL)**                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
|                                                 |         |                     | | **NTSC_16:9 720x486 1.21 (NTSC_16:9)**                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
|                                                 |         |                     | | **PAL_16:9 720x576 1.46 (PAL_16:9)**                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
|                                                 |         |                     | | **HD_720 1280x720 (HD_720)**                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
|                                                 |         |                     | | **HD 1920x1080 (HD)**                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
|                                                 |         |                     | | **UHD_4K 3840x2160 (UHD_4K)**                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
|                                                 |         |                     | | **1K_Super_35(full-ap) 1024x778 (1K_Super_35(full-ap))**                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
|                                                 |         |                     | | **1K_Cinemascope 914x778 2.00 (1K_Cinemascope)**                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
|                                                 |         |                     | | **2K_Super_35(full-ap) 2048x1556 (2K_Super_35(full-ap))**                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
|                                                 |         |                     | | **2K_Cinemascope 1828x1556 2.00 (2K_Cinemascope)**                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
|                                                 |         |                     | | **2K_DCP 2048x1080 (2K_DCP)**                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
|                                                 |         |                     | | **4K_Super_35(full-ap) 4096x3112 (4K_Super_35(full-ap))**                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
|                                                 |         |                     | | **4K_Cinemascope 3656x3112 2.00 (4K_Cinemascope)**                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
|                                                 |         |                     | | **4K_DCP 4096x2160 (4K_DCP)**                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
|                                                 |         |                     | | **square_256 256x256 (square_256)**                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
|                                                 |         |                     | | **square_512 512x512 (square_512)**                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
|                                                 |         |                     | | **square_1K 1024x1024 (square_1K)**                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
|                                                 |         |                     | | **square_2K 2048x2048 (square_2K)**                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
 
| Clip To RoD / ``clipToRoD``                     | Boolean | On                  | | When checked, the portion of the image written will be the region of definition of the image in input and not the format selected by the Output Format parameter.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
|                                                 |         |                     | | For the EXR file format, this will distinguish the data window (size of the image in input) from the display window (the format specified by Output Format).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
 
| OCIO Config File / ``ocioConfigFile``           | N/A     |                     | OpenColorIO configuration file                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
 
| Input Colorspace / ``ocioInputSpaceIndex``      | Choice  |                     | Input data is taken to be in this colorspace.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
 
| File Colorspace / ``ocioOutputSpaceIndex``      | Choice  |                     | Output data is taken to be in this colorspace.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
 
| key1 / ``key1``                                 | String  |                     | | OCIO Contexts allow you to apply specific LUTs or grades to different shots.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
|                                                 |         |                     | | Here you can specify the context name (key) and its corresponding value.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
|                                                 |         |                     | | Full details of how to set up contexts and add them to your config can be found in the OpenColorIO documentation:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
|                                                 |         |                     | | http://opencolorio.org/userguide/contexts.html                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
 
| value1 / ``value1``                             | String  |                     | | OCIO Contexts allow you to apply specific LUTs or grades to different shots.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
|                                                 |         |                     | | Here you can specify the context name (key) and its corresponding value.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
|                                                 |         |                     | | Full details of how to set up contexts and add them to your config can be found in the OpenColorIO documentation:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
|                                                 |         |                     | | http://opencolorio.org/userguide/contexts.html                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
 
| key2 / ``key2``                                 | String  |                     | | OCIO Contexts allow you to apply specific LUTs or grades to different shots.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
|                                                 |         |                     | | Here you can specify the context name (key) and its corresponding value.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
|                                                 |         |                     | | Full details of how to set up contexts and add them to your config can be found in the OpenColorIO documentation:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
|                                                 |         |                     | | http://opencolorio.org/userguide/contexts.html                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
 
| value2 / ``value2``                             | String  |                     | | OCIO Contexts allow you to apply specific LUTs or grades to different shots.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
|                                                 |         |                     | | Here you can specify the context name (key) and its corresponding value.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
|                                                 |         |                     | | Full details of how to set up contexts and add them to your config can be found in the OpenColorIO documentation:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
|                                                 |         |                     | | http://opencolorio.org/userguide/contexts.html                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
 
| key3 / ``key3``                                 | String  |                     | | OCIO Contexts allow you to apply specific LUTs or grades to different shots.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
|                                                 |         |                     | | Here you can specify the context name (key) and its corresponding value.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
|                                                 |         |                     | | Full details of how to set up contexts and add them to your config can be found in the OpenColorIO documentation:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
|                                                 |         |                     | | http://opencolorio.org/userguide/contexts.html                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
 
| value3 / ``value3``                             | String  |                     | | OCIO Contexts allow you to apply specific LUTs or grades to different shots.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
|                                                 |         |                     | | Here you can specify the context name (key) and its corresponding value.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
|                                                 |         |                     | | Full details of how to set up contexts and add them to your config can be found in the OpenColorIO documentation:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
|                                                 |         |                     | | http://opencolorio.org/userguide/contexts.html                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
 
| key4 / ``key4``                                 | String  |                     | | OCIO Contexts allow you to apply specific LUTs or grades to different shots.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
|                                                 |         |                     | | Here you can specify the context name (key) and its corresponding value.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
|                                                 |         |                     | | Full details of how to set up contexts and add them to your config can be found in the OpenColorIO documentation:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
|                                                 |         |                     | | http://opencolorio.org/userguide/contexts.html                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
 
| value4 / ``value4``                             | String  |                     | | OCIO Contexts allow you to apply specific LUTs or grades to different shots.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
|                                                 |         |                     | | Here you can specify the context name (key) and its corresponding value.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
|                                                 |         |                     | | Full details of how to set up contexts and add them to your config can be found in the OpenColorIO documentation:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
|                                                 |         |                     | | http://opencolorio.org/userguide/contexts.html                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
 
| OCIO config help... / ``ocioHelp``              | Button  |                     | Help about the OpenColorIO configuration.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
 
| Input Premult / ``inputPremult``                | Choice  | PreMultiplied       | | Input is considered to have this premultiplication state.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
|                                                 |         |                     | | Colorspace conversion is done on the input RGB data, even if it is premultiplied, and may thus give a wrong result if the input is premultiplied and the target colorspace is nonlinear.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
|                                                 |         |                     | | This is set automatically from the input stream information, but can be adjusted if this information is wrong.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
|                                                 |         |                     | | **Opaque (opaque)**: The image is opaque and so has no premultiplication state, as if the alpha component in all pixels were set to the white point.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
|                                                 |         |                     | | **PreMultiplied (premult)**: The image is premultiplied by its alpha (also called “associated alpha”).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
|                                                 |         |                     | | **UnPreMultiplied (unpremult)**: The image is unpremultiplied (also called “unassociated alpha”).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
 
| Clip Info... / ``clipInfo``                     | Button  |                     | Display information about the inputs                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
 
| Frame Range / ``frameRange``                    | Choice  | Project frame range | | What frame range should be rendered.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
|                                                 |         |                     | | **Union of input ranges (union)**: The union of all inputs frame ranges will be rendered.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
|                                                 |         |                     | | **Project frame range (project)**: The frame range delimited by the frame range of the project will be rendered.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
|                                                 |         |                     | | **Manual (manual)**: The frame range will be the one defined by the first frame and last frame parameters.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
 
| First Frame / ``firstFrame``                    | Integer | 0                   |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
 
| Last Frame / ``lastFrame``                      | Integer | 0                   |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
 
| Tile Size / ``tileSize``                        | Choice  | Scan-Line Based     | | Size of a tile in the output file for formats that support tiles. If scan-line based, the whole image will have a single tile.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
|                                                 |         |                     | | **Scan-Line Based (0)**                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
|                                                 |         |                     | | **64**                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
|                                                 |         |                     | | **128**                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
|                                                 |         |                     | | **256**                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
|                                                 |         |                     | | **512**                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
 
| Bit Depth / ``bitDepth``                        | Choice  | auto                | | Number of bits per sample in the file [TIFF,DPX,TGA,DDS,ICO,IFF,PNM,PIC].                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
|                                                 |         |                     | | **auto**: Guess from the output format                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
|                                                 |         |                     | | **8i**: 8 bits integer                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
|                                                 |         |                     | | **10i**: 10 bits integer                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
|                                                 |         |                     | | **12i**: 12 bits integer                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
|                                                 |         |                     | | **16i**: 16 bits integer                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
|                                                 |         |                     | | **16f**: 16 bits floating point                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
|                                                 |         |                     | | **32i**: 32 bits integer                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
|                                                 |         |                     | | **32f**: 32 bits floating point                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
|                                                 |         |                     | | **64i**: 64 bits integer                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
|                                                 |         |                     | | **64f**: 64 bits floating point                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
 
| Quality / ``quality``                           | Integer | 100                 | Indicates the quality of compression to use (0-100), for those plugins and compression methods that allow a variable amount of compression, with higher numbers indicating higher image fidelity. [JPEG, TIFF w/ JPEG comp., WEBP]                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
 
| DWA Compression Level / ``dwaCompressionLevel`` | Double  | 45                  | Amount of compression when using Dreamworks DWAA or DWAB compression options. These lossy formats are variable in quality and can minimize the compression artifacts. Higher values will result in greater compression and likewise smaller file size, but increases the chance for artifacts. Values from 45 to 150 are usually correct for production shots, whereas HDR vacation photos could use up to 500. Values below 45 should give no visible imprrovement on photographs. [EXR w/ DWAa or DWAb comp.]                                                                                                                                                                                                 |
 
| Orientation / ``orientation``                   | Choice  | normal              | | The orientation of the image data [DPX,TIFF,JPEG,HDR,FITS].                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
|                                                 |         |                     | | By default, image pixels are ordered from the top of the display to the bottom, and within each scanline, from left to right (i.e., the same ordering as English text and scan progression on a CRT). But the “Orientation” parameter can suggest that it should be displayed with a different orientation, according to the TIFF/EXIF conventions.                                                                                                                                                                                                                                                                                                                                                           |
|                                                 |         |                     | | **normal**: normal (top to bottom, left to right)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
|                                                 |         |                     | | **flop**: flipped horizontally (top to bottom, right to left)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
|                                                 |         |                     | | **180**: rotate 180deg (bottom to top, right to left)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
|                                                 |         |                     | | **flip**: flipped vertically (bottom to top, left to right)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
|                                                 |         |                     | | **transposed**: transposed (left to right, top to bottom)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
|                                                 |         |                     | | **90clockwise**: rotated 90deg clockwise (right to left, top to bottom)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
|                                                 |         |                     | | **transverse**: transverse (right to left, bottom to top)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
|                                                 |         |                     | | **90counter-clockwise**: rotated 90deg counter-clockwise (left to right, bottom to top)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
 
| Compression / ``compression``                   | Choice  | default             | | Compression type [TIFF,EXR,DDS,IFF,SGI,TGA]                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
|                                                 |         |                     | | Indicates the type of compression the file uses. Supported compression modes will vary from format to format. As an example, the TIFF format supports “none”, “lzw”, “ccittrle”, “zip” (the default), “jpeg”, “packbits”, and the EXR format supports “none”, “rle”, “zip” (the default), “piz”, “pxr24”, “b44”, “b44a”, “dwaa” or “dwab”.                                                                                                                                                                                                                                                                                                                                                                    |
|                                                 |         |                     | | **default**: Guess from the output format                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
|                                                 |         |                     | | **none**: No compression [EXR, TIFF, IFF]                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
|                                                 |         |                     | | **zip**: Zlib/Deflate compression (lossless) [EXR, TIFF, Zfile]                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
|                                                 |         |                     | | **zips**: Zlib compression (lossless), one scan line at a time [EXR]                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
|                                                 |         |                     | | **rle**: Run Length Encoding (lossless) [DPX, IFF, EXR, TGA, RLA]                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
|                                                 |         |                     | | **piz**: Piz-based wavelet compression [EXR]                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
|                                                 |         |                     | | **pxr24**: Lossy 24bit float compression [EXR]                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
|                                                 |         |                     | | **b44**: Lossy 4-by-4 pixel block compression, fixed compression rate [EXR]                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
|                                                 |         |                     | | **b44a**: Lossy 4-by-4 pixel block compression, flat fields are compressed more [EXR]                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
|                                                 |         |                     | | **dwaa**: lossy DCT based compression, in blocks of 32 scanlines. More efficient for partial buffer access. [EXR]                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
|                                                 |         |                     | | **dwab**: lossy DCT based compression, in blocks of 256 scanlines. More efficient space wise and faster to decode full frames than DWAA. [EXR]                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
|                                                 |         |                     | | **lzw**: Lempel-Ziv Welsch compression (lossless) [TIFF]                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
|                                                 |         |                     | | **ccittrle**: CCITT modified Huffman RLE (lossless) [TIFF]                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
|                                                 |         |                     | | **jpeg**: JPEG [TIFF]                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
|                                                 |         |                     | | **packbits**: Macintosh RLE (lossless) [TIFF]                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
 
| Layer(s) / ``outputChannels``                   | Choice  | Color.RGBA          | | Select which layer to write to the file. This is either All or a single layer. This is not yet possible to append a layer to an existing file.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
|                                                 |         |                     | | **Color.RGBA (uk.co.thefoundry.OfxImagePlaneColour)**                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
|                                                 |         |                     | | **DisparityLeft.Disparity (uk.co.thefoundry.OfxImagePlaneStereoDisparityLeft)**                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
|                                                 |         |                     | | **DisparityRight.Disparity (uk.co.thefoundry.OfxImagePlaneStereoDisparityRight)**                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
|                                                 |         |                     | | **Backward.Motion (uk.co.thefoundry.OfxImagePlaneBackMotionVector)**                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
|                                                 |         |                     | | **Forward.Motion (uk.co.thefoundry.OfxImagePlaneForwardMotionVector)**                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
 
| All Planes / ``processAllPlanes``               | Boolean | Off                 | When checked all planes in input will be processed and output to the same plane as in input. It is useful for example to apply a Transform effect on all planes.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
 
| Parts / ``partSplitting``                       | Choice  | Split Views,Layers  | | Defines whether to separate views/layers in different EXR parts or not. Note that multi-part files are only supported by OpenEXR >= 2                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
|                                                 |         |                     | | **Single Part (single)**: All views and layers will be in the same part, ensuring compatibility with OpenEXR 1.x                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
|                                                 |         |                     | | **Split Views (views)**: All views will have its own part, and each part will contain all layers. This will produce an EXR optimized in size that can be opened only with applications supporting OpenEXR 2                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
|                                                 |         |                     | | **Split Views,Layers (views_layers)**: Each layer of each view will have its own part. This will produce an EXR optimized for decoding speed that can be opened only with applications supporting OpenEXR 2                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
 
| Views / ``viewsSelector``                       | Choice  | All                 | | Select the views to render. When choosing All, make sure the output filename does not have a %v or %V view pattern in which case each view would be written to a separate file.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
|                                                 |         |                     | | **All**                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
|                                                 |         |                     | | **Main**                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
 
| OpenImageIO Info... / ``libraryInfo``           | Button  |                     | Display information about the underlying library.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
 

.. |pluginIcon| image:: fr.inria.openfx.WriteOIIO.png
   :width: 10.0%
