Reduce amount of deprecated symbols used from FFmpeg
[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 #include "BLI_fileops.h"
44
45 #include "DNA_userdef_types.h"
46 #include "BKE_global.h"
47
48 #include "imbuf.h"
49 #include "IMB_imbuf_types.h"
50 #include "IMB_imbuf.h"
51 #include "IMB_filetype.h"
52
53 #include "IMB_anim.h"
54
55 #ifdef WITH_QUICKTIME
56 #include "quicktime_import.h"
57 #endif
58
59 #ifdef WITH_FFMPEG
60 #include <libavcodec/avcodec.h>
61 #include <libavformat/avformat.h>
62 #include <libavdevice/avdevice.h>
63 #include <libavutil/log.h>
64
65 #include "ffmpeg_compat.h"
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
99 const char *imb_ext_image_qt[] = {
100         ".gif",
101         ".psd",
102         ".pct", ".pict",
103         ".pntg",
104         ".qtif",
105         NULL
106 };
107
108 const char *imb_ext_movie[] = {
109         ".avi",
110         ".flc",
111         ".mov",
112         ".movie",
113         ".mp4",
114         ".m4v",
115         ".m2v",
116         ".m2t",
117         ".m2ts",
118         ".mts",
119         ".mv",
120         ".avs",
121         ".wmv",
122         ".ogv",
123         ".dv",
124         ".mpeg",
125         ".mpg",
126         ".mpg2",
127         ".vob",
128         ".mkv",
129         ".flv",
130         ".divx",
131         ".xvid",
132         ".mxf",
133         NULL
134 };
135
136 /* sort of wrong being here... */
137 const char *imb_ext_audio[] = {
138         ".wav",
139         ".ogg",
140         ".oga",
141         ".mp3",
142         ".mp2",
143         ".ac3",
144         ".aac",
145         ".flac",
146         ".wma",
147         ".eac3",
148         ".aif",
149         ".aiff",
150         ".m4a",
151         NULL
152 };
153
154 static int IMB_ispic_name(const char *name)
155 {
156         ImFileType *type;
157         struct stat st;
158         int fp, buf[10];
159
160         if (UTIL_DEBUG) printf("IMB_ispic_name: loading %s\n", name);
161         
162         if (stat(name, &st) == -1)
163                 return FALSE;
164         if (((st.st_mode) & S_IFMT) != S_IFREG)
165                 return FALSE;
166
167         if ((fp = BLI_open(name, O_BINARY | O_RDONLY, 0)) < 0)
168                 return FALSE;
169
170         if (read(fp, buf, 32) != 32) {
171                 close(fp);
172                 return FALSE;
173         }
174
175         close(fp);
176
177         /* XXX move this exception */
178         if ((BIG_LONG(buf[0]) & 0xfffffff0) == 0xffd8ffe0)
179                 return JPG;
180
181         for (type = IMB_FILE_TYPES; type->is_a; type++)
182                 if (type->is_a((uchar *)buf))
183                         return type->filetype;
184
185         return FALSE;
186 }
187
188 int IMB_ispic(const char *filename)
189 {
190         if (U.uiflag & USER_FILTERFILEEXTS) {
191                 if ((BLI_testextensie_array(filename, imb_ext_image)) ||
192                     (G.have_quicktime && BLI_testextensie_array(filename, imb_ext_image_qt)))
193                 {
194                         return IMB_ispic_name(filename);
195                 }
196                 else {
197                         return FALSE;
198                 }
199         }
200         else { /* no FILTERFILEEXTS */
201                 return IMB_ispic_name(filename);
202         }
203 }
204
205
206
207 static int isavi(const char *name)
208 {
209         return AVI_is_avi(name);
210 }
211
212 #ifdef WITH_QUICKTIME
213 static int isqtime(const char *name)
214 {
215         return anim_is_quicktime(name);
216 }
217 #endif
218
219 #ifdef WITH_FFMPEG
220
221 void silence_log_ffmpeg(int quiet)
222 {
223         if (quiet) {
224                 av_log_set_level(AV_LOG_QUIET);
225         }
226         else {
227                 av_log_set_level(AV_LOG_DEBUG);
228         }
229 }
230
231 extern void do_init_ffmpeg(void);
232 void do_init_ffmpeg(void)
233 {
234         static int ffmpeg_init = 0;
235         if (!ffmpeg_init) {
236                 ffmpeg_init = 1;
237                 av_register_all();
238                 avdevice_register_all();
239                 if ((G.debug & G_DEBUG_FFMPEG) == 0) {
240                         silence_log_ffmpeg(1);
241                 }
242                 else {
243                         silence_log_ffmpeg(0);
244                 }
245         }
246 }
247
248 static int isffmpeg(const char *filename)
249 {
250         AVFormatContext *pFormatCtx = NULL;
251         unsigned int i;
252         int videoStream;
253         AVCodec *pCodec;
254         AVCodecContext *pCodecCtx;
255
256         do_init_ffmpeg();
257
258         if (BLI_testextensie(filename, ".swf") ||
259             BLI_testextensie(filename, ".jpg") ||
260             BLI_testextensie(filename, ".png") ||
261             BLI_testextensie(filename, ".dds") ||
262             BLI_testextensie(filename, ".tga") ||
263             BLI_testextensie(filename, ".bmp") ||
264             BLI_testextensie(filename, ".exr") ||
265             BLI_testextensie(filename, ".cin") ||
266             BLI_testextensie(filename, ".wav"))
267         {
268                 return 0;
269         }
270
271         if (avformat_open_input(&pFormatCtx, filename, NULL, 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) av_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                     pFormatCtx->streams[i]->codec &&
290                     (pFormatCtx->streams[i]->codec->codec_type == AVMEDIA_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 = pFormatCtx->streams[videoStream]->codec;
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 {
337         int type;
338         struct stat st;
339
340         if (UTIL_DEBUG) printf("in getanimtype: %s\n", name);
341
342 #ifndef _WIN32
343 #   ifdef WITH_QUICKTIME
344         if (isqtime(name)) return (ANIM_QTIME);
345 #   endif
346 #   ifdef WITH_FFMPEG
347         /* stat test below fails on large files > 4GB */
348         if (isffmpeg(name)) return (ANIM_FFMPEG);
349 #   endif
350         if (BLI_stat(name, &st) == -1) return(0);
351         if (((st.st_mode) & S_IFMT) != S_IFREG) return(0);
352
353         if (isavi(name)) return (ANIM_AVI);
354
355         if (ismovie(name)) return (ANIM_MOVIE);
356 #else
357         if (BLI_stat(name, &st) == -1) return(0);
358         if (((st.st_mode) & S_IFMT) != S_IFREG) return(0);
359
360         if (ismovie(name)) return (ANIM_MOVIE);
361 #   ifdef WITH_QUICKTIME
362         if (isqtime(name)) return (ANIM_QTIME);
363 #   endif
364 #   ifdef WITH_FFMPEG
365         if (isffmpeg(name)) return (ANIM_FFMPEG);
366 #   endif
367
368
369         if (isavi(name)) return (ANIM_AVI);
370 #endif
371 #ifdef WITH_REDCODE
372         if (isredcode(name)) return (ANIM_REDCODE);
373 #endif
374         type = IMB_ispic(name);
375         if (type) {
376                 return ANIM_SEQUENCE;
377         }
378
379         return ANIM_NONE;
380 }
381  
382 int IMB_isanim(const char *filename)
383 {
384         int type;
385         
386         if (U.uiflag & USER_FILTERFILEEXTS) {
387                 if (G.have_quicktime) {
388                         if (BLI_testextensie(filename, ".avi")   ||
389                             BLI_testextensie(filename, ".flc")   ||
390                             BLI_testextensie(filename, ".dv")    ||
391                             BLI_testextensie(filename, ".r3d")   ||
392                             BLI_testextensie(filename, ".mov")   ||
393                             BLI_testextensie(filename, ".movie") ||
394                             BLI_testextensie(filename, ".mv"))
395                         {
396                                 type = imb_get_anim_type(filename);
397                         }
398                         else {
399                                 return(FALSE);                  
400                         }
401                 }
402                 else { /* no quicktime */
403                         if (BLI_testextensie(filename, ".avi") ||
404                             BLI_testextensie(filename, ".dv")  ||
405                             BLI_testextensie(filename, ".r3d") ||
406                             BLI_testextensie(filename, ".mv"))
407                         {
408                                 type = imb_get_anim_type(filename);
409                         }
410                         else {
411                                 return(FALSE);
412                         }
413                 }
414         }
415         else { /* no FILTERFILEEXTS */
416                 type = imb_get_anim_type(filename);
417         }
418         
419         return (type && type != ANIM_SEQUENCE);
420 }