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