[pierre jasmin]: This is a bit complicated, perhaps we can ignore planes for now as a first pass?

Don't we only need something like:

typedefstruct
               OfxMultiViewImageEffectSuiteV1
               {
               OfxStatus
               (
               *
               clipGetMultiViewImage
               )
               (
               OfxImageClipHandle clip
               ,
               OfxTime
               time
               ,
               int
               iview
               ,
               OfxRectD
               *
               region
               ,
               OfxPropertySetHandle
               *
               imageHandle
               )
               ;
               OfxStatus
               (
               *
               getViewCount
               )
               (
               OfxImageEffectHandle instance
               ,
               int
               *
               nViews
               )
               ;
               // 2 when stereo
               OfxStatus
               (
               *
               getViewName
               )
               (
               OfxImageEffectHandle effect
               ,
               int
               view
               ,
               char
               **
               viewName
               )
               ;
               }
               OfxMultiViewImageSuiteV1
               ;
            

+ maybe we need to say we support this, I am OK if I have to add a menu (process both, left only, right only - assuming I can get both views when rendering one) Also if getViewCount == 2 - maybe we can use predefined int values: ALL=0, LEFT=1, RIGHT=2?

[Gary Oberbrunner]: Like Pierre, I think a simple interface is better if it serves the need. Handling stereo is all we really need to do here, right? Being able to get disparity from the host would be nice, but (a) some hosts, even stereo-capable ones, might not have that, and (b) most plug-ins just need the actual left and right images.

One additional comment: what if we are in direct OpenGL mode? This suite has to interoperate with that one.

—

[Dennis Adams]: There are two needs that we identified:

1. Some stereo-aware plug-ins would like to know which view it is currently processing.
2. Some stereo-aware plug-ins would like access to frames from views other than the one it is processing.

We addressed these in Vegas Pro 10 using the following (shipping) OFX extensions:

1. Two new properties of the OfxImageEffectActionRender action describing the view being rendered, and how many views total:

/** @brief Indicates the number of the view to render

       - Type - int x 1
       - Property Set - Render In Args (read only)
       - Valid Values - 0 (standard), 0 (left stereoscopic processing), 1 (right stereoscopic processing)

    */#define kOfxImageEffectPropRenderView OfxImageEffectPropRenderView/** @brief Indicates the number of total views to render

       - Type - int x 1
       - Property Set - Render In Args (read only)
       - Valid Values - 1 (standard), 2 (stereoscopic processing)

    */#define kOfxImageEffectPropViewsToRender OfxImageEffectPropViewsToRender

2. Callback suite to get a specific view (using the standard callback gets you the current view being rendered):

/** @brief Name of the Vegas stereoscopic image effect suite (used to get a clip image from the
               either view (otherwise getClipImage by default returns the current image)
    */#define kOfxVegasStereoscopicImageEffectSuite OfxVegasStereoscopicImageEffectSuitetypedefstruct
               OfxVegasStereoscopicImageEffectSuiteV1
               {
               OfxStatus
               (
               *
               clipGetStereoscopicImage
               )
               (
               OfxImageClipHandle clip
               ,
               OfxTime
               time
               ,
               int
               iview
               ,
               OfxRectD
               *
               region
               ,
               OfxPropertySetHandle
               *
               imageHandle
               )
               ;
               }
               OfxVegasStereoscopicImageSuiteV1
               ;
            

Both of these seem to fit inside what Bruno has proposed (based on how Nuke works), but using numbers instead of names for the views.

To Gary's comment, these are compatible with the OpenGL extension and can be used at the same time.

Regarding taking it past stereoscopic: we may need a convention for describing views. For example, views needed for:

1. Stereoscopic (left and right).
2. Autostereoscopic displays (I've seen these with 4 to 15 views, probably more someday).
3. 360 displays like Sony RayModeler ( http://www.youtube.com/watch?v=6BFKC-NKRFw ).
4. Multiple views in both X and Y view directions?

All of these can be sufficiently enumerated just with “view N of M” (or “view Nx,Ny of Mx,My” for #4) but for 2 and 3 you might want to know the angle described by each view.

[pierre jasmin]: I don't think we want decimation, tiling etc in there. Just maybe Stereo and Other.

Conceptually seems we need to separate “Planes” - multi-channel from multi-view

OfxStatus (* clipGetImagePlane)(OfxImageClipHandle clip,

                                OfxTime               time,
                                const char*           plane,
                                OfxRectD*             region,
                                OfxPropertySetHandle* imageHandle);

OfxStatus (*clipGetImageView)(OfxImageClipHandle clip,

                    OfxTime       time,
                    int           iview,
                    OfxRectD     *region,
                    OfxPropertySetHandle   *imageHandle);

OfxStatus (* clipGetImageViewAndPlane)(OfxImageClipHandle clip,

                                OfxTime               time,
                                int                   view,
                                const char*           plane,
                                OfxRectD*             region,
                                OfxPropertySetHandle* imageHandle);