code cleanup: remove unused and unsupported functions from libmv-capi
[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 <stdlib.h>
43
44 #include "BLI_path_util.h"
45 #include "BLI_fileops.h"
46 #include "BLI_utildefines.h"
47 #include "BLI_string.h"
48
49 #include "DNA_userdef_types.h"
50 #include "BKE_global.h"
51
52 #include "imbuf.h"
53 #include "IMB_imbuf_types.h"
54 #include "IMB_imbuf.h"
55 #include "IMB_filetype.h"
56
57 #include "IMB_anim.h"
58
59 #ifdef WITH_QUICKTIME
60 #include "quicktime_import.h"
61 #endif
62
63 #ifdef WITH_FFMPEG
64 #include <libavcodec/avcodec.h>
65 #include <libavformat/avformat.h>
66 #include <libavdevice/avdevice.h>
67 #include <libavutil/log.h>
68
69 #include "ffmpeg_compat.h"
70
71 #endif
72
73 #define UTIL_DEBUG 0
74
75 const char *imb_ext_image[] = {
76         ".png",
77         ".tga",
78         ".bmp",
79         ".jpg", ".jpeg",
80         ".sgi", ".rgb", ".rgba",
81 #ifdef WITH_TIFF
82         ".tif", ".tiff", ".tx",
83 #endif
84 #ifdef WITH_OPENJPEG
85         ".jp2",
86         ".j2c",
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
104 const char *imb_ext_image_qt[] = {
105         ".gif",
106         ".psd",
107         ".pct", ".pict",
108         ".pntg",
109         ".qtif",
110         NULL
111 };
112
113 const char *imb_ext_movie[] = {
114         ".avi",
115         ".flc",
116         ".mov",
117         ".movie",
118         ".mp4",
119         ".m4v",
120         ".m2v",
121         ".m2t",
122         ".m2ts",
123         ".mts",
124         ".mv",
125         ".avs",
126         ".wmv",
127         ".ogv",
128         ".dv",
129         ".mpeg",
130         ".mpg",
131         ".mpg2",
132         ".vob",
133         ".mkv",
134         ".flv",
135         ".divx",
136         ".xvid",
137         ".mxf",
138         NULL
139 };
140
141 /* sort of wrong being here... */
142 const char *imb_ext_audio[] = {
143         ".wav",
144         ".ogg",
145         ".oga",
146         ".mp3",
147         ".mp2",
148         ".ac3",
149         ".aac",
150         ".flac",
151         ".wma",
152         ".eac3",
153         ".aif",
154         ".aiff",
155         ".m4a",
156         NULL
157 };
158
159 static int IMB_ispic_name(const char *name)
160 {
161         ImFileType *type;
162         struct stat st;
163         int fp, buf[10];
164
165         if (UTIL_DEBUG) printf("IMB_ispic_name: loading %s\n", name);
166         
167         if (stat(name, &st) == -1)
168                 return FALSE;
169         if (((st.st_mode) & S_IFMT) != S_IFREG)
170                 return FALSE;
171
172         if ((fp = BLI_open(name, O_BINARY | O_RDONLY, 0)) < 0)
173                 return FALSE;
174
175         if (read(fp, buf, 32) != 32) {
176                 close(fp);
177                 return FALSE;
178         }
179
180         close(fp);
181
182         /* XXX move this exception */
183         if ((BIG_LONG(buf[0]) & 0xfffffff0) == 0xffd8ffe0)
184                 return JPG;
185
186         for (type = IMB_FILE_TYPES; type->is_a; type++)
187                 if (type->is_a((uchar *)buf))
188                         return type->filetype;
189
190         return FALSE;
191 }
192
193 int IMB_ispic(const char *filename)
194 {
195         if (U.uiflag & USER_FILTERFILEEXTS) {
196                 if ((BLI_testextensie_array(filename, imb_ext_image)) ||
197                     (G.have_quicktime && BLI_testextensie_array(filename, imb_ext_image_qt)))
198                 {
199                         return IMB_ispic_name(filename);
200                 }
201                 else {
202                         return FALSE;
203                 }
204         }
205         else { /* no FILTERFILEEXTS */
206                 return IMB_ispic_name(filename);
207         }
208 }
209
210
211
212 static int isavi(const char *name)
213 {
214 #ifdef WITH_AVI
215         return AVI_is_avi(name);
216 #else
217         (void)name;
218         return FALSE;
219 #endif
220 }
221
222 #ifdef WITH_QUICKTIME
223 static int isqtime(const char *name)
224 {
225         return anim_is_quicktime(name);
226 }
227 #endif
228
229 #ifdef WITH_FFMPEG
230
231 #ifdef _MSC_VER
232 #define va_copy(dst, src) ((dst) = (src))
233 #endif
234
235 /* BLI_vsnprintf in ffmpeg_log_callback() causes invalid warning */
236 #ifdef __GNUC__
237 #  pragma GCC diagnostic push
238 #  pragma GCC diagnostic ignored "-Wmissing-format-attribute"
239 #endif
240
241 static char ffmpeg_last_error[1024];
242
243 static void ffmpeg_log_callback(void *ptr, int level, const char *format, va_list arg)
244 {
245         if (ELEM(level, AV_LOG_FATAL, AV_LOG_ERROR)) {
246                 size_t n;
247                 va_list arg2;
248
249                 va_copy(arg2, arg);
250
251                 n = BLI_vsnprintf(ffmpeg_last_error, sizeof(ffmpeg_last_error), format, arg2);
252
253                 /* strip trailing \n */
254                 ffmpeg_last_error[n - 1] = '\0';
255         }
256
257         if (G.debug & G_DEBUG_FFMPEG) {
258                 /* call default logger to print all message to console */
259                 av_log_default_callback(ptr, level, format, arg);
260         }
261 }
262
263 #ifdef __GNUC__
264 #  pragma GCC diagnostic pop
265 #endif
266
267 void IMB_ffmpeg_init(void)
268 {
269         av_register_all();
270         avdevice_register_all();
271
272         ffmpeg_last_error[0] = '\0';
273
274         /* set own callback which could store last error to report to UI */
275         av_log_set_callback(ffmpeg_log_callback);
276 }
277
278 const char *IMB_ffmpeg_last_error(void)
279 {
280         return ffmpeg_last_error;
281 }
282
283 static int isffmpeg(const char *filename)
284 {
285         AVFormatContext *pFormatCtx = NULL;
286         unsigned int i;
287         int videoStream;
288         AVCodec *pCodec;
289         AVCodecContext *pCodecCtx;
290
291         if (BLI_testextensie(filename, ".swf") ||
292             BLI_testextensie(filename, ".jpg") ||
293             BLI_testextensie(filename, ".png") ||
294             BLI_testextensie(filename, ".dds") ||
295             BLI_testextensie(filename, ".tga") ||
296             BLI_testextensie(filename, ".bmp") ||
297             BLI_testextensie(filename, ".exr") ||
298             BLI_testextensie(filename, ".cin") ||
299             BLI_testextensie(filename, ".wav"))
300         {
301                 return 0;
302         }
303
304         if (avformat_open_input(&pFormatCtx, filename, NULL, NULL) != 0) {
305                 if (UTIL_DEBUG) fprintf(stderr, "isffmpeg: av_open_input_file failed\n");
306                 return 0;
307         }
308
309         if (avformat_find_stream_info(pFormatCtx, NULL) < 0) {
310                 if (UTIL_DEBUG) fprintf(stderr, "isffmpeg: avformat_find_stream_info failed\n");
311                 av_close_input_file(pFormatCtx);
312                 return 0;
313         }
314
315         if (UTIL_DEBUG) av_dump_format(pFormatCtx, 0, filename, 0);
316
317
318         /* Find the first video stream */
319         videoStream = -1;
320         for (i = 0; i < pFormatCtx->nb_streams; i++)
321                 if (pFormatCtx->streams[i] &&
322                     pFormatCtx->streams[i]->codec &&
323                     (pFormatCtx->streams[i]->codec->codec_type == AVMEDIA_TYPE_VIDEO))
324                 {
325                         videoStream = i;
326                         break;
327                 }
328
329         if (videoStream == -1) {
330                 av_close_input_file(pFormatCtx);
331                 return 0;
332         }
333
334         pCodecCtx = pFormatCtx->streams[videoStream]->codec;
335
336         /* Find the decoder for the video stream */
337         pCodec = avcodec_find_decoder(pCodecCtx->codec_id);
338         if (pCodec == NULL) {
339                 av_close_input_file(pFormatCtx);
340                 return 0;
341         }
342
343         if (avcodec_open2(pCodecCtx, pCodec, NULL) < 0) {
344                 av_close_input_file(pFormatCtx);
345                 return 0;
346         }
347
348         avcodec_close(pCodecCtx);
349         av_close_input_file(pFormatCtx);
350
351         return 1;
352 }
353 #endif
354
355 #ifdef WITH_REDCODE
356 static int isredcode(const char *filename)
357 {
358         struct redcode_handle *h = redcode_open(filename);
359         if (!h) {
360                 return 0;
361         }
362         redcode_close(h);
363         return 1;
364 }
365
366 #endif
367
368 int imb_get_anim_type(const char *name)
369 {
370         int type;
371         struct stat st;
372
373         if (UTIL_DEBUG) printf("in getanimtype: %s\n", name);
374
375 #ifndef _WIN32
376 #   ifdef WITH_QUICKTIME
377         if (isqtime(name)) return (ANIM_QTIME);
378 #   endif
379 #   ifdef WITH_FFMPEG
380         /* stat test below fails on large files > 4GB */
381         if (isffmpeg(name)) return (ANIM_FFMPEG);
382 #   endif
383         if (BLI_stat(name, &st) == -1) return(0);
384         if (((st.st_mode) & S_IFMT) != S_IFREG) return(0);
385
386         if (isavi(name)) return (ANIM_AVI);
387
388         if (ismovie(name)) return (ANIM_MOVIE);
389 #else
390         if (BLI_stat(name, &st) == -1) return(0);
391         if (((st.st_mode) & S_IFMT) != S_IFREG) return(0);
392
393         if (ismovie(name)) return (ANIM_MOVIE);
394 #   ifdef WITH_QUICKTIME
395         if (isqtime(name)) return (ANIM_QTIME);
396 #   endif
397 #   ifdef WITH_FFMPEG
398         if (isffmpeg(name)) return (ANIM_FFMPEG);
399 #   endif
400
401
402         if (isavi(name)) return (ANIM_AVI);
403 #endif
404 #ifdef WITH_REDCODE
405         if (isredcode(name)) return (ANIM_REDCODE);
406 #endif
407         type = IMB_ispic(name);
408         if (type) {
409                 return ANIM_SEQUENCE;
410         }
411
412         return ANIM_NONE;
413 }
414  
415 int IMB_isanim(const char *filename)
416 {
417         int type;
418         
419         if (U.uiflag & USER_FILTERFILEEXTS) {
420                 if (G.have_quicktime) {
421                         if (BLI_testextensie(filename, ".avi")   ||
422                             BLI_testextensie(filename, ".flc")   ||
423                             BLI_testextensie(filename, ".dv")    ||
424                             BLI_testextensie(filename, ".r3d")   ||
425                             BLI_testextensie(filename, ".mov")   ||
426                             BLI_testextensie(filename, ".movie") ||
427                             BLI_testextensie(filename, ".mv"))
428                         {
429                                 type = imb_get_anim_type(filename);
430                         }
431                         else {
432                                 return(FALSE);
433                         }
434                 }
435                 else { /* no quicktime */
436                         if (BLI_testextensie(filename, ".avi") ||
437                             BLI_testextensie(filename, ".dv")  ||
438                             BLI_testextensie(filename, ".r3d") ||
439                             BLI_testextensie(filename, ".mv"))
440                         {
441                                 type = imb_get_anim_type(filename);
442                         }
443                         else {
444                                 return(FALSE);
445                         }
446                 }
447         }
448         else { /* no FILTERFILEEXTS */
449                 type = imb_get_anim_type(filename);
450         }
451         
452         return (type && type != ANIM_SEQUENCE);
453 }