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