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