Merge with trunk r40782
[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         if(stat(name,&st) == -1)
160                 return FALSE;
161         if(((st.st_mode) & S_IFMT) != S_IFREG)
162                 return FALSE;
163
164         if((fp = open(name,O_BINARY|O_RDONLY)) < 0)
165                 return FALSE;
166
167         if(read(fp, buf, 32) != 32) {
168                 close(fp);
169                 return FALSE;
170         }
171
172         close(fp);
173
174         /* XXX move this exception */
175         if((BIG_LONG(buf[0]) & 0xfffffff0) == 0xffd8ffe0)
176                 return JPG;
177
178         for(type=IMB_FILE_TYPES; type->is_a; type++)
179                 if(type->is_a((uchar*)buf))
180                         return type->filetype;
181
182         return FALSE;
183 }
184
185 int IMB_ispic(const char *filename)
186 {
187         if(U.uiflag & USER_FILTERFILEEXTS) {
188                 if(     (BLI_testextensie_array(filename, imb_ext_image)) ||
189                         (G.have_quicktime && BLI_testextensie_array(filename, imb_ext_image_qt))
190                 ) {
191                         return IMB_ispic_name(filename);
192                 }
193                 else  {
194                         return FALSE;
195                 }
196         }
197         else { /* no FILTERFILEEXTS */
198                 return IMB_ispic_name(filename);
199         }
200 }
201
202
203
204 static int isavi (const char *name) {
205         return AVI_is_avi (name);
206 }
207
208 #ifdef WITH_QUICKTIME
209 static int isqtime (const char *name) {
210         return anim_is_quicktime (name);
211 }
212 #endif
213
214 #ifdef WITH_FFMPEG
215
216 void silence_log_ffmpeg(int quiet)
217 {
218         if (quiet)
219         {
220                 av_log_set_level(AV_LOG_QUIET);
221         }
222         else
223         {
224                 av_log_set_level(AV_LOG_DEBUG);
225         }
226 }
227
228 extern void do_init_ffmpeg(void);
229 void do_init_ffmpeg(void)
230 {
231         static int ffmpeg_init = 0;
232         if (!ffmpeg_init) {
233                 ffmpeg_init = 1;
234                 av_register_all();
235                 avdevice_register_all();
236                 
237                 if ((G.f & G_DEBUG) == 0) {
238                         silence_log_ffmpeg(1);
239                 } else {
240                         silence_log_ffmpeg(0);
241                 }
242         }
243 }
244
245 static int isffmpeg (const char *filename) {
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")) return 0;
263
264         if(av_open_input_file(&pFormatCtx, filename, NULL, 0, NULL)!=0) {
265                 if(UTIL_DEBUG) fprintf(stderr, "isffmpeg: av_open_input_file failed\n");
266                 return 0;
267         }
268
269         if(av_find_stream_info(pFormatCtx)<0) {
270                 if(UTIL_DEBUG) fprintf(stderr, "isffmpeg: av_find_stream_info failed\n");
271                 av_close_input_file(pFormatCtx);
272                 return 0;
273         }
274
275         if(UTIL_DEBUG) av_dump_format(pFormatCtx, 0, filename, 0);
276
277
278                 /* Find the first video stream */
279         videoStream=-1;
280         for(i=0; i<pFormatCtx->nb_streams; i++)
281                 if(pFormatCtx->streams[i] &&
282                    pFormatCtx->streams[i]->codec && 
283                   (pFormatCtx->streams[i]->codec->codec_type==AVMEDIA_TYPE_VIDEO))
284                 {
285                         videoStream=i;
286                         break;
287                 }
288
289         if(videoStream==-1) {
290                 av_close_input_file(pFormatCtx);
291                 return 0;
292         }
293
294         pCodecCtx = pFormatCtx->streams[videoStream]->codec;
295
296                 /* Find the decoder for the video stream */
297         pCodec=avcodec_find_decoder(pCodecCtx->codec_id);
298         if(pCodec==NULL) {
299                 av_close_input_file(pFormatCtx);
300                 return 0;
301         }
302
303         if(avcodec_open(pCodecCtx, pCodec)<0) {
304                 av_close_input_file(pFormatCtx);
305                 return 0;
306         }
307
308         avcodec_close(pCodecCtx);
309         av_close_input_file(pFormatCtx);
310
311         return 1;
312 }
313 #endif
314
315 #ifdef WITH_REDCODE
316 static int isredcode(const char * filename)
317 {
318         struct redcode_handle * h = redcode_open(filename);
319         if (!h) {
320                 return 0;
321         }
322         redcode_close(h);
323         return 1;
324 }
325
326 #endif
327
328 int imb_get_anim_type(const char * name) {
329         int type;
330         struct stat st;
331
332         if(UTIL_DEBUG) printf("in getanimtype: %s\n", name);
333
334 #ifndef _WIN32
335 #       ifdef WITH_QUICKTIME
336         if (isqtime(name)) return (ANIM_QTIME);
337 #       endif
338 #       ifdef WITH_FFMPEG
339         /* stat test below fails on large files > 4GB */
340         if (isffmpeg(name)) return (ANIM_FFMPEG);
341 #       endif
342         if (stat(name,&st) == -1) return(0);
343         if (((st.st_mode) & S_IFMT) != S_IFREG) return(0);
344
345         if (isavi(name)) return (ANIM_AVI);
346
347         if (ismovie(name)) return (ANIM_MOVIE);
348 #else
349         if (stat(name,&st) == -1) return(0);
350         if (((st.st_mode) & S_IFMT) != S_IFREG) return(0);
351
352         if (ismovie(name)) return (ANIM_MOVIE);
353 #       ifdef WITH_QUICKTIME
354         if (isqtime(name)) return (ANIM_QTIME);
355 #       endif
356 #       ifdef WITH_FFMPEG
357         if (isffmpeg(name)) return (ANIM_FFMPEG);
358 #       endif
359         if (isavi(name)) return (ANIM_AVI);
360 #endif
361 #ifdef WITH_REDCODE
362         if (isredcode(name)) return (ANIM_REDCODE);
363 #endif
364         type = IMB_ispic(name);
365         if (type) return(ANIM_SEQUENCE);
366         return(0);
367 }
368  
369 int IMB_isanim(const char *filename) {
370         int type;
371         
372         if(U.uiflag & USER_FILTERFILEEXTS) {
373                 if (G.have_quicktime){
374                         if(             BLI_testextensie(filename, ".avi")
375                                 ||      BLI_testextensie(filename, ".flc")
376                                 ||      BLI_testextensie(filename, ".dv")
377                                 ||      BLI_testextensie(filename, ".r3d")
378                                 ||      BLI_testextensie(filename, ".mov")
379                                 ||      BLI_testextensie(filename, ".movie")
380                                 ||      BLI_testextensie(filename, ".mv")) {
381                                 type = imb_get_anim_type(filename);
382                         } else {
383                                 return(FALSE);                  
384                         }
385                 } else { // no quicktime
386                         if(             BLI_testextensie(filename, ".avi")
387                                 ||      BLI_testextensie(filename, ".dv")
388                                 ||      BLI_testextensie(filename, ".r3d")
389                                 ||      BLI_testextensie(filename, ".mv")) {
390                                 type = imb_get_anim_type(filename);
391                         }
392                         else  {
393                                 return(FALSE);
394                         }
395                 }
396         } else { // no FILTERFILEEXTS
397                 type = imb_get_anim_type(filename);
398         }
399         
400         return (type && type!=ANIM_SEQUENCE);
401 }