47dad378eb7e9ec3415039b5094c00a93772a932
[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         if(stat(name,&st) == -1)
158                 return FALSE;
159         if(((st.st_mode) & S_IFMT) != S_IFREG)
160                 return FALSE;
161
162         if((fp = open(name,O_BINARY|O_RDONLY)) < 0)
163                 return FALSE;
164
165         if(read(fp, buf, 32) != 32) {
166                 close(fp);
167                 return FALSE;
168         }
169
170         close(fp);
171
172         /* XXX move this exception */
173         if((BIG_LONG(buf[0]) & 0xfffffff0) == 0xffd8ffe0)
174                 return JPG;
175
176         for(type=IMB_FILE_TYPES; type->is_a; type++)
177                 if(type->is_a((uchar*)buf))
178                         return type->filetype;
179
180         return FALSE;
181 }
182
183 int IMB_ispic(const char *filename)
184 {
185         if(U.uiflag & USER_FILTERFILEEXTS) {
186                 if(     (BLI_testextensie_array(filename, imb_ext_image)) ||
187                         (G.have_quicktime && BLI_testextensie_array(filename, imb_ext_image_qt))
188                 ) {
189                         return IMB_ispic_name(filename);
190                 }
191                 else  {
192                         return FALSE;
193                 }
194         }
195         else { /* no FILTERFILEEXTS */
196                 return IMB_ispic_name(filename);
197         }
198 }
199
200
201
202 static int isavi (const char *name)
203 {
204         return AVI_is_avi (name);
205 }
206
207 #ifdef WITH_QUICKTIME
208 static int isqtime (const char *name)
209 {
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 {
247         AVFormatContext *pFormatCtx;
248         unsigned int i;
249         int videoStream;
250         AVCodec *pCodec;
251         AVCodecContext *pCodecCtx;
252
253         do_init_ffmpeg();
254
255         if( BLI_testextensie(filename, ".swf") ||
256                 BLI_testextensie(filename, ".jpg") ||
257                 BLI_testextensie(filename, ".png") ||
258                 BLI_testextensie(filename, ".dds") ||
259                 BLI_testextensie(filename, ".tga") ||
260                 BLI_testextensie(filename, ".bmp") ||
261                 BLI_testextensie(filename, ".exr") ||
262                 BLI_testextensie(filename, ".cin") ||
263                 BLI_testextensie(filename, ".wav")) return 0;
264
265         if(av_open_input_file(&pFormatCtx, filename, NULL, 0, NULL)!=0) {
266                 if(UTIL_DEBUG) fprintf(stderr, "isffmpeg: av_open_input_file failed\n");
267                 return 0;
268         }
269
270         if(av_find_stream_info(pFormatCtx)<0) {
271                 if(UTIL_DEBUG) fprintf(stderr, "isffmpeg: av_find_stream_info failed\n");
272                 av_close_input_file(pFormatCtx);
273                 return 0;
274         }
275
276         if(UTIL_DEBUG) av_dump_format(pFormatCtx, 0, filename, 0);
277
278
279                 /* Find the first video stream */
280         videoStream=-1;
281         for(i=0; i<pFormatCtx->nb_streams; i++)
282                 if(pFormatCtx->streams[i] &&
283                    pFormatCtx->streams[i]->codec && 
284                   (pFormatCtx->streams[i]->codec->codec_type==AVMEDIA_TYPE_VIDEO))
285                 {
286                         videoStream=i;
287                         break;
288                 }
289
290         if(videoStream==-1) {
291                 av_close_input_file(pFormatCtx);
292                 return 0;
293         }
294
295         pCodecCtx = pFormatCtx->streams[videoStream]->codec;
296
297                 /* Find the decoder for the video stream */
298         pCodec=avcodec_find_decoder(pCodecCtx->codec_id);
299         if(pCodec==NULL) {
300                 av_close_input_file(pFormatCtx);
301                 return 0;
302         }
303
304         if(avcodec_open(pCodecCtx, pCodec)<0) {
305                 av_close_input_file(pFormatCtx);
306                 return 0;
307         }
308
309         avcodec_close(pCodecCtx);
310         av_close_input_file(pFormatCtx);
311
312         return 1;
313 }
314 #endif
315
316 #ifdef WITH_REDCODE
317 static int isredcode(const char * filename)
318 {
319         struct redcode_handle * h = redcode_open(filename);
320         if (!h) {
321                 return 0;
322         }
323         redcode_close(h);
324         return 1;
325 }
326
327 #endif
328
329 int imb_get_anim_type(const char * name)
330 {
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 {
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 }