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