Cycles: svn merge -r39457:39669 https://svn.blender.org/svnroot/bf-blender/trunk...
[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_INFO);
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                 {
243                         silence_log_ffmpeg(1);
244                 }
245         }
246 }
247
248 static int isffmpeg (const char *filename) {
249         AVFormatContext *pFormatCtx;
250         unsigned int i;
251         int videoStream;
252         AVCodec *pCodec;
253         AVCodecContext *pCodecCtx;
254
255         do_init_ffmpeg();
256
257         if( BLI_testextensie(filename, ".swf") ||
258                 BLI_testextensie(filename, ".jpg") ||
259                 BLI_testextensie(filename, ".png") ||
260                 BLI_testextensie(filename, ".dds") ||
261                 BLI_testextensie(filename, ".tga") ||
262                 BLI_testextensie(filename, ".bmp") ||
263                 BLI_testextensie(filename, ".exr") ||
264                 BLI_testextensie(filename, ".cin") ||
265                 BLI_testextensie(filename, ".wav")) return 0;
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         int type;
333         struct stat st;
334
335         if(UTIL_DEBUG) printf("in getanimtype: %s\n", name);
336
337 #ifndef _WIN32
338 #       ifdef WITH_QUICKTIME
339         if (isqtime(name)) return (ANIM_QTIME);
340 #       endif
341 #       ifdef WITH_FFMPEG
342         /* stat test below fails on large files > 4GB */
343         if (isffmpeg(name)) return (ANIM_FFMPEG);
344 #       endif
345         if (stat(name,&st) == -1) return(0);
346         if (((st.st_mode) & S_IFMT) != S_IFREG) return(0);
347
348         if (isavi(name)) return (ANIM_AVI);
349
350         if (ismovie(name)) return (ANIM_MOVIE);
351 #else
352         if (stat(name,&st) == -1) return(0);
353         if (((st.st_mode) & S_IFMT) != S_IFREG) return(0);
354
355         if (ismovie(name)) return (ANIM_MOVIE);
356 #       ifdef WITH_QUICKTIME
357         if (isqtime(name)) return (ANIM_QTIME);
358 #       endif
359 #       ifdef WITH_FFMPEG
360         if (isffmpeg(name)) return (ANIM_FFMPEG);
361 #       endif
362         if (isavi(name)) return (ANIM_AVI);
363 #endif
364 #ifdef WITH_REDCODE
365         if (isredcode(name)) return (ANIM_REDCODE);
366 #endif
367         type = IMB_ispic(name);
368         if (type) return(ANIM_SEQUENCE);
369         return(0);
370 }
371  
372 int IMB_isanim(const char *filename) {
373         int type;
374         
375         if(U.uiflag & USER_FILTERFILEEXTS) {
376                 if (G.have_quicktime){
377                         if(             BLI_testextensie(filename, ".avi")
378                                 ||      BLI_testextensie(filename, ".flc")
379                                 ||      BLI_testextensie(filename, ".dv")
380                                 ||      BLI_testextensie(filename, ".r3d")
381                                 ||      BLI_testextensie(filename, ".mov")
382                                 ||      BLI_testextensie(filename, ".movie")
383                                 ||      BLI_testextensie(filename, ".mv")) {
384                                 type = imb_get_anim_type(filename);
385                         } else {
386                                 return(FALSE);                  
387                         }
388                 } else { // no quicktime
389                         if(             BLI_testextensie(filename, ".avi")
390                                 ||      BLI_testextensie(filename, ".dv")
391                                 ||      BLI_testextensie(filename, ".r3d")
392                                 ||      BLI_testextensie(filename, ".mv")) {
393                                 type = imb_get_anim_type(filename);
394                         }
395                         else  {
396                                 return(FALSE);
397                         }
398                 }
399         } else { // no FILTERFILEEXTS
400                 type = imb_get_anim_type(filename);
401         }
402         
403         return (type && type!=ANIM_SEQUENCE);
404 }