Fix crash from freeing of NULL pointer
[blender.git] / source / blender / imbuf / IMB_imbuf.h
1 /*
2  * ***** BEGIN GPL LICENSE BLOCK *****
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License
6  * as published by the Free Software Foundation; either version 2
7  * of the License, or (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software Foundation,
16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
17  *
18  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
19  * All rights reserved.
20  *
21  * The Original Code is: all of this file.
22  *
23  * Contributor(s): none yet.
24  *
25  * ***** END GPL LICENSE BLOCK *****
26  */
27
28 /** \file blender/imbuf/IMB_imbuf.h
29  *  \ingroup imbuf
30  */
31
32 /**
33  * \brief IMage Buffer module.
34  *
35  * This module offers import/export of several graphical file formats.
36  * \ingroup imbuf
37  *
38  * \page IMB Imbuf module external interface
39  *
40  *
41  * \section imb_about About the IMB module
42  *
43  * External interface of the IMage Buffer module. This module offers
44  * import/export of several graphical file formats. It offers the
45  * ImBuf type as a common structure to refer to different graphical
46  * file formats, and to enable a uniform way of handling them.
47  *
48  * \section imb_issues Known issues with IMB
49  *
50  * - imbuf is written in C.
51  * - Endianness issues are dealt with internally.
52  * - File I/O must be done externally. The module uses FILE*'s to
53  *   direct input/output.
54  *
55  * \section imb_dependencies Dependencies
56  *
57  * IMB needs:
58  * - \ref DNA module
59  *     The listbase types are used for handling the memory
60  *     management.
61  * - \ref blenlib module
62  *     blenlib handles guarded memory management in blender-style.
63  *     BLI_winstuff.h makes a few windows specific behaviors
64  *     posix-compliant.
65  */
66
67 #ifndef __IMB_IMBUF_H__
68 #define __IMB_IMBUF_H__
69
70 #define IM_MAX_SPACE 64
71
72 /* for bool */
73 #include "../blenlib/BLI_sys_types.h"
74
75 /**
76  *
77  * \attention defined in ???
78  */
79 struct ImBuf;
80
81 /**
82  *
83  * \attention defined in ???
84  */
85 struct anim;
86
87 struct ColorManagedDisplay;
88
89 struct GSet;
90 /**
91  *
92  * \attention defined in DNA_scene_types.h
93  */
94 struct ImageFormatData;
95 struct Stereo3dFormat;
96
97 /**
98  *
99  * \attention Defined in allocimbuf.c
100  */
101 void IMB_init(void);
102 void IMB_exit(void);
103
104 /**
105  *
106  * \attention Defined in readimage.c
107  */
108 struct ImBuf *IMB_ibImageFromMemory(unsigned char *mem, size_t size, int flags, char colorspace[IM_MAX_SPACE], const char *descr);
109
110 /**
111  *
112  * \attention Defined in readimage.c
113  */
114 struct ImBuf *IMB_testiffname(const char *filepath, int flags);
115
116 /**
117  *
118  * \attention Defined in readimage.c
119  */
120 struct ImBuf *IMB_loadiffname(const char *filepath, int flags, char colorspace[IM_MAX_SPACE]);
121
122 /**
123  *
124  * \attention Defined in allocimbuf.c
125  */
126 void IMB_freeImBuf(struct ImBuf *ibuf);
127
128 /**
129  *
130  * \attention Defined in allocimbuf.c
131  */
132 struct ImBuf *IMB_allocImBuf(unsigned int x, unsigned int y,
133                              unsigned char planes, unsigned int flags);
134
135 /**
136  * Initialize given ImBuf.
137  *
138  * Use in cases when temporary image buffer is allocated on stack.
139  *
140  * \attention Defined in allocimbuf.c
141  */
142 bool IMB_initImBuf(struct ImBuf *ibuf,
143                    unsigned int x, unsigned int y,
144                    unsigned char planes, unsigned int flags);
145
146 /**
147  * Create a copy of a pixel buffer and wrap it to a new ImBuf
148  * \attention Defined in allocimbuf.c
149  */
150 struct ImBuf *IMB_allocFromBuffer(const unsigned int *rect, const float *rectf,
151                                   unsigned int w, unsigned int h);
152
153 /**
154  *
155  * Increase reference count to imbuf
156  * (to delete an imbuf you have to call freeImBuf as many times as it
157  * is referenced)
158  *
159  * \attention Defined in allocimbuf.c
160  */
161
162 void IMB_refImBuf(struct ImBuf *ibuf);
163 struct ImBuf *IMB_makeSingleUser(struct ImBuf *ibuf);
164
165 /**
166  *
167  * \attention Defined in allocimbuf.c
168  */
169 struct ImBuf *IMB_dupImBuf(struct ImBuf *ibuf1);
170
171 /**
172  *
173  * \attention Defined in allocimbuf.c
174  */
175 bool addzbufImBuf(struct ImBuf *ibuf);
176 bool addzbuffloatImBuf(struct ImBuf *ibuf);
177
178 /**
179  *
180  * \attention Defined in rectop.c
181  */
182
183 typedef enum IMB_BlendMode {
184         IMB_BLEND_MIX = 0,
185         IMB_BLEND_ADD = 1,
186         IMB_BLEND_SUB = 2,
187         IMB_BLEND_MUL = 3,
188         IMB_BLEND_LIGHTEN = 4,
189         IMB_BLEND_DARKEN = 5,
190         IMB_BLEND_ERASE_ALPHA = 6,
191         IMB_BLEND_ADD_ALPHA = 7,
192         IMB_BLEND_OVERLAY = 8,
193         IMB_BLEND_HARDLIGHT     = 9,
194         IMB_BLEND_COLORBURN     = 10,
195         IMB_BLEND_LINEARBURN = 11,
196         IMB_BLEND_COLORDODGE = 12,
197         IMB_BLEND_SCREEN = 13,
198         IMB_BLEND_SOFTLIGHT     = 14,
199         IMB_BLEND_PINLIGHT = 15,
200         IMB_BLEND_VIVIDLIGHT = 16,
201         IMB_BLEND_LINEARLIGHT = 17,
202         IMB_BLEND_DIFFERENCE = 18,
203         IMB_BLEND_EXCLUSION     = 19,
204         IMB_BLEND_HUE = 20,
205         IMB_BLEND_SATURATION = 21,
206         IMB_BLEND_LUMINOSITY = 22,
207         IMB_BLEND_COLOR = 23,
208
209         IMB_BLEND_COPY = 1000,
210         IMB_BLEND_COPY_RGB = 1001,
211         IMB_BLEND_COPY_ALPHA = 1002
212 } IMB_BlendMode;
213
214 void IMB_blend_color_byte(unsigned char dst[4], unsigned char src1[4],
215         unsigned char src2[4], IMB_BlendMode mode);
216 void IMB_blend_color_float(float dst[4], float src1[4], float src2[4],
217         IMB_BlendMode mode);
218
219 void IMB_rectclip(struct ImBuf *dbuf, struct ImBuf *sbuf, int *destx, 
220         int *desty, int *srcx, int *srcy, int *width, int *height);
221 void IMB_rectcpy(struct ImBuf *drect, struct ImBuf *srect, int destx,
222         int desty, int srcx, int srcy, int width, int height);
223 void IMB_rectblend(struct ImBuf *dbuf, struct ImBuf *obuf, struct ImBuf *sbuf,
224         unsigned short *dmask, unsigned short *curvemask, unsigned short *mmask, float mask_max,
225         int destx,  int desty, int origx, int origy, int srcx, int srcy,
226         int width, int height, IMB_BlendMode mode, bool accumulate);
227 void IMB_rectblend_threaded(struct ImBuf *dbuf, struct ImBuf *obuf, struct ImBuf *sbuf,
228         unsigned short *dmask, unsigned short *curvemask, unsigned short *mmask, float mask_max,
229         int destx,  int desty, int origx, int origy, int srcx, int srcy,
230         int width, int height, IMB_BlendMode mode, bool accumulate);
231
232 /**
233  *
234  * \attention Defined in indexer.c
235  */
236
237 typedef enum IMB_Timecode_Type {
238         IMB_TC_NONE       = 0, /* don't use timecode files at all */
239
240         IMB_TC_RECORD_RUN = 1, /* use images in the order as they are recorded
241                                 * (currently, this is the only one implemented
242                                 * and is a sane default) */
243
244         IMB_TC_FREE_RUN   = 2, /* use global timestamp written by recording
245                                 * device (prosumer camcorders e.g. can do that) */
246         IMB_TC_INTERPOLATED_REC_DATE_FREE_RUN = 4, /* interpolate a global timestamp using the
247                                                     * record date and time written by recording
248                                                     * device (*every* consumer camcorder can do
249                                                     * that :) )*/
250         IMB_TC_RECORD_RUN_NO_GAPS = 8,
251         IMB_TC_MAX_SLOT   = 4
252 } IMB_Timecode_Type;
253
254 typedef enum IMB_Proxy_Size {
255         IMB_PROXY_NONE = 0,
256         IMB_PROXY_25 = 1,
257         IMB_PROXY_50 = 2,
258         IMB_PROXY_75 = 4,
259         IMB_PROXY_100 = 8,
260         IMB_PROXY_MAX_SLOT = 4
261 } IMB_Proxy_Size;
262
263 /* defaults to BL_proxy within the directory of the animation */
264 void IMB_anim_set_index_dir(struct anim *anim, const char *dir);
265 void IMB_anim_get_fname(struct anim *anim, char *file, int size);
266
267 int IMB_anim_index_get_frame_index(struct anim *anim, IMB_Timecode_Type tc,
268                                    int position);
269
270 IMB_Proxy_Size IMB_anim_proxy_get_existing(struct anim *anim);
271
272 struct IndexBuildContext;
273
274 /* prepare context for proxies/imecodes builder */
275 struct IndexBuildContext *IMB_anim_index_rebuild_context(struct anim *anim, IMB_Timecode_Type tcs_in_use,
276                                                          IMB_Proxy_Size proxy_sizes_in_use, int quality,
277                                                          const bool overwite, struct GSet *file_list);
278
279 /* will rebuild all used indices and proxies at once */
280 void IMB_anim_index_rebuild(struct IndexBuildContext *context,
281                             short *stop, short *do_update, float *progress);
282
283 /* finish rebuilding proxises/timecodes and free temporary contexts used */
284 void IMB_anim_index_rebuild_finish(struct IndexBuildContext *context, short stop);
285
286 /**
287  * Return the length (in frames) of the given \a anim.
288  */
289 int IMB_anim_get_duration(struct anim *anim, IMB_Timecode_Type tc);
290
291
292 /**
293  * Return the fps contained in movie files (function rval is false,
294  * and frs_sec and frs_sec_base untouched if none available!)
295  */
296 bool IMB_anim_get_fps(struct anim *anim,
297                       short *frs_sec, float *frs_sec_base, bool no_av_base);
298
299 /**
300  *
301  * \attention Defined in anim_movie.c
302  */
303 struct anim *IMB_open_anim(const char *name, int ib_flags, int streamindex, char colorspace[IM_MAX_SPACE]);
304 void IMB_suffix_anim(struct anim *anim, const char *suffix);
305 void IMB_close_anim(struct anim *anim);
306 void IMB_close_anim_proxies(struct anim *anim);
307
308 /**
309  *
310  * \attention Defined in anim_movie.c
311  */
312
313 int ismovie(const char *filepath);
314 void IMB_anim_set_preseek(struct anim *anim, int preseek);
315 int IMB_anim_get_preseek(struct anim *anim);
316
317 /**
318  *
319  * \attention Defined in anim_movie.c
320  */
321
322 struct ImBuf *IMB_anim_absolute(
323         struct anim *anim, int position,
324         IMB_Timecode_Type tc        /* = 1 = IMB_TC_RECORD_RUN */, 
325         IMB_Proxy_Size preview_size /* = 0 = IMB_PROXY_NONE */);
326
327 /**
328  *
329  * \attention Defined in anim_movie.c
330  * fetches a define previewframe, usually half way into the movie
331  */
332 struct ImBuf *IMB_anim_previewframe(struct anim *anim);
333
334 /**
335  *
336  * \attention Defined in anim_movie.c
337  */
338 void IMB_free_anim(struct anim *anim);
339
340 /**
341  *
342  * \attention Defined in filter.c
343  */
344
345 #define FILTER_MASK_NULL                0
346 #define FILTER_MASK_MARGIN              1
347 #define FILTER_MASK_USED                2
348
349 void IMB_filter(struct ImBuf *ibuf);
350 void IMB_mask_filter_extend(char *mask, int width, int height);
351 void IMB_mask_clear(struct ImBuf *ibuf, char *mask, int val);
352 void IMB_filter_extend(struct ImBuf *ibuf, char *mask, int filter);
353 void IMB_makemipmap(struct ImBuf *ibuf, int use_filter);
354 void IMB_remakemipmap(struct ImBuf *ibuf, int use_filter);
355 struct ImBuf *IMB_getmipmap(struct ImBuf *ibuf, int level);
356
357 /**
358  *
359  * \attention Defined in cache.c
360  */
361
362 void IMB_tile_cache_params(int totthread, int maxmem);
363 unsigned int *IMB_gettile(struct ImBuf *ibuf, int tx, int ty, int thread);
364 void IMB_tiles_to_rect(struct ImBuf *ibuf);
365
366 /**
367  *
368  * \attention Defined in filter.c
369  */
370 void IMB_filtery(struct ImBuf *ibuf);
371
372 /**
373  *
374  * \attention Defined in scaling.c
375  */
376 struct ImBuf *IMB_onehalf(struct ImBuf *ibuf1);
377
378 /**
379  *
380  * \attention Defined in scaling.c
381  */
382 struct ImBuf *IMB_scaleImBuf(struct ImBuf *ibuf, unsigned int newx, unsigned int newy);
383
384 /**
385  *
386  * \attention Defined in scaling.c
387  */
388 struct ImBuf *IMB_scalefastImBuf(struct ImBuf *ibuf, unsigned int newx, unsigned int newy);
389
390 /**
391  *
392  * \attention Defined in scaling.c
393  */
394 void IMB_scaleImBuf_threaded(struct ImBuf *ibuf, unsigned int newx, unsigned int newy);
395
396 /**
397  *
398  * \attention Defined in writeimage.c
399  */
400 short IMB_saveiff(struct ImBuf *ibuf, const char *filepath, int flags);
401 struct ImBuf *IMB_prepare_write_ImBuf(const bool isfloat, struct ImBuf *ibuf);
402
403 /**
404  *
405  * \attention Defined in util.c
406  */
407 bool IMB_ispic(const char *name);
408 int  IMB_ispic_type(const char *name);
409
410 /**
411  *
412  * \attention Defined in util.c
413  */
414 bool IMB_isanim(const char *name);
415
416 /**
417  *
418  * \attention Defined in util.c
419  */
420 int imb_get_anim_type(const char *name);
421
422 /**
423  *
424  * \attention Defined in util.c
425  */
426 bool IMB_isfloat(struct ImBuf *ibuf);
427
428 /**
429  *
430  * \attention Defined in divers.c
431  */
432 void IMB_de_interlace(struct ImBuf *ibuf);
433 void IMB_interlace(struct ImBuf *ibuf);
434
435 /* create char buffer, color corrected if necessary, for ImBufs that lack one */ 
436 void IMB_rect_from_float(struct ImBuf *ibuf);
437 /* Create char buffer for part of the image, color corrected if necessary,
438  * Changed part will be stored in buffer. This is expected to be used for texture painting updates */
439 void IMB_partial_rect_from_float(struct ImBuf *ibuf, float *buffer, int x, int y, int w, int h, bool is_data);
440 void IMB_float_from_rect(struct ImBuf *ibuf);
441 void IMB_color_to_bw(struct ImBuf *ibuf);
442 void IMB_saturation(struct ImBuf *ibuf, float sat);
443
444 /* converting pixel buffers */
445 void IMB_buffer_byte_from_float(unsigned char *rect_to, const float *rect_from,
446         int channels_from, float dither, int profile_to, int profile_from, bool predivide,
447         int width, int height, int stride_to, int stride_from);
448 void IMB_buffer_byte_from_float_mask(unsigned char *rect_to, const float *rect_from,
449         int channels_from, float dither, bool predivide,
450         int width, int height, int stride_to, int stride_from, char *mask);
451 void IMB_buffer_float_from_byte(float *rect_to, const unsigned char *rect_from,
452         int profile_to, int profile_from, bool predivide,
453         int width, int height, int stride_to, int stride_from);
454 void IMB_buffer_float_from_float(float *rect_to, const float *rect_from,
455         int channels_from, int profile_to, int profile_from, bool predivide,
456         int width, int height, int stride_to, int stride_from);
457 void IMB_buffer_float_from_float_threaded(float *rect_to, const float *rect_from,
458         int channels_from, int profile_to, int profile_from, bool predivide,
459         int width, int height, int stride_to, int stride_from);
460 void IMB_buffer_float_from_float_mask(float *rect_to, const float *rect_from,
461         int channels_from, int width, int height, int stride_to, int stride_from, char *mask);
462 void IMB_buffer_byte_from_byte(unsigned char *rect_to, const unsigned char *rect_from,
463         int profile_to, int profile_from, bool predivide,
464         int width, int height, int stride_to, int stride_from);
465 void IMB_buffer_float_clamp(float *buf, int width, int height);
466 void IMB_buffer_float_unpremultiply(float *buf, int width, int height);
467 void IMB_buffer_float_premultiply(float *buf, int width, int height);
468
469 /**
470  * Change the ordering of the color bytes pointed to by rect from
471  * rgba to abgr. size * 4 color bytes are reordered.
472  *
473  * \attention Defined in imageprocess.c
474  */
475 void IMB_convert_rgba_to_abgr(struct ImBuf *ibuf);
476
477 /**
478  *
479  * \attention defined in imageprocess.c
480  */
481 void bicubic_interpolation(struct ImBuf *in, struct ImBuf *out, float u, float v, int xout, int yout);
482 void nearest_interpolation(struct ImBuf *in, struct ImBuf *out, float u, float v, int xout, int yout);
483 void bilinear_interpolation(struct ImBuf *in, struct ImBuf *out, float u, float v, int xout, int yout);
484
485 void bicubic_interpolation_color(struct ImBuf *in, unsigned char col[4], float col_float[4], float u, float v);
486 void nearest_interpolation_color(struct ImBuf *in, unsigned char col[4], float col_float[4], float u, float v);
487 void nearest_interpolation_color_wrap(struct ImBuf *in, unsigned char col[4], float col_float[4], float u, float v);
488 void bilinear_interpolation_color(struct ImBuf *in, unsigned char col[4], float col_float[4], float u, float v);
489 void bilinear_interpolation_color_wrap(struct ImBuf *in, unsigned char col[4], float col_float[4], float u, float v);
490
491 void IMB_alpha_under_color_float(float *rect_float, int x, int y, float backcol[3]);
492 void IMB_alpha_under_color_byte(unsigned char *rect, int x, int y, float backcol[3]);
493
494 /**
495  *
496  * \attention defined in readimage.c
497  */  
498 struct ImBuf *IMB_loadifffile(int file, const char *filepath, int flags, char colorspace[IM_MAX_SPACE], const char *descr);
499
500 /**
501  *
502  * \attention defined in scaling.c
503  */
504 struct ImBuf *IMB_half_x(struct ImBuf *ibuf1);
505
506 /**
507  *
508  * \attention defined in scaling.c
509  */
510 struct ImBuf *IMB_double_fast_x(struct ImBuf *ibuf1);
511
512 /**
513  *
514  * \attention defined in scaling.c
515  */
516 struct ImBuf *IMB_double_x(struct ImBuf *ibuf1);
517
518 /**
519  *
520  * \attention defined in scaling.c
521  */
522 struct ImBuf *IMB_half_y(struct ImBuf *ibuf1);
523
524 /**
525  *
526  * \attention defined in scaling.c
527  */
528 struct ImBuf *IMB_double_fast_y(struct ImBuf *ibuf1);
529
530 /**
531  *
532  * \attention defined in scaling.c
533  */
534 struct ImBuf *IMB_double_y(struct ImBuf *ibuf1);
535
536 /**
537  *
538  * \attention Defined in rotate.c
539  */
540 void IMB_flipx(struct ImBuf *ibuf);
541 void IMB_flipy(struct ImBuf *ibuf);
542
543 /* Premultiply alpha */
544
545 void IMB_premultiply_alpha(struct ImBuf *ibuf);
546 void IMB_unpremultiply_alpha(struct ImBuf *ibuf);
547
548 /**
549  *
550  * \attention Defined in allocimbuf.c
551  */
552 void IMB_freezbufImBuf(struct ImBuf *ibuf);
553 void IMB_freezbuffloatImBuf(struct ImBuf *ibuf);
554
555 /**
556  *
557  * \attention Defined in rectop.c
558  */
559 void IMB_rectfill(struct ImBuf *drect, const float col[4]);
560 void IMB_rectfill_area(struct ImBuf *ibuf, const float col[4], int x1, int y1, int x2, int y2, struct ColorManagedDisplay *display);
561 void IMB_rectfill_alpha(struct ImBuf *ibuf, const float value);
562
563 /* this should not be here, really, we needed it for operating on render data, IMB_rectfill_area calls it */
564 void buf_rectfill_area(unsigned char *rect, float *rectf, int width, int height,
565                        const float col[4], struct ColorManagedDisplay *display,
566                        int x1, int y1, int x2, int y2);
567
568 /**
569  *
570  * \attention Defined in metadata.c
571  */
572 /** read the field from the image info into the field 
573  *  \param img - the ImBuf that contains the image data
574  *  \param key - the key of the field
575  *  \param value - the data in the field, first one found with key is returned, 
576  *                 memory has to be allocated by user.
577  *  \param len - length of value buffer allocated by user.
578  *  \return    - 1 (true) if ImageInfo present and value for the key found, 0 (false) otherwise
579  */
580 bool IMB_metadata_get_field(struct ImBuf *img, const char *key, char *value, const size_t len);
581 bool IMB_metadata_change_field(struct ImBuf *img, const char *key, const char *field);
582 void IMB_metadata_copy(struct ImBuf *dimb, struct ImBuf *simb);
583
584 /* exported for image tools in blender, to quickly allocate 32 bits rect */
585 bool imb_addrectImBuf(struct ImBuf *ibuf);
586 void imb_freerectImBuf(struct ImBuf *ibuf);
587
588 bool imb_addrectfloatImBuf(struct ImBuf *ibuf);
589 void imb_freerectfloatImBuf(struct ImBuf *ibuf);
590 void imb_freemipmapImBuf(struct ImBuf *ibuf);
591
592 bool imb_addtilesImBuf(struct ImBuf *ibuf);
593 void imb_freetilesImBuf(struct ImBuf *ibuf);
594
595 /* threaded processors */
596 void IMB_processor_apply_threaded(int buffer_lines, int handle_size, void *init_customdata,
597                                   void (init_handle) (void *handle, int start_line, int tot_line,
598                                                       void *customdata),
599                                   void *(do_thread) (void *));
600
601 typedef void (*ScanlineThreadFunc) (void *custom_data,
602                                     int start_scanline,
603                                     int num_scanlines);
604 void IMB_processor_apply_threaded_scanlines(int total_scanlines,
605                                             ScanlineThreadFunc do_thread,
606                                             void *custom_data);
607
608
609 /* ffmpeg */
610 void IMB_ffmpeg_init(void);
611 const char *IMB_ffmpeg_last_error(void);
612
613 /**
614  *
615  * \attention defined in stereoimbuf.c
616  */
617 void IMB_stereo3d_write_dimensions(
618         const char mode, const bool is_squeezed, const size_t width, const size_t height,
619         size_t *r_width, size_t *r_height);
620 void IMB_stereo3d_read_dimensions(
621         const char mode, const bool is_squeezed, const size_t width, const size_t height,
622         size_t *r_width, size_t *r_height);
623 int *IMB_stereo3d_from_rect(
624         struct ImageFormatData *im_format, const size_t x, const size_t y, const size_t channels,
625         int *rect_left, int *rect_right);
626 float *IMB_stereo3d_from_rectf(
627         struct ImageFormatData *im_format, const size_t x, const size_t y, const size_t channels,
628         float *rectf_left, float *rectf_right);
629 struct ImBuf *IMB_stereo3d_ImBuf(
630         struct ImageFormatData *im_format,
631         struct ImBuf *ibuf_left, struct ImBuf *ibuf_right);
632 void IMB_ImBufFromStereo3d(
633         struct Stereo3dFormat *s3d, struct ImBuf *ibuf_stereo,
634         struct ImBuf **r_ibuf_left, struct ImBuf **r_ibuf_right);
635
636 #endif