Fix msvc 2013 compiler errors after the ingenious cleanup in 4ca67869cc7a.
[blender.git] / source / blender / imbuf / intern / util.c
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  * util.c
27  *
28  */
29
30 /** \file blender/imbuf/intern/util.c
31  *  \ingroup imbuf
32  */
33
34
35 #ifdef _WIN32
36 #  include <io.h>
37 #  define open _open
38 #  define read _read
39 #  define close _close
40 #endif
41
42 #include <stdlib.h>
43
44 #include "BLI_utildefines.h"
45 #include "BLI_path_util.h"
46 #include "BLI_fileops.h"
47 #include "BLI_string.h"
48
49 #include "BKE_global.h"
50
51 #include "imbuf.h"
52 #include "IMB_imbuf_types.h"
53 #include "IMB_imbuf.h"
54 #include "IMB_filetype.h"
55
56 #include "IMB_anim.h"
57
58 #ifdef WITH_QUICKTIME
59 #include "quicktime_import.h"
60 #endif
61
62 #ifdef WITH_FFMPEG
63 #include <libavcodec/avcodec.h>
64 #include <libavformat/avformat.h>
65 #include <libavdevice/avdevice.h>
66 #include <libavutil/log.h>
67
68 #include "ffmpeg_compat.h"
69
70 #endif
71
72 #define UTIL_DEBUG 0
73
74 const char *imb_ext_image[] = {
75         ".png",
76         ".tga",
77         ".bmp",
78         ".jpg", ".jpeg",
79         ".sgi", ".rgb", ".rgba",
80 #ifdef WITH_TIFF
81         ".tif", ".tiff", ".tx",
82 #endif
83 #ifdef WITH_OPENJPEG
84         ".jp2",
85         ".j2c",
86 #endif
87 #ifdef WITH_HDR
88         ".hdr",
89 #endif
90 #ifdef WITH_DDS
91         ".dds",
92 #endif
93 #ifdef WITH_CINEON
94         ".dpx",
95         ".cin",
96 #endif
97 #ifdef WITH_OPENEXR
98         ".exr",
99 #endif
100 #ifdef WITH_OPENIMAGEIO
101         ".psd", ".pdd", ".psb",
102 #endif
103         NULL
104 };
105
106 const char *imb_ext_image_filepath_only[] = {
107 #ifdef WITH_OPENIMAGEIO
108         ".psd", ".pdd", ".psb",
109 #endif
110         NULL
111 };
112
113 const char *imb_ext_image_qt[] = {
114         ".gif",
115         ".psd",
116         ".pct", ".pict",
117         ".pntg",
118         ".qtif",
119         NULL
120 };
121
122 #if 0  /* UNUSED */
123 const char *imb_ext_movie_qt[] = {
124         ".avi",   
125         ".flc",   
126         ".dv",    
127         ".r3d",   
128         ".mov",   
129         ".movie", 
130         ".mv",
131         NULL
132 };
133 #endif
134
135 const char *imb_ext_movie[] = {
136         ".avi",
137         ".flc",
138         ".mov",
139         ".movie",
140         ".mp4",
141         ".m4v",
142         ".m2v",
143         ".m2t",
144         ".m2ts",
145         ".mts",
146         ".ts",
147         ".mv",
148         ".avs",
149         ".wmv",
150         ".ogv",
151         ".ogg",
152         ".r3d",
153         ".dv",
154         ".mpeg",
155         ".mpg",
156         ".mpg2",
157         ".vob",
158         ".mkv",
159         ".flv",
160         ".divx",
161         ".xvid",
162         ".mxf",
163         ".webm",
164         NULL
165 };
166
167 /* sort of wrong being here... */
168 const char *imb_ext_audio[] = {
169         ".wav",
170         ".ogg",
171         ".oga",
172         ".mp3",
173         ".mp2",
174         ".ac3",
175         ".aac",
176         ".flac",
177         ".wma",
178         ".eac3",
179         ".aif",
180         ".aiff",
181         ".m4a",
182         ".mka",
183         NULL
184 };
185
186 int IMB_ispic_type(const char *name)
187 {
188         /* increased from 32 to 64 because of the bitmaps header size */
189 #define HEADER_SIZE 64
190
191         unsigned char buf[HEADER_SIZE];
192         ImFileType *type;
193         struct stat st;
194         int fp;
195
196         if (UTIL_DEBUG) printf("IMB_ispic_name: loading %s\n", name);
197         
198         if (BLI_stat(name, &st) == -1)
199                 return false;
200         if (((st.st_mode) & S_IFMT) != S_IFREG)
201                 return false;
202
203         if ((fp = BLI_open(name, O_BINARY | O_RDONLY, 0)) == -1)
204                 return false;
205
206         memset(buf, 0, sizeof(buf));
207         if (read(fp, buf, HEADER_SIZE) <= 0) {
208                 close(fp);
209                 return false;
210         }
211
212         close(fp);
213
214         /* XXX move this exception */
215         if ((BIG_LONG(((int *)buf)[0]) & 0xfffffff0) == 0xffd8ffe0)
216                 return JPG;
217
218         for (type = IMB_FILE_TYPES; type < IMB_FILE_TYPES_LAST; type++) {
219                 if (type->is_a) {
220                         if (type->is_a(buf)) {
221                                 return type->filetype;
222                         }
223                 }
224                 else if (type->is_a_filepath) {
225                         if (type->is_a_filepath(name)) {
226                                 return type->filetype;
227                         }
228                 }
229         }
230
231         return 0;
232
233 #undef HEADER_SIZE
234 }
235
236 bool IMB_ispic(const char *name)
237 {
238         return (IMB_ispic_type(name) != 0);
239 }
240
241 static int isavi(const char *name)
242 {
243 #ifdef WITH_AVI
244         return AVI_is_avi(name);
245 #else
246         (void)name;
247         return false;
248 #endif
249 }
250
251 #ifdef WITH_QUICKTIME
252 static int isqtime(const char *name)
253 {
254         return anim_is_quicktime(name);
255 }
256 #endif
257
258 #ifdef WITH_FFMPEG
259
260 #if defined(_MSC_VER) && _MSC_VER < 1800
261 #define va_copy(dst, src) ((dst) = (src))
262 #endif
263
264 /* BLI_vsnprintf in ffmpeg_log_callback() causes invalid warning */
265 #ifdef __GNUC__
266 #  pragma GCC diagnostic push
267 #  pragma GCC diagnostic ignored "-Wmissing-format-attribute"
268 #endif
269
270 static char ffmpeg_last_error[1024];
271
272 static void ffmpeg_log_callback(void *ptr, int level, const char *format, va_list arg)
273 {
274         if (ELEM(level, AV_LOG_FATAL, AV_LOG_ERROR)) {
275                 size_t n;
276                 va_list args_cpy;
277
278                 va_copy(args_cpy, arg);
279                 n = BLI_vsnprintf(ffmpeg_last_error, sizeof(ffmpeg_last_error), format, args_cpy);
280                 va_end(args_cpy);
281
282                 /* strip trailing \n */
283                 ffmpeg_last_error[n - 1] = '\0';
284         }
285
286         if (G.debug & G_DEBUG_FFMPEG) {
287                 /* call default logger to print all message to console */
288                 av_log_default_callback(ptr, level, format, arg);
289         }
290 }
291
292 #ifdef __GNUC__
293 #  pragma GCC diagnostic pop
294 #endif
295
296 void IMB_ffmpeg_init(void)
297 {
298         av_register_all();
299         avdevice_register_all();
300
301         ffmpeg_last_error[0] = '\0';
302
303         if (G.debug & G_DEBUG_FFMPEG)
304                 av_log_set_level(AV_LOG_DEBUG);
305
306         /* set own callback which could store last error to report to UI */
307         av_log_set_callback(ffmpeg_log_callback);
308 }
309
310 const char *IMB_ffmpeg_last_error(void)
311 {
312         return ffmpeg_last_error;
313 }
314
315 static int isffmpeg(const char *filename)
316 {
317         AVFormatContext *pFormatCtx = NULL;
318         unsigned int i;
319         int videoStream;
320         AVCodec *pCodec;
321         AVCodecContext *pCodecCtx;
322
323         if (BLI_testextensie_n(
324                 filename,
325                 ".swf", ".jpg", ".png", ".dds", ".tga", ".bmp", ".tif", ".exr", ".cin", ".wav", NULL))
326         {
327                 return 0;
328         }
329
330         if (avformat_open_input(&pFormatCtx, filename, NULL, NULL) != 0) {
331                 if (UTIL_DEBUG) fprintf(stderr, "isffmpeg: av_open_input_file failed\n");
332                 return 0;
333         }
334
335         if (avformat_find_stream_info(pFormatCtx, NULL) < 0) {
336                 if (UTIL_DEBUG) fprintf(stderr, "isffmpeg: avformat_find_stream_info failed\n");
337                 avformat_close_input(&pFormatCtx);
338                 return 0;
339         }
340
341         if (UTIL_DEBUG) av_dump_format(pFormatCtx, 0, filename, 0);
342
343
344         /* Find the first video stream */
345         videoStream = -1;
346         for (i = 0; i < pFormatCtx->nb_streams; i++)
347                 if (pFormatCtx->streams[i] &&
348                     pFormatCtx->streams[i]->codec &&
349                     (pFormatCtx->streams[i]->codec->codec_type == AVMEDIA_TYPE_VIDEO))
350                 {
351                         videoStream = i;
352                         break;
353                 }
354
355         if (videoStream == -1) {
356                 avformat_close_input(&pFormatCtx);
357                 return 0;
358         }
359
360         pCodecCtx = pFormatCtx->streams[videoStream]->codec;
361
362         /* Find the decoder for the video stream */
363         pCodec = avcodec_find_decoder(pCodecCtx->codec_id);
364         if (pCodec == NULL) {
365                 avformat_close_input(&pFormatCtx);
366                 return 0;
367         }
368
369         if (avcodec_open2(pCodecCtx, pCodec, NULL) < 0) {
370                 avformat_close_input(&pFormatCtx);
371                 return 0;
372         }
373
374         avcodec_close(pCodecCtx);
375         avformat_close_input(&pFormatCtx);
376
377         return 1;
378 }
379 #endif
380
381 #ifdef WITH_REDCODE
382 static int isredcode(const char *filename)
383 {
384         struct redcode_handle *h = redcode_open(filename);
385         if (!h) {
386                 return 0;
387         }
388         redcode_close(h);
389         return 1;
390 }
391
392 #endif
393
394 int imb_get_anim_type(const char *name)
395 {
396         int type;
397         struct stat st;
398
399         if (UTIL_DEBUG) printf("in getanimtype: %s\n", name);
400
401 #ifndef _WIN32
402 #   ifdef WITH_QUICKTIME
403         if (isqtime(name)) return (ANIM_QTIME);
404 #   endif
405 #   ifdef WITH_FFMPEG
406         /* stat test below fails on large files > 4GB */
407         if (isffmpeg(name)) return (ANIM_FFMPEG);
408 #   endif
409         if (BLI_stat(name, &st) == -1) return(0);
410         if (((st.st_mode) & S_IFMT) != S_IFREG) return(0);
411
412         if (isavi(name)) return (ANIM_AVI);
413
414         if (ismovie(name)) return (ANIM_MOVIE);
415 #else
416         if (BLI_stat(name, &st) == -1) return(0);
417         if (((st.st_mode) & S_IFMT) != S_IFREG) return(0);
418
419         if (ismovie(name)) return (ANIM_MOVIE);
420 #   ifdef WITH_QUICKTIME
421         if (isqtime(name)) return (ANIM_QTIME);
422 #   endif
423 #   ifdef WITH_FFMPEG
424         if (isffmpeg(name)) return (ANIM_FFMPEG);
425 #   endif
426
427
428         if (isavi(name)) return (ANIM_AVI);
429 #endif
430 #ifdef WITH_REDCODE
431         if (isredcode(name)) return (ANIM_REDCODE);
432 #endif
433         type = IMB_ispic(name);
434         if (type) {
435                 return ANIM_SEQUENCE;
436         }
437
438         return ANIM_NONE;
439 }
440  
441 bool IMB_isanim(const char *filename)
442 {
443         int type;
444         
445         type = imb_get_anim_type(filename);
446         
447         return (type && type != ANIM_SEQUENCE);
448 }