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