3e4136cbef9013f106a631c8231f9ecd52f463c0
[blender-staging.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 #if LIBAVFORMAT_VERSION_INT < (49 << 16)
67 #define FFMPEG_OLD_FRAME_RATE 1
68 #else
69 #define FFMPEG_CODEC_IS_POINTER 1
70 #endif
71
72 #endif
73
74 #define UTIL_DEBUG 0
75
76 const char *imb_ext_image[] = {
77         ".png",
78         ".tga",
79         ".bmp",
80         ".jpg", ".jpeg",
81         ".sgi", ".rgb", ".rgba",
82 #ifdef WITH_TIFF
83         ".tif", ".tiff", ".tx",
84 #endif
85 #ifdef WITH_OPENJPEG
86         ".jp2",
87 #endif
88 #ifdef WITH_HDR
89         ".hdr",
90 #endif
91 #ifdef WITH_DDS
92         ".dds",
93 #endif
94 #ifdef WITH_CINEON
95         ".dpx",
96         ".cin",
97 #endif
98 #ifdef WITH_OPENEXR
99         ".exr",
100 #endif
101         NULL};
102
103 const char *imb_ext_image_qt[] = {
104         ".gif",
105         ".psd",
106         ".pct", ".pict",
107         ".pntg",
108         ".qtif",
109         NULL};
110
111 const char *imb_ext_movie[] = {
112         ".avi",
113         ".flc",
114         ".mov",
115         ".movie",
116         ".mp4",
117         ".m4v",
118         ".m2v",
119         ".m2t",
120         ".mts",
121         ".mv",
122         ".avs",
123         ".wmv",
124         ".ogv",
125         ".dv",
126         ".mpeg",
127         ".mpg",
128         ".mpg2",
129         ".vob",
130         ".mkv",
131         ".flv",
132         ".divx",
133         ".xvid",
134         ".mxf",
135         NULL};
136
137 /* sort of wrong being here... */
138 const char *imb_ext_audio[] = {
139         ".wav",
140         ".ogg",
141         ".oga",
142         ".mp3",
143         ".mp2",
144         ".ac3",
145         ".aac",
146         ".flac",
147         ".wma",
148         ".eac3",
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_INFO);
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                 {
239                         silence_log_ffmpeg(1);
240                 }
241         }
242 }
243
244 #ifdef FFMPEG_CODEC_IS_POINTER
245 static AVCodecContext* get_codec_from_stream(AVStream* stream)
246 {
247         return stream->codec;
248 }
249 #else
250 static AVCodecContext* get_codec_from_stream(AVStream* stream)
251 {
252         return &stream->codec;
253 }
254 #endif
255
256
257 static int isffmpeg (const char *filename) {
258         AVFormatContext *pFormatCtx;
259         unsigned int i;
260         int videoStream;
261         AVCodec *pCodec;
262         AVCodecContext *pCodecCtx;
263
264         do_init_ffmpeg();
265
266         if( BLI_testextensie(filename, ".swf") ||
267                 BLI_testextensie(filename, ".jpg") ||
268                 BLI_testextensie(filename, ".png") ||
269                 BLI_testextensie(filename, ".dds") ||
270                 BLI_testextensie(filename, ".tga") ||
271                 BLI_testextensie(filename, ".bmp") ||
272                 BLI_testextensie(filename, ".exr") ||
273                 BLI_testextensie(filename, ".cin") ||
274                 BLI_testextensie(filename, ".wav")) return 0;
275
276         if(av_open_input_file(&pFormatCtx, filename, NULL, 0, NULL)!=0) {
277                 if(UTIL_DEBUG) fprintf(stderr, "isffmpeg: av_open_input_file failed\n");
278                 return 0;
279         }
280
281         if(av_find_stream_info(pFormatCtx)<0) {
282                 if(UTIL_DEBUG) fprintf(stderr, "isffmpeg: av_find_stream_info failed\n");
283                 av_close_input_file(pFormatCtx);
284                 return 0;
285         }
286
287         if(UTIL_DEBUG) dump_format(pFormatCtx, 0, filename, 0);
288
289
290                 /* Find the first video stream */
291         videoStream=-1;
292         for(i=0; i<pFormatCtx->nb_streams; i++)
293                 if(pFormatCtx->streams[i] &&
294                    get_codec_from_stream(pFormatCtx->streams[i]) && 
295                   (get_codec_from_stream(pFormatCtx->streams[i])->codec_type==CODEC_TYPE_VIDEO))
296                 {
297                         videoStream=i;
298                         break;
299                 }
300
301         if(videoStream==-1) {
302                 av_close_input_file(pFormatCtx);
303                 return 0;
304         }
305
306         pCodecCtx = get_codec_from_stream(pFormatCtx->streams[videoStream]);
307
308                 /* Find the decoder for the video stream */
309         pCodec=avcodec_find_decoder(pCodecCtx->codec_id);
310         if(pCodec==NULL) {
311                 av_close_input_file(pFormatCtx);
312                 return 0;
313         }
314
315         if(avcodec_open(pCodecCtx, pCodec)<0) {
316                 av_close_input_file(pFormatCtx);
317                 return 0;
318         }
319
320         avcodec_close(pCodecCtx);
321         av_close_input_file(pFormatCtx);
322
323         return 1;
324 }
325 #endif
326
327 #ifdef WITH_REDCODE
328 static int isredcode(const char * filename)
329 {
330         struct redcode_handle * h = redcode_open(filename);
331         if (!h) {
332                 return 0;
333         }
334         redcode_close(h);
335         return 1;
336 }
337
338 #endif
339
340 int imb_get_anim_type(const char * name) {
341         int type;
342         struct stat st;
343
344         if(UTIL_DEBUG) printf("in getanimtype: %s\n", name);
345
346 #ifndef _WIN32
347 #       ifdef WITH_QUICKTIME
348         if (isqtime(name)) return (ANIM_QTIME);
349 #       endif
350 #       ifdef WITH_FFMPEG
351         /* stat test below fails on large files > 4GB */
352         if (isffmpeg(name)) return (ANIM_FFMPEG);
353 #       endif
354         if (stat(name,&st) == -1) return(0);
355         if (((st.st_mode) & S_IFMT) != S_IFREG) return(0);
356
357         if (isavi(name)) return (ANIM_AVI);
358
359         if (ismovie(name)) return (ANIM_MOVIE);
360 #else
361         if (stat(name,&st) == -1) return(0);
362         if (((st.st_mode) & S_IFMT) != S_IFREG) return(0);
363
364         if (ismovie(name)) return (ANIM_MOVIE);
365 #       ifdef WITH_QUICKTIME
366         if (isqtime(name)) return (ANIM_QTIME);
367 #       endif
368 #       ifdef WITH_FFMPEG
369         if (isffmpeg(name)) return (ANIM_FFMPEG);
370 #       endif
371         if (isavi(name)) return (ANIM_AVI);
372 #endif
373 #ifdef WITH_REDCODE
374         if (isredcode(name)) return (ANIM_REDCODE);
375 #endif
376         type = IMB_ispic(name);
377         if (type) return(ANIM_SEQUENCE);
378         return(0);
379 }
380  
381 int IMB_isanim(const char *filename) {
382         int type;
383         
384         if(U.uiflag & USER_FILTERFILEEXTS) {
385                 if (G.have_quicktime){
386                         if(             BLI_testextensie(filename, ".avi")
387                                 ||      BLI_testextensie(filename, ".flc")
388                                 ||      BLI_testextensie(filename, ".dv")
389                                 ||      BLI_testextensie(filename, ".r3d")
390                                 ||      BLI_testextensie(filename, ".mov")
391                                 ||      BLI_testextensie(filename, ".movie")
392                                 ||      BLI_testextensie(filename, ".mv")) {
393                                 type = imb_get_anim_type(filename);
394                         } else {
395                                 return(FALSE);                  
396                         }
397                 } else { // no quicktime
398                         if(             BLI_testextensie(filename, ".avi")
399                                 ||      BLI_testextensie(filename, ".dv")
400                                 ||      BLI_testextensie(filename, ".r3d")
401                                 ||      BLI_testextensie(filename, ".mv")) {
402                                 type = imb_get_anim_type(filename);
403                         }
404                         else  {
405                                 return(FALSE);
406                         }
407                 }
408         } else { // no FILTERFILEEXTS
409                 type = imb_get_anim_type(filename);
410         }
411         
412         return (type && type!=ANIM_SEQUENCE);
413 }