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