VSE: Cache rewrite
[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
50  *     management.
51  * - \ref blenlib module
52  *     blenlib handles guarded memory management in blender-style.
53  *     BLI_winstuff.h makes a few windows specific behaviors
54  *     posix-compliant.
55  */
56
57 #ifndef __IMB_IMBUF_H__
58 #define __IMB_IMBUF_H__
59
60 #define IM_MAX_SPACE 64
61
62 /* for bool */
63 #include "../blenlib/BLI_sys_types.h"
64
65 /**
66  *
67  * \attention defined in ???
68  */
69 struct ImBuf;
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_rectclip(struct ImBuf *dbuf,
226                   struct ImBuf *sbuf,
227                   int *destx,
228                   int *desty,
229                   int *srcx,
230                   int *srcy,
231                   int *width,
232                   int *height);
233 void IMB_rectcpy(struct ImBuf *drect,
234                  struct ImBuf *srect,
235                  int destx,
236                  int desty,
237                  int srcx,
238                  int srcy,
239                  int width,
240                  int height);
241 void IMB_rectblend(struct ImBuf *dbuf,
242                    struct ImBuf *obuf,
243                    struct ImBuf *sbuf,
244                    unsigned short *dmask,
245                    unsigned short *curvemask,
246                    unsigned short *mmask,
247                    float mask_max,
248                    int destx,
249                    int desty,
250                    int origx,
251                    int origy,
252                    int srcx,
253                    int srcy,
254                    int width,
255                    int height,
256                    IMB_BlendMode mode,
257                    bool accumulate);
258 void IMB_rectblend_threaded(struct ImBuf *dbuf,
259                             struct ImBuf *obuf,
260                             struct ImBuf *sbuf,
261                             unsigned short *dmask,
262                             unsigned short *curvemask,
263                             unsigned short *mmask,
264                             float mask_max,
265                             int destx,
266                             int desty,
267                             int origx,
268                             int origy,
269                             int srcx,
270                             int srcy,
271                             int width,
272                             int height,
273                             IMB_BlendMode mode,
274                             bool accumulate);
275
276 /**
277  *
278  * \attention Defined in indexer.c
279  */
280
281 typedef enum IMB_Timecode_Type {
282   /** Don't use timecode files at all. */
283   IMB_TC_NONE = 0,
284   /** use images in the order as they are recorded
285    * (currently, this is the only one implemented
286    * and is a sane default) */
287   IMB_TC_RECORD_RUN = 1,
288   /** Use global timestamp written by recording
289    * device (prosumer camcorders e.g. can do that). */
290   IMB_TC_FREE_RUN = 2,
291   /** Interpolate a global timestamp using the
292    * record date and time written by recording
293    * device (*every* consumer camcorder can do
294    * that :) )*/
295   IMB_TC_INTERPOLATED_REC_DATE_FREE_RUN = 4,
296   IMB_TC_RECORD_RUN_NO_GAPS = 8,
297   IMB_TC_MAX_SLOT = 4,
298 } IMB_Timecode_Type;
299
300 typedef enum IMB_Proxy_Size {
301   IMB_PROXY_NONE = 0,
302   IMB_PROXY_25 = 1,
303   IMB_PROXY_50 = 2,
304   IMB_PROXY_75 = 4,
305   IMB_PROXY_100 = 8,
306   IMB_PROXY_MAX_SLOT = 4,
307 } IMB_Proxy_Size;
308
309 /* defaults to BL_proxy within the directory of the animation */
310 void IMB_anim_set_index_dir(struct anim *anim, const char *dir);
311 void IMB_anim_get_fname(struct anim *anim, char *file, int size);
312
313 int IMB_anim_index_get_frame_index(struct anim *anim, IMB_Timecode_Type tc, int position);
314
315 IMB_Proxy_Size IMB_anim_proxy_get_existing(struct anim *anim);
316
317 struct IndexBuildContext;
318
319 /* prepare context for proxies/imecodes builder */
320 struct IndexBuildContext *IMB_anim_index_rebuild_context(struct anim *anim,
321                                                          IMB_Timecode_Type tcs_in_use,
322                                                          IMB_Proxy_Size proxy_sizes_in_use,
323                                                          int quality,
324                                                          const bool overwite,
325                                                          struct GSet *file_list);
326
327 /* will rebuild all used indices and proxies at once */
328 void IMB_anim_index_rebuild(struct IndexBuildContext *context,
329                             short *stop,
330                             short *do_update,
331                             float *progress);
332
333 /* finish rebuilding proxises/timecodes and free temporary contexts used */
334 void IMB_anim_index_rebuild_finish(struct IndexBuildContext *context, short stop);
335
336 /**
337  * Return the length (in frames) of the given \a anim.
338  */
339 int IMB_anim_get_duration(struct anim *anim, IMB_Timecode_Type tc);
340
341 /**
342  * Return the fps contained in movie files (function rval is false,
343  * and frs_sec and frs_sec_base untouched if none available!)
344  */
345 bool IMB_anim_get_fps(struct anim *anim, short *frs_sec, float *frs_sec_base, bool no_av_base);
346
347 /**
348  *
349  * \attention Defined in anim_movie.c
350  */
351 struct anim *IMB_open_anim(const char *name,
352                            int ib_flags,
353                            int streamindex,
354                            char colorspace[IM_MAX_SPACE]);
355 void IMB_suffix_anim(struct anim *anim, const char *suffix);
356 void IMB_close_anim(struct anim *anim);
357 void IMB_close_anim_proxies(struct anim *anim);
358
359 /**
360  *
361  * \attention Defined in anim_movie.c
362  */
363
364 int ismovie(const char *filepath);
365 void IMB_anim_set_preseek(struct anim *anim, int preseek);
366 int IMB_anim_get_preseek(struct anim *anim);
367
368 /**
369  *
370  * \attention Defined in anim_movie.c
371  */
372
373 struct ImBuf *IMB_anim_absolute(struct anim *anim,
374                                 int position,
375                                 IMB_Timecode_Type tc /* = 1 = IMB_TC_RECORD_RUN */,
376                                 IMB_Proxy_Size preview_size /* = 0 = IMB_PROXY_NONE */);
377
378 /**
379  *
380  * \attention Defined in anim_movie.c
381  * fetches a define previewframe, usually half way into the movie
382  */
383 struct ImBuf *IMB_anim_previewframe(struct anim *anim);
384
385 /**
386  *
387  * \attention Defined in anim_movie.c
388  */
389 void IMB_free_anim(struct anim *anim);
390
391 /**
392  *
393  * \attention Defined in filter.c
394  */
395
396 #define FILTER_MASK_NULL 0
397 #define FILTER_MASK_MARGIN 1
398 #define FILTER_MASK_USED 2
399
400 void IMB_filter(struct ImBuf *ibuf);
401 void IMB_mask_filter_extend(char *mask, int width, int height);
402 void IMB_mask_clear(struct ImBuf *ibuf, char *mask, int val);
403 void IMB_filter_extend(struct ImBuf *ibuf, char *mask, int filter);
404 void IMB_makemipmap(struct ImBuf *ibuf, int use_filter);
405 void IMB_remakemipmap(struct ImBuf *ibuf, int use_filter);
406 struct ImBuf *IMB_getmipmap(struct ImBuf *ibuf, int level);
407
408 /**
409  *
410  * \attention Defined in cache.c
411  */
412
413 void IMB_tile_cache_params(int totthread, int maxmem);
414 unsigned int *IMB_gettile(struct ImBuf *ibuf, int tx, int ty, int thread);
415 void IMB_tiles_to_rect(struct ImBuf *ibuf);
416
417 /**
418  *
419  * \attention Defined in filter.c
420  */
421 void IMB_filtery(struct ImBuf *ibuf);
422
423 /**
424  *
425  * \attention Defined in scaling.c
426  */
427 struct ImBuf *IMB_onehalf(struct ImBuf *ibuf1);
428
429 /**
430  *
431  * \attention Defined in scaling.c
432  */
433 bool IMB_scaleImBuf(struct ImBuf *ibuf, unsigned int newx, unsigned int newy);
434
435 /**
436  *
437  * \attention Defined in scaling.c
438  */
439 bool IMB_scalefastImBuf(struct ImBuf *ibuf, unsigned int newx, unsigned int newy);
440
441 /**
442  *
443  * \attention Defined in scaling.c
444  */
445 void IMB_scaleImBuf_threaded(struct ImBuf *ibuf, unsigned int newx, unsigned int newy);
446
447 /**
448  *
449  * \attention Defined in writeimage.c
450  */
451 short IMB_saveiff(struct ImBuf *ibuf, const char *filepath, int flags);
452 bool IMB_prepare_write_ImBuf(const bool isfloat, struct ImBuf *ibuf);
453
454 /**
455  *
456  * \attention Defined in util.c
457  */
458 bool IMB_ispic(const char *name);
459 int IMB_ispic_type(const char *name);
460
461 /**
462  *
463  * \attention Defined in util.c
464  */
465 bool IMB_isanim(const char *name);
466
467 /**
468  *
469  * \attention Defined in util.c
470  */
471 int imb_get_anim_type(const char *name);
472
473 /**
474  *
475  * \attention Defined in util.c
476  */
477 bool IMB_isfloat(struct ImBuf *ibuf);
478
479 /* create char buffer, color corrected if necessary, for ImBufs that lack one */
480 void IMB_rect_from_float(struct ImBuf *ibuf);
481 /* Create char buffer for part of the image, color corrected if necessary,
482  * Changed part will be stored in buffer.
483  * This is expected to be used for texture painting updates */
484 void IMB_partial_rect_from_float(
485     struct ImBuf *ibuf, float *buffer, int x, int y, int w, int h, bool is_data);
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_clamp(float *buf, int width, int height);
559 void IMB_buffer_float_unpremultiply(float *buf, int width, int height);
560 void IMB_buffer_float_premultiply(float *buf, int width, int height);
561
562 /**
563  * Change the ordering of the color bytes pointed to by rect from
564  * rgba to abgr. size * 4 color bytes are reordered.
565  *
566  * \attention Defined in imageprocess.c
567  */
568 void IMB_convert_rgba_to_abgr(struct ImBuf *ibuf);
569
570 /**
571  *
572  * \attention defined in imageprocess.c
573  */
574 void bicubic_interpolation(
575     struct ImBuf *in, struct ImBuf *out, float u, float v, int xout, int yout);
576 void nearest_interpolation(
577     struct ImBuf *in, struct ImBuf *out, float u, float v, int xout, int yout);
578 void bilinear_interpolation(
579     struct ImBuf *in, struct ImBuf *out, float u, float v, int xout, int yout);
580
581 void bicubic_interpolation_color(
582     struct ImBuf *in, unsigned char col[4], float col_float[4], float u, float v);
583 void nearest_interpolation_color(
584     struct ImBuf *in, unsigned char col[4], float col_float[4], float u, float v);
585 void nearest_interpolation_color_wrap(
586     struct ImBuf *in, unsigned char col[4], float col_float[4], float u, float v);
587 void bilinear_interpolation_color(
588     struct ImBuf *in, unsigned char col[4], float col_float[4], float u, float v);
589 void bilinear_interpolation_color_wrap(
590     struct ImBuf *in, unsigned char col[4], float col_float[4], float u, float v);
591
592 void IMB_alpha_under_color_float(float *rect_float, int x, int y, float backcol[3]);
593 void IMB_alpha_under_color_byte(unsigned char *rect, int x, int y, float backcol[3]);
594
595 /**
596  *
597  * \attention defined in readimage.c
598  */
599 struct ImBuf *IMB_loadifffile(
600     int file, const char *filepath, int flags, char colorspace[IM_MAX_SPACE], const char *descr);
601
602 /**
603  *
604  * \attention defined in scaling.c
605  */
606 struct ImBuf *IMB_half_x(struct ImBuf *ibuf1);
607
608 /**
609  *
610  * \attention defined in scaling.c
611  */
612 struct ImBuf *IMB_double_fast_x(struct ImBuf *ibuf1);
613
614 /**
615  *
616  * \attention defined in scaling.c
617  */
618 struct ImBuf *IMB_double_x(struct ImBuf *ibuf1);
619
620 /**
621  *
622  * \attention defined in scaling.c
623  */
624 struct ImBuf *IMB_half_y(struct ImBuf *ibuf1);
625
626 /**
627  *
628  * \attention defined in scaling.c
629  */
630 struct ImBuf *IMB_double_fast_y(struct ImBuf *ibuf1);
631
632 /**
633  *
634  * \attention defined in scaling.c
635  */
636 struct ImBuf *IMB_double_y(struct ImBuf *ibuf1);
637
638 /**
639  *
640  * \attention Defined in rotate.c
641  */
642 void IMB_flipx(struct ImBuf *ibuf);
643 void IMB_flipy(struct ImBuf *ibuf);
644
645 /* Premultiply alpha */
646
647 void IMB_premultiply_alpha(struct ImBuf *ibuf);
648 void IMB_unpremultiply_alpha(struct ImBuf *ibuf);
649
650 /**
651  *
652  * \attention Defined in allocimbuf.c
653  */
654 void IMB_freezbufImBuf(struct ImBuf *ibuf);
655 void IMB_freezbuffloatImBuf(struct ImBuf *ibuf);
656
657 /**
658  *
659  * \attention Defined in rectop.c
660  */
661 void IMB_rectfill(struct ImBuf *drect, const float col[4]);
662 void IMB_rectfill_area(struct ImBuf *ibuf,
663                        const float col[4],
664                        int x1,
665                        int y1,
666                        int x2,
667                        int y2,
668                        struct ColorManagedDisplay *display);
669 void IMB_rectfill_alpha(struct ImBuf *ibuf, const float value);
670
671 /* This should not be here, really,
672  * we needed it for operating on render data, IMB_rectfill_area calls it. */
673 void buf_rectfill_area(unsigned char *rect,
674                        float *rectf,
675                        int width,
676                        int height,
677                        const float col[4],
678                        struct ColorManagedDisplay *display,
679                        int x1,
680                        int y1,
681                        int x2,
682                        int y2);
683
684 /* exported for image tools in blender, to quickly allocate 32 bits rect */
685 void *imb_alloc_pixels(
686     unsigned int x, unsigned int y, unsigned int channels, size_t typesize, const char *name);
687
688 bool imb_addrectImBuf(struct ImBuf *ibuf);
689 void imb_freerectImBuf(struct ImBuf *ibuf);
690
691 bool imb_addrectfloatImBuf(struct ImBuf *ibuf);
692 void imb_freerectfloatImBuf(struct ImBuf *ibuf);
693 void imb_freemipmapImBuf(struct ImBuf *ibuf);
694
695 bool imb_addtilesImBuf(struct ImBuf *ibuf);
696 void imb_freetilesImBuf(struct ImBuf *ibuf);
697
698 /* threaded processors */
699 void IMB_processor_apply_threaded(
700     int buffer_lines,
701     int handle_size,
702     void *init_customdata,
703     void(init_handle)(void *handle, int start_line, int tot_line, void *customdata),
704     void *(do_thread)(void *));
705
706 typedef void (*ScanlineThreadFunc)(void *custom_data, int start_scanline, int num_scanlines);
707 void IMB_processor_apply_threaded_scanlines(int total_scanlines,
708                                             ScanlineThreadFunc do_thread,
709                                             void *custom_data);
710
711 /* ffmpeg */
712 void IMB_ffmpeg_init(void);
713 const char *IMB_ffmpeg_last_error(void);
714
715 /**
716  *
717  * \attention defined in stereoimbuf.c
718  */
719 void IMB_stereo3d_write_dimensions(const char mode,
720                                    const bool is_squeezed,
721                                    const size_t width,
722                                    const size_t height,
723                                    size_t *r_width,
724                                    size_t *r_height);
725 void IMB_stereo3d_read_dimensions(const char mode,
726                                   const bool is_squeezed,
727                                   const size_t width,
728                                   const size_t height,
729                                   size_t *r_width,
730                                   size_t *r_height);
731 int *IMB_stereo3d_from_rect(struct ImageFormatData *im_format,
732                             const size_t x,
733                             const size_t y,
734                             const size_t channels,
735                             int *rect_left,
736                             int *rect_right);
737 float *IMB_stereo3d_from_rectf(struct ImageFormatData *im_format,
738                                const size_t x,
739                                const size_t y,
740                                const size_t channels,
741                                float *rectf_left,
742                                float *rectf_right);
743 struct ImBuf *IMB_stereo3d_ImBuf(struct ImageFormatData *im_format,
744                                  struct ImBuf *ibuf_left,
745                                  struct ImBuf *ibuf_right);
746 void IMB_ImBufFromStereo3d(struct Stereo3dFormat *s3d,
747                            struct ImBuf *ibuf_stereo,
748                            struct ImBuf **r_ibuf_left,
749                            struct ImBuf **r_ibuf_right);
750
751 #endif