Cycles: svn merge -r40411:40934 ^/trunk/blender
[blender.git] / source / blender / imbuf / intern / util.c
1 /*
2  *
3  * ***** BEGIN GPL LICENSE BLOCK *****
4  *
5  * This program is free software; you can redistribute it and/or
6  * modify it under the terms of the GNU General Public License
7  * as published by the Free Software Foundation; either version 2
8  * of the License, or (at your option) any later version.
9  *
10  * This program is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13  * GNU General Public License for more details.
14  *
15  * You should have received a copy of the GNU General Public License
16  * along with this program; if not, write to the Free Software Foundation,
17  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
18  *
19  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
20  * All rights reserved.
21  *
22  * The Original Code is: all of this file.
23  *
24  * Contributor(s): none yet.
25  *
26  * ***** END GPL LICENSE BLOCK *****
27  * util.c
28  *
29  * $Id$
30  */
31
32 /** \file blender/imbuf/intern/util.c
33  *  \ingroup imbuf
34  */
35
36
37 #ifdef _WIN32
38 #include <io.h>
39 #define open _open
40 #define read _read
41 #define close _close
42 #endif
43
44 #include "BLI_blenlib.h"
45
46 #include "DNA_userdef_types.h"
47 #include "BKE_global.h"
48
49 #include "imbuf.h"
50 #include "IMB_imbuf_types.h"
51 #include "IMB_imbuf.h"
52 #include "IMB_filetype.h"
53
54 #include "IMB_anim.h"
55
56 #ifdef WITH_QUICKTIME
57 #include "quicktime_import.h"
58 #endif
59
60 #ifdef WITH_FFMPEG
61 #include <libavcodec/avcodec.h>
62 #include <libavformat/avformat.h>
63 #include <libavdevice/avdevice.h>
64 #include <libavutil/log.h>
65
66 #include "ffmpeg_compat.h"
67
68 #endif
69
70 #define UTIL_DEBUG 0
71
72 const char *imb_ext_image[] = {
73         ".png",
74         ".tga",
75         ".bmp",
76         ".jpg", ".jpeg",
77         ".sgi", ".rgb", ".rgba",
78 #ifdef WITH_TIFF
79         ".tif", ".tiff", ".tx",
80 #endif
81 #ifdef WITH_OPENJPEG
82         ".jp2",
83 #endif
84 #ifdef WITH_HDR
85         ".hdr",
86 #endif
87 #ifdef WITH_DDS
88         ".dds",
89 #endif
90 #ifdef WITH_CINEON
91         ".dpx",
92         ".cin",
93 #endif
94 #ifdef WITH_OPENEXR
95         ".exr",
96 #endif
97         NULL};
98
99 const char *imb_ext_image_qt[] = {
100         ".gif",
101         ".psd",
102         ".pct", ".pict",
103         ".pntg",
104         ".qtif",
105         NULL};
106
107 const char *imb_ext_movie[] = {
108         ".avi",
109         ".flc",
110         ".mov",
111         ".movie",
112         ".mp4",
113         ".m4v",
114         ".m2v",
115         ".m2t",
116         ".m2ts",
117         ".mts",
118         ".mv",
119         ".avs",
120         ".wmv",
121         ".ogv",
122         ".dv",
123         ".mpeg",
124         ".mpg",
125         ".mpg2",
126         ".vob",
127         ".mkv",
128         ".flv",
129         ".divx",
130         ".xvid",
131         ".mxf",
132         NULL};
133
134 /* sort of wrong being here... */
135 const char *imb_ext_audio[] = {
136         ".wav",
137         ".ogg",
138         ".oga",
139         ".mp3",
140         ".mp2",
141         ".ac3",
142         ".aac",
143         ".flac",
144         ".wma",
145         ".eac3",
146         ".aif",
147         ".aiff",
148         ".m4a",
149         NULL};
150
151 static int IMB_ispic_name(const char *name)
152 {
153         ImFileType *type;
154         struct stat st;
155         int fp, buf[10];
156
157         if(UTIL_DEBUG) printf("IMB_ispic_name: loading %s\n", name);
158
159         /*for(type=IMB_FILE_TYPES; type->is_a; type++)
160                 if(type->is_a_filepath && type->is_a_filepath(name))
161                         return type->filetype;*/
162         
163         if(stat(name,&st) == -1)
164                 return FALSE;
165         if(((st.st_mode) & S_IFMT) != S_IFREG)
166                 return FALSE;
167
168         if((fp = open(name,O_BINARY|O_RDONLY)) < 0)
169                 return FALSE;
170
171         if(read(fp, buf, 32) != 32) {
172                 close(fp);
173                 return FALSE;
174         }
175
176         close(fp);
177
178         /* XXX move this exception */
179         if((BIG_LONG(buf[0]) & 0xfffffff0) == 0xffd8ffe0)
180                 return JPG;
181
182         for(type=IMB_FILE_TYPES; type->is_a; type++)
183                 if(type->is_a && type->is_a((uchar*)buf))
184                         return type->filetype;
185
186         return FALSE;
187 }
188
189 int IMB_ispic(const char *filename)
190 {
191         if(U.uiflag & USER_FILTERFILEEXTS) {
192                 if(     (BLI_testextensie_array(filename, imb_ext_image)) ||
193                         (G.have_quicktime && BLI_testextensie_array(filename, imb_ext_image_qt))
194                 ) {
195                         return IMB_ispic_name(filename);
196                 }
197                 else  {
198                         return FALSE;
199                 }
200         }
201         else { /* no FILTERFILEEXTS */
202                 return IMB_ispic_name(filename);
203         }
204 }
205
206
207
208 static int isavi (const char *name) {
209         return AVI_is_avi (name);
210 }
211
212 #ifdef WITH_QUICKTIME
213 static int isqtime (const char *name) {
214         return anim_is_quicktime (name);
215 }
216 #endif
217
218 #ifdef WITH_FFMPEG
219
220 void silence_log_ffmpeg(int quiet)
221 {
222         if (quiet)
223         {
224                 av_log_set_level(AV_LOG_QUIET);
225         }
226         else
227         {
228                 av_log_set_level(AV_LOG_DEBUG);
229         }
230 }
231
232 extern void do_init_ffmpeg(void);
233 void do_init_ffmpeg(void)
234 {
235         static int ffmpeg_init = 0;
236         if (!ffmpeg_init) {
237                 ffmpeg_init = 1;
238                 av_register_all();
239                 avdevice_register_all();
240                 
241                 if ((G.f & G_DEBUG) == 0) {
242                         silence_log_ffmpeg(1);
243                 } else {
244                         silence_log_ffmpeg(0);
245                 }
246         }
247 }
248
249 static int isffmpeg (const char *filename) {
250         AVFormatContext *pFormatCtx;
251         unsigned int i;
252         int videoStream;
253         AVCodec *pCodec;
254         AVCodecContext *pCodecCtx;
255
256         do_init_ffmpeg();
257
258         if( BLI_testextensie(filename, ".swf") ||
259                 BLI_testextensie(filename, ".jpg") ||
260                 BLI_testextensie(filename, ".png") ||
261                 BLI_testextensie(filename, ".dds") ||
262                 BLI_testextensie(filename, ".tga") ||
263                 BLI_testextensie(filename, ".bmp") ||
264                 BLI_testextensie(filename, ".exr") ||
265                 BLI_testextensie(filename, ".cin") ||
266                 BLI_testextensie(filename, ".wav")) return 0;
267
268         if(av_open_input_file(&pFormatCtx, filename, NULL, 0, NULL)!=0) {
269                 if(UTIL_DEBUG) fprintf(stderr, "isffmpeg: av_open_input_file failed\n");
270                 return 0;
271         }
272
273         if(av_find_stream_info(pFormatCtx)<0) {
274                 if(UTIL_DEBUG) fprintf(stderr, "isffmpeg: av_find_stream_info failed\n");
275                 av_close_input_file(pFormatCtx);
276                 return 0;
277         }
278
279         if(UTIL_DEBUG) av_dump_format(pFormatCtx, 0, filename, 0);
280
281
282                 /* Find the first video stream */
283         videoStream=-1;
284         for(i=0; i<pFormatCtx->nb_streams; i++)
285                 if(pFormatCtx->streams[i] &&
286                    pFormatCtx->streams[i]->codec && 
287                   (pFormatCtx->streams[i]->codec->codec_type==AVMEDIA_TYPE_VIDEO))
288                 {
289                         videoStream=i;
290                         break;
291                 }
292
293         if(videoStream==-1) {
294                 av_close_input_file(pFormatCtx);
295                 return 0;
296         }
297
298         pCodecCtx = pFormatCtx->streams[videoStream]->codec;
299
300                 /* Find the decoder for the video stream */
301         pCodec=avcodec_find_decoder(pCodecCtx->codec_id);
302         if(pCodec==NULL) {
303                 av_close_input_file(pFormatCtx);
304                 return 0;
305         }
306
307         if(avcodec_open(pCodecCtx, pCodec)<0) {
308                 av_close_input_file(pFormatCtx);
309                 return 0;
310         }
311
312         avcodec_close(pCodecCtx);
313         av_close_input_file(pFormatCtx);
314
315         return 1;
316 }
317 #endif
318
319 #ifdef WITH_REDCODE
320 static int isredcode(const char * filename)
321 {
322         struct redcode_handle * h = redcode_open(filename);
323         if (!h) {
324                 return 0;
325         }
326         redcode_close(h);
327         return 1;
328 }
329
330 #endif
331
332 int imb_get_anim_type(const char * name) {
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 (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 (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         if (isavi(name)) return (ANIM_AVI);
364 #endif
365 #ifdef WITH_REDCODE
366         if (isredcode(name)) return (ANIM_REDCODE);
367 #endif
368         type = IMB_ispic(name);
369         if (type) return(ANIM_SEQUENCE);
370         return(0);
371 }
372  
373 int IMB_isanim(const char *filename) {
374         int type;
375         
376         if(U.uiflag & USER_FILTERFILEEXTS) {
377                 if (G.have_quicktime){
378                         if(             BLI_testextensie(filename, ".avi")
379                                 ||      BLI_testextensie(filename, ".flc")
380                                 ||      BLI_testextensie(filename, ".dv")
381                                 ||      BLI_testextensie(filename, ".r3d")
382                                 ||      BLI_testextensie(filename, ".mov")
383                                 ||      BLI_testextensie(filename, ".movie")
384                                 ||      BLI_testextensie(filename, ".mv")) {
385                                 type = imb_get_anim_type(filename);
386                         } else {
387                                 return(FALSE);                  
388                         }
389                 } else { // no quicktime
390                         if(             BLI_testextensie(filename, ".avi")
391                                 ||      BLI_testextensie(filename, ".dv")
392                                 ||      BLI_testextensie(filename, ".r3d")
393                                 ||      BLI_testextensie(filename, ".mv")) {
394                                 type = imb_get_anim_type(filename);
395                         }
396                         else  {
397                                 return(FALSE);
398                         }
399                 }
400         } else { // no FILTERFILEEXTS
401                 type = imb_get_anim_type(filename);
402         }
403         
404         return (type && type!=ANIM_SEQUENCE);
405 }