Merge branch 'blender2.7'
[blender.git] / intern / ffmpeg / ffmpeg_compat.h
1 /*
2  * compatibility macros to make every ffmpeg installation appear
3  * like the most current installation (wrapping some functionality sometimes)
4  * it also includes all ffmpeg header files at once, no need to do it 
5  * separately.
6  *
7  * Copyright (c) 2011 Peter Schlaile
8  *
9  * This program is free software; you can redistribute it and/or modify
10  * it under the terms of the GNU General Public License as published by
11  * the Free Software Foundation; either version 2 of the License, or
12  * (at your option) any later version.
13  *
14  * This program is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17  * GNU General Public License for more details.
18  *
19  */
20
21 #ifndef __FFMPEG_COMPAT_H__
22 #define __FFMPEG_COMPAT_H__
23
24 #include <libavformat/avformat.h>
25
26 /* check our ffmpeg is new enough, avoids user complaints */
27 #if (LIBAVFORMAT_VERSION_MAJOR < 52) || ((LIBAVFORMAT_VERSION_MAJOR == 52) && (LIBAVFORMAT_VERSION_MINOR <= 64))
28 #  error "FFmpeg 0.7 or newer is needed, Upgrade your FFmpeg or disable it"
29 #endif
30 /* end sanity check */
31
32 /* visual studio 2012 does not define inline for C */
33 #ifdef _MSC_VER
34 #  define FFMPEG_INLINE static __inline
35 #else
36 #  define FFMPEG_INLINE static inline
37 #endif
38
39 #include <libavcodec/avcodec.h>
40 #include <libavutil/rational.h>
41 #include <libavutil/opt.h>
42 #include <libavutil/mathematics.h>
43
44 #if (LIBAVFORMAT_VERSION_MAJOR > 52) || ((LIBAVFORMAT_VERSION_MAJOR >= 52) && (LIBAVFORMAT_VERSION_MINOR >= 101))
45 #  define FFMPEG_HAVE_PARSE_UTILS 1
46 #  include <libavutil/parseutils.h>
47 #endif
48
49 #include <libswscale/swscale.h>
50
51 /* Stupid way to distinguish FFmpeg from Libav:
52  * - FFmpeg's MICRO version starts from 100 and goes up, while
53  * - Libav's micro is always below 100.
54  */
55 #if LIBAVCODEC_VERSION_MICRO >= 100
56 #  define AV_USING_FFMPEG
57 #else
58 #  define AV_USING_LIBAV
59 #endif
60
61 #if (LIBAVFORMAT_VERSION_MAJOR > 52) || ((LIBAVFORMAT_VERSION_MAJOR >= 52) && (LIBAVFORMAT_VERSION_MINOR >= 105))
62 #  define FFMPEG_HAVE_AVIO 1
63 #endif
64
65 #if (LIBAVCODEC_VERSION_MAJOR > 53) || ((LIBAVCODEC_VERSION_MAJOR == 53) && (LIBAVCODEC_VERSION_MINOR > 1)) || ((LIBAVCODEC_VERSION_MAJOR == 53) && (LIBAVCODEC_VERSION_MINOR == 1) && (LIBAVCODEC_VERSION_MICRO >= 1)) || ((LIBAVCODEC_VERSION_MAJOR == 52) && (LIBAVCODEC_VERSION_MINOR >= 121))
66 #  define FFMPEG_HAVE_DEFAULT_VAL_UNION 1
67 #endif
68
69 #if (LIBAVFORMAT_VERSION_MAJOR > 52) || ((LIBAVFORMAT_VERSION_MAJOR >= 52) && (LIBAVFORMAT_VERSION_MINOR >= 101))
70 #  define FFMPEG_HAVE_AV_DUMP_FORMAT 1
71 #endif
72
73 #if (LIBAVFORMAT_VERSION_MAJOR > 52) || ((LIBAVFORMAT_VERSION_MAJOR >= 52) && (LIBAVFORMAT_VERSION_MINOR >= 45))
74 #  define FFMPEG_HAVE_AV_GUESS_FORMAT 1
75 #endif
76
77 #if (LIBAVCODEC_VERSION_MAJOR > 52) || ((LIBAVCODEC_VERSION_MAJOR >= 52) && (LIBAVCODEC_VERSION_MINOR >= 23))
78 #  define FFMPEG_HAVE_DECODE_AUDIO3 1
79 #  define FFMPEG_HAVE_DECODE_VIDEO2 1
80 #endif
81
82 #if (LIBAVCODEC_VERSION_MAJOR > 52) || ((LIBAVCODEC_VERSION_MAJOR >= 52) && (LIBAVCODEC_VERSION_MINOR >= 64))
83 #  define FFMPEG_HAVE_AVMEDIA_TYPES 1
84 #endif
85
86 #if ((LIBAVCODEC_VERSION_MAJOR > 52) || (LIBAVCODEC_VERSION_MAJOR >= 52) && (LIBAVCODEC_VERSION_MINOR >= 29)) && \
87         ((LIBSWSCALE_VERSION_MAJOR > 0) || (LIBSWSCALE_VERSION_MAJOR >= 0) && (LIBSWSCALE_VERSION_MINOR >= 10))
88 #  define FFMPEG_SWSCALE_COLOR_SPACE_SUPPORT
89 #endif
90
91 #if ((LIBAVCODEC_VERSION_MAJOR > 54) || (LIBAVCODEC_VERSION_MAJOR >= 54) && (LIBAVCODEC_VERSION_MINOR > 14))
92 #  define FFMPEG_HAVE_CANON_H264_RESOLUTION_FIX
93 #endif
94
95 #if ((LIBAVCODEC_VERSION_MAJOR > 53) || (LIBAVCODEC_VERSION_MAJOR >= 53) && (LIBAVCODEC_VERSION_MINOR >= 60))
96 #  define FFMPEG_HAVE_ENCODE_AUDIO2
97 #endif
98
99 #if ((LIBAVCODEC_VERSION_MAJOR > 53) || (LIBAVCODEC_VERSION_MAJOR >= 53) && (LIBAVCODEC_VERSION_MINOR >= 42))
100 #  define FFMPEG_HAVE_DECODE_AUDIO4
101 #endif
102
103 #if ((LIBAVCODEC_VERSION_MAJOR > 54) || (LIBAVCODEC_VERSION_MAJOR >= 54) && (LIBAVCODEC_VERSION_MINOR >= 13))
104 #  define FFMPEG_HAVE_AVFRAME_SAMPLE_RATE
105 #endif
106
107 #if ((LIBAVUTIL_VERSION_MAJOR > 51) || (LIBAVUTIL_VERSION_MAJOR == 51) && (LIBAVUTIL_VERSION_MINOR >= 21))
108 #  define FFMPEG_FFV1_ALPHA_SUPPORTED
109 #  define FFMPEG_SAMPLE_FMT_S16P_SUPPORTED
110 #else
111
112 FFMPEG_INLINE
113 int av_sample_fmt_is_planar(enum AVSampleFormat sample_fmt)
114 {
115         /* no planar formats in FFmpeg < 0.9 */
116         (void) sample_fmt;
117         return 0;
118 }
119
120 #endif
121
122 /* XXX TODO Probably fix to correct modern flags in code? Not sure how old FFMPEG we want to support though,
123  * so for now this will do. */
124
125 #ifndef FF_MIN_BUFFER_SIZE
126 #  ifdef AV_INPUT_BUFFER_MIN_SIZE
127 #    define FF_MIN_BUFFER_SIZE AV_INPUT_BUFFER_MIN_SIZE
128 #  endif
129 #endif
130
131 #ifndef FF_INPUT_BUFFER_PADDING_SIZE
132 #  ifdef AV_INPUT_BUFFER_PADDING_SIZE
133 #    define FF_INPUT_BUFFER_PADDING_SIZE AV_INPUT_BUFFER_PADDING_SIZE
134 #  endif
135 #endif
136
137 #ifndef CODEC_FLAG_GLOBAL_HEADER
138 #  ifdef AV_CODEC_FLAG_GLOBAL_HEADER
139 #    define CODEC_FLAG_GLOBAL_HEADER AV_CODEC_FLAG_GLOBAL_HEADER
140 #  endif
141 #endif
142
143 #ifndef CODEC_FLAG_GLOBAL_HEADER
144 #  ifdef AV_CODEC_FLAG_GLOBAL_HEADER
145 #    define CODEC_FLAG_GLOBAL_HEADER AV_CODEC_FLAG_GLOBAL_HEADER
146 #  endif
147 #endif
148
149 #ifndef CODEC_FLAG_INTERLACED_DCT
150 #  ifdef AV_CODEC_FLAG_INTERLACED_DCT
151 #    define CODEC_FLAG_INTERLACED_DCT AV_CODEC_FLAG_INTERLACED_DCT
152 #  endif
153 #endif
154
155 #ifndef CODEC_FLAG_INTERLACED_ME
156 #  ifdef AV_CODEC_FLAG_INTERLACED_ME
157 #    define CODEC_FLAG_INTERLACED_ME AV_CODEC_FLAG_INTERLACED_ME
158 #  endif
159 #endif
160
161 /* FFmpeg upstream 1.0 is the first who added AV_ prefix. */
162 #if LIBAVCODEC_VERSION_INT < AV_VERSION_INT(54, 59, 100)
163 #  define AV_CODEC_ID_NONE CODEC_ID_NONE
164 #  define AV_CODEC_ID_MPEG4 CODEC_ID_MPEG4
165 #  define AV_CODEC_ID_MJPEG CODEC_ID_MJPEG
166 #  define AV_CODEC_ID_DNXHD CODEC_ID_DNXHD
167 #  define AV_CODEC_ID_MPEG2VIDEO CODEC_ID_MPEG2VIDEO
168 #  define AV_CODEC_ID_MPEG1VIDEO CODEC_ID_MPEG1VIDEO
169 #  define AV_CODEC_ID_DVVIDEO CODEC_ID_DVVIDEO
170 #  define AV_CODEC_ID_THEORA CODEC_ID_THEORA
171 #  define AV_CODEC_ID_PNG CODEC_ID_PNG
172 #  define AV_CODEC_ID_QTRLE CODEC_ID_QTRLE
173 #  define AV_CODEC_ID_FFV1 CODEC_ID_FFV1
174 #  define AV_CODEC_ID_HUFFYUV CODEC_ID_HUFFYUV
175 #  define AV_CODEC_ID_H264 CODEC_ID_H264
176 #  define AV_CODEC_ID_FLV1 CODEC_ID_FLV1
177
178 #  define AV_CODEC_ID_AAC CODEC_ID_AAC
179 #  define AV_CODEC_ID_AC3 CODEC_ID_AC3
180 #  define AV_CODEC_ID_MP3 CODEC_ID_MP3
181 #  define AV_CODEC_ID_MP2 CODEC_ID_MP2
182 #  define AV_CODEC_ID_FLAC CODEC_ID_FLAC
183 #  define AV_CODEC_ID_PCM_U8 CODEC_ID_PCM_U8
184 #  define AV_CODEC_ID_PCM_S16LE CODEC_ID_PCM_S16LE
185 #  define AV_CODEC_ID_PCM_S24LE CODEC_ID_PCM_S24LE
186 #  define AV_CODEC_ID_PCM_S32LE CODEC_ID_PCM_S32LE
187 #  define AV_CODEC_ID_PCM_F32LE CODEC_ID_PCM_F32LE
188 #  define AV_CODEC_ID_PCM_F64LE CODEC_ID_PCM_F64LE
189 #  define AV_CODEC_ID_VORBIS CODEC_ID_VORBIS
190 #endif
191
192 FFMPEG_INLINE
193 int av_get_cropped_height_from_codec(AVCodecContext *pCodecCtx)
194 {
195         int y = pCodecCtx->height;
196
197 #ifndef FFMPEG_HAVE_CANON_H264_RESOLUTION_FIX
198 /* really bad hack to remove this dreadfull black bar at the bottom
199    with Canon footage and old ffmpeg versions.
200    (to fix this properly in older ffmpeg versions one has to write a new
201    demuxer...) 
202            
203    see the actual fix here for reference:
204
205    http://git.libav.org/?p=libav.git;a=commit;h=30f515091c323da59c0f1b533703dedca2f4b95d
206
207    We do our best to apply this only to matching footage.
208 */
209         if (pCodecCtx->width == 1920 && 
210             pCodecCtx->height == 1088 &&
211             pCodecCtx->pix_fmt == PIX_FMT_YUVJ420P &&
212             pCodecCtx->codec_id == AV_CODEC_ID_H264 ) {
213                 y = 1080;
214         }
215 #endif
216
217         return y;
218 }
219
220 #if ((LIBAVUTIL_VERSION_MAJOR < 51) || (LIBAVUTIL_VERSION_MAJOR == 51) && (LIBAVUTIL_VERSION_MINOR < 22))
221 FFMPEG_INLINE
222 int av_opt_set(void *obj, const char *name, const char *val, int search_flags)
223 {
224         const AVOption *rv = NULL;
225         (void) search_flags;
226         av_set_string3(obj, name, val, 1, &rv);
227         return rv != NULL;
228 }
229
230 FFMPEG_INLINE
231 int av_opt_set_int(void *obj, const char *name, int64_t val, int search_flags)
232 {
233         const AVOption *rv = NULL;
234         (void) search_flags;
235         rv = av_set_int(obj, name, val);
236         return rv != NULL;
237 }
238
239 FFMPEG_INLINE
240 int av_opt_set_double(void *obj, const char *name, double val, int search_flags)
241 {
242         const AVOption *rv = NULL;
243         (void) search_flags;
244         rv = av_set_double(obj, name, val);
245         return rv != NULL;
246 }
247
248 #  define AV_OPT_TYPE_INT     FF_OPT_TYPE_INT
249 #  define AV_OPT_TYPE_INT64   FF_OPT_TYPE_INT64
250 #  define AV_OPT_TYPE_STRING  FF_OPT_TYPE_STRING
251 #  define AV_OPT_TYPE_CONST   FF_OPT_TYPE_CONST
252 #  define AV_OPT_TYPE_DOUBLE  FF_OPT_TYPE_DOUBLE
253 #  define AV_OPT_TYPE_FLOAT   FF_OPT_TYPE_FLOAT
254 #endif
255
256 #if ((LIBAVUTIL_VERSION_MAJOR < 51) || (LIBAVUTIL_VERSION_MAJOR == 51) && (LIBAVUTIL_VERSION_MINOR < 54))
257 FFMPEG_INLINE
258 enum AVSampleFormat av_get_packed_sample_fmt(enum AVSampleFormat sample_fmt)
259 {
260     if (sample_fmt < 0 || sample_fmt >= AV_SAMPLE_FMT_NB)
261         return AV_SAMPLE_FMT_NONE;
262     return sample_fmt;
263 }
264 #endif
265
266 #if ((LIBAVCODEC_VERSION_MAJOR < 53) || (LIBAVCODEC_VERSION_MAJOR == 53 && LIBAVCODEC_VERSION_MINOR < 35))
267 FFMPEG_INLINE
268 int avcodec_open2(AVCodecContext *avctx, AVCodec *codec, AVDictionary **options)
269 {
270         /* TODO: no options are taking into account */
271         (void) options;
272         return avcodec_open(avctx, codec);
273 }
274 #endif
275
276 #if ((LIBAVFORMAT_VERSION_MAJOR < 53) || (LIBAVFORMAT_VERSION_MAJOR == 53 && LIBAVFORMAT_VERSION_MINOR < 21))
277 FFMPEG_INLINE
278 AVStream *avformat_new_stream(AVFormatContext *s, AVCodec *c)
279 {
280         /* TODO: no codec is taking into account */
281         (void) c;
282         return av_new_stream(s, 0);
283 }
284
285 FFMPEG_INLINE
286 int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options)
287 {
288         /* TODO: no options are taking into account */
289         (void) options;
290         return av_find_stream_info(ic);
291 }
292 #endif
293
294 #if ((LIBAVFORMAT_VERSION_MAJOR > 53) || ((LIBAVFORMAT_VERSION_MAJOR == 53) && (LIBAVFORMAT_VERSION_MINOR > 32)) || ((LIBAVFORMAT_VERSION_MAJOR == 53) && (LIBAVFORMAT_VERSION_MINOR == 24) && (LIBAVFORMAT_VERSION_MICRO >= 100)))
295 FFMPEG_INLINE
296 void my_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp)
297 {
298         int i;
299
300         for (i = 0; i < s->nb_streams; i++) {
301                 AVStream *st = s->streams[i];
302
303                 st->cur_dts = av_rescale(timestamp,
304                                          st->time_base.den * (int64_t)ref_st->time_base.num,
305                                          st->time_base.num * (int64_t)ref_st->time_base.den);
306         }
307 }
308
309 FFMPEG_INLINE
310 void av_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp)
311 {
312         my_update_cur_dts(s, ref_st, timestamp);
313 }
314 #endif
315
316 #if ((LIBAVCODEC_VERSION_MAJOR < 54) || (LIBAVCODEC_VERSION_MAJOR == 54 && LIBAVCODEC_VERSION_MINOR < 28))
317 FFMPEG_INLINE
318 void avcodec_free_frame(AVFrame **frame)
319 {
320         /* don't need to do anything with old AVFrame
321          * since it does not have malloced members */
322         (void)frame;
323 }
324 #endif
325
326 #if ((LIBAVCODEC_VERSION_MAJOR > 54) || (LIBAVCODEC_VERSION_MAJOR >= 54) && (LIBAVCODEC_VERSION_MINOR >= 13))
327 #  define FFMPEG_HAVE_AVFRAME_SAMPLE_RATE
328 #endif
329
330 #if ((LIBAVCODEC_VERSION_MAJOR > 54) || (LIBAVCODEC_VERSION_MAJOR == 54 && LIBAVCODEC_VERSION_MINOR >= 13))
331 #  define FFMPEG_HAVE_FRAME_CHANNEL_LAYOUT
332 #endif
333
334 #ifndef FFMPEG_HAVE_AVIO
335 #  define AVIO_FLAG_WRITE URL_WRONLY
336 #  define avio_open url_fopen
337 #  define avio_tell url_ftell
338 #  define avio_close url_fclose
339 #  define avio_size url_fsize
340 #endif
341
342 /* there are some version inbetween, which have avio_... functions but no
343  * AVIO_FLAG_... */
344 #ifndef AVIO_FLAG_WRITE
345 #  define AVIO_FLAG_WRITE URL_WRONLY
346 #endif
347
348 #ifndef AV_PKT_FLAG_KEY
349 #  define AV_PKT_FLAG_KEY PKT_FLAG_KEY
350 #endif
351
352 #ifndef FFMPEG_HAVE_AV_DUMP_FORMAT
353 #  define av_dump_format dump_format
354 #endif
355
356 #ifndef FFMPEG_HAVE_AV_GUESS_FORMAT
357 #  define av_guess_format guess_format
358 #endif
359
360 #ifndef FFMPEG_HAVE_PARSE_UTILS
361 #  define av_parse_video_rate av_parse_video_frame_rate
362 #endif
363
364 #ifdef FFMPEG_HAVE_DEFAULT_VAL_UNION
365 #  define FFMPEG_DEF_OPT_VAL_INT(OPT) OPT->default_val.i64
366 #  define FFMPEG_DEF_OPT_VAL_DOUBLE(OPT) OPT->default_val.dbl
367 #else
368 #  define FFMPEG_DEF_OPT_VAL_INT(OPT) OPT->default_val
369 #  define FFMPEG_DEF_OPT_VAL_DOUBLE(OPT) OPT->default_val
370 #endif
371
372 #ifndef FFMPEG_HAVE_AVMEDIA_TYPES
373 #  define AVMEDIA_TYPE_VIDEO CODEC_TYPE_VIDEO
374 #  define AVMEDIA_TYPE_AUDIO CODEC_TYPE_AUDIO
375 #endif
376
377 #ifndef FFMPEG_HAVE_DECODE_AUDIO3
378 FFMPEG_INLINE 
379 int avcodec_decode_audio3(AVCodecContext *avctx, int16_t *samples,
380                           int *frame_size_ptr, AVPacket *avpkt)
381 {
382         return avcodec_decode_audio2(avctx, samples,
383                                      frame_size_ptr, avpkt->data,
384                                      avpkt->size);
385 }
386 #endif
387
388 #ifndef FFMPEG_HAVE_DECODE_VIDEO2
389 FFMPEG_INLINE
390 int avcodec_decode_video2(AVCodecContext *avctx, AVFrame *picture,
391                          int *got_picture_ptr,
392                          AVPacket *avpkt)
393 {
394         return avcodec_decode_video(avctx, picture, got_picture_ptr,
395                                     avpkt->data, avpkt->size);
396 }
397 #endif
398
399 FFMPEG_INLINE
400 int64_t av_get_pts_from_frame(AVFormatContext *avctx, AVFrame * picture)
401 {
402         int64_t pts;
403 #if LIBAVUTIL_VERSION_INT >= AV_VERSION_INT(55, 34, 100)
404         pts = picture->pts;
405 #else
406         pts = picture->pkt_pts;
407 #endif
408
409         if (pts == AV_NOPTS_VALUE) {
410                 pts = picture->pkt_dts;
411         }
412         if (pts == AV_NOPTS_VALUE) {
413                 pts = 0;
414         }
415
416         (void)avctx;
417         return pts;
418 }
419
420 /* obsolete constant formerly defined in FFMpeg libavcodec/avcodec.h */
421 #ifndef AVCODEC_MAX_AUDIO_FRAME_SIZE
422 #  define AVCODEC_MAX_AUDIO_FRAME_SIZE 192000 // 1 second of 48khz 32bit audio
423 #endif
424
425 #if LIBAVCODEC_VERSION_INT < AV_VERSION_INT(54, 1, 0)
426 FFMPEG_INLINE
427 int avcodec_encode_video2(AVCodecContext *avctx, AVPacket *pkt,
428                           const AVFrame *frame, int *got_output)
429 {
430         int outsize, ret;
431
432         ret = av_new_packet(pkt, avctx->width * avctx->height * 7 + 10000);
433         if (ret < 0)
434                 return ret;
435
436         outsize = avcodec_encode_video(avctx, pkt->data, pkt->size, frame);
437         if (outsize <= 0) {
438                 *got_output = 0;
439                 av_free_packet(pkt);
440         }
441         else {
442                 *got_output = 1;
443                 av_shrink_packet(pkt, outsize);
444                 if (avctx->coded_frame) {
445                         pkt->pts = avctx->coded_frame->pts;
446                         if (avctx->coded_frame->key_frame)
447                                 pkt->flags |= AV_PKT_FLAG_KEY;
448                 }
449         }
450
451         return outsize >= 0 ? 0 : outsize;
452 }
453
454 #endif
455
456 #if LIBAVFORMAT_VERSION_INT < AV_VERSION_INT(53, 17, 0)
457 FFMPEG_INLINE
458 void avformat_close_input(AVFormatContext **ctx)
459 {
460     av_close_input_file(*ctx);
461     *ctx = NULL;
462 }
463 #endif
464
465 #if LIBAVUTIL_VERSION_INT < AV_VERSION_INT(52, 8, 0)
466 FFMPEG_INLINE
467 AVFrame *av_frame_alloc(void)
468 {
469     return avcodec_alloc_frame();
470 }
471
472 FFMPEG_INLINE
473 void av_frame_free(AVFrame **frame)
474 {
475     av_freep(frame);
476 }
477 #endif
478
479 FFMPEG_INLINE
480 const char* av_get_metadata_key_value(AVDictionary *metadata, const char *key)
481 {
482         if (metadata == NULL) {
483                 return NULL;
484         }
485         AVDictionaryEntry *tag = NULL;
486         while ((tag = av_dict_get(metadata, "", tag, AV_DICT_IGNORE_SUFFIX))) {
487                 if (!strcmp(tag->key, key)) {
488                         return tag->value;
489                 }
490         }
491         return NULL;
492 }
493
494 FFMPEG_INLINE
495 bool av_check_encoded_with_ffmpeg(AVFormatContext *ctx)
496 {
497         const char* encoder = av_get_metadata_key_value(ctx->metadata, "ENCODER");
498         if (encoder != NULL && !strncmp(encoder, "Lavf", 4)) {
499                 return true;
500         }
501         return false;
502 }
503
504 FFMPEG_INLINE
505 AVRational av_get_r_frame_rate_compat(AVFormatContext *ctx,
506                                       const AVStream *stream)
507 {
508         /* If the video is encoded with FFmpeg and we are decoding with FFmpeg
509          * as well it seems to be more reliable to use r_frame_rate (tbr).
510          *
511          * For other cases we fall back to avg_frame_rate (fps) when possible.
512          */
513 #ifdef AV_USING_FFMPEG
514         if (av_check_encoded_with_ffmpeg(ctx)) {
515                 return stream->r_frame_rate;
516         }
517 #endif
518
519 #if LIBAVCODEC_VERSION_INT < AV_VERSION_INT(54, 23, 1)
520         /* For until r_frame_rate was deprecated use it. */
521         return stream->r_frame_rate;
522 #else
523 #  ifdef AV_USING_FFMPEG
524         /* Some of the videos might have average frame rate set to, while the
525          * r_frame_rate will show a correct value. This happens, for example, for
526          * OGG video files saved with Blender. */
527         if (stream->avg_frame_rate.den == 0) {
528                 return stream->r_frame_rate;
529         }
530 #  endif
531         return stream->avg_frame_rate;
532 #endif
533 }
534
535 #if LIBAVUTIL_VERSION_INT < AV_VERSION_INT(51, 32, 0)
536 #  define AV_OPT_SEARCH_FAKE_OBJ 0
537 #endif
538
539 #if LIBAVCODEC_VERSION_INT < AV_VERSION_INT(54, 59, 100)
540 #  define FFMPEG_HAVE_DEPRECATED_FLAGS2
541 #endif
542
543 /* Since FFmpeg-1.1 this constant have AV_ prefix. */
544 #if LIBAVUTIL_VERSION_INT < AV_VERSION_INT(52, 3, 100)
545 #  define AV_PIX_FMT_BGR32 PIX_FMT_BGR32
546 #  define AV_PIX_FMT_YUV422P PIX_FMT_YUV422P
547 #  define AV_PIX_FMT_BGRA PIX_FMT_BGRA
548 #  define AV_PIX_FMT_ARGB PIX_FMT_ARGB
549 #  define AV_PIX_FMT_RGBA PIX_FMT_RGBA
550 #endif
551
552 /* New API from FFmpeg-2.0 which soon became recommended one. */
553 #if LIBAVUTIL_VERSION_INT < AV_VERSION_INT(52, 38, 100)
554 #  define av_frame_alloc avcodec_alloc_frame
555 #  define av_frame_free avcodec_free_frame
556 #  define av_frame_unref avcodec_get_frame_defaults
557 #endif
558
559 #if LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(57, 24, 102)
560
561 /* NOTE: The code in this block are from FFmpeg 2.6.4, which is licensed by LGPL. */
562
563 #define MAX_NEG_CROP 1024
564
565 #define times4(x) x, x, x, x
566 #define times256(x) times4(times4(times4(times4(times4(x)))))
567
568 static const uint8_t ff_compat_crop_tab[256 + 2 * MAX_NEG_CROP] = {
569 times256(0x00),
570 0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0A,0x0B,0x0C,0x0D,0x0E,0x0F,
571 0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17,0x18,0x19,0x1A,0x1B,0x1C,0x1D,0x1E,0x1F,
572 0x20,0x21,0x22,0x23,0x24,0x25,0x26,0x27,0x28,0x29,0x2A,0x2B,0x2C,0x2D,0x2E,0x2F,
573 0x30,0x31,0x32,0x33,0x34,0x35,0x36,0x37,0x38,0x39,0x3A,0x3B,0x3C,0x3D,0x3E,0x3F,
574 0x40,0x41,0x42,0x43,0x44,0x45,0x46,0x47,0x48,0x49,0x4A,0x4B,0x4C,0x4D,0x4E,0x4F,
575 0x50,0x51,0x52,0x53,0x54,0x55,0x56,0x57,0x58,0x59,0x5A,0x5B,0x5C,0x5D,0x5E,0x5F,
576 0x60,0x61,0x62,0x63,0x64,0x65,0x66,0x67,0x68,0x69,0x6A,0x6B,0x6C,0x6D,0x6E,0x6F,
577 0x70,0x71,0x72,0x73,0x74,0x75,0x76,0x77,0x78,0x79,0x7A,0x7B,0x7C,0x7D,0x7E,0x7F,
578 0x80,0x81,0x82,0x83,0x84,0x85,0x86,0x87,0x88,0x89,0x8A,0x8B,0x8C,0x8D,0x8E,0x8F,
579 0x90,0x91,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0x9A,0x9B,0x9C,0x9D,0x9E,0x9F,
580 0xA0,0xA1,0xA2,0xA3,0xA4,0xA5,0xA6,0xA7,0xA8,0xA9,0xAA,0xAB,0xAC,0xAD,0xAE,0xAF,
581 0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,0xB8,0xB9,0xBA,0xBB,0xBC,0xBD,0xBE,0xBF,
582 0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF,
583 0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xD7,0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0xDF,
584 0xE0,0xE1,0xE2,0xE3,0xE4,0xE5,0xE6,0xE7,0xE8,0xE9,0xEA,0xEB,0xEC,0xED,0xEE,0xEF,
585 0xF0,0xF1,0xF2,0xF3,0xF4,0xF5,0xF6,0xF7,0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF,
586 times256(0xFF)
587 };
588
589 #undef times4
590 #undef times256
591
592 /* filter parameters: [-1 4 2 4 -1] // 8 */
593 FFMPEG_INLINE
594 void deinterlace_line(uint8_t *dst,
595                       const uint8_t *lum_m4, const uint8_t *lum_m3,
596                       const uint8_t *lum_m2, const uint8_t *lum_m1,
597                       const uint8_t *lum,
598                       int size)
599 {
600         const uint8_t *cm = ff_compat_crop_tab + MAX_NEG_CROP;
601         int sum;
602
603         for(;size > 0;size--) {
604                 sum = -lum_m4[0];
605                 sum += lum_m3[0] << 2;
606                 sum += lum_m2[0] << 1;
607                 sum += lum_m1[0] << 2;
608                 sum += -lum[0];
609                 dst[0] = cm[(sum + 4) >> 3];
610                 lum_m4++;
611                 lum_m3++;
612                 lum_m2++;
613                 lum_m1++;
614                 lum++;
615                 dst++;
616         }
617 }
618
619 FFMPEG_INLINE
620 void deinterlace_line_inplace(uint8_t *lum_m4, uint8_t *lum_m3,
621                               uint8_t *lum_m2, uint8_t *lum_m1,
622                               uint8_t *lum, int size)
623 {
624         const uint8_t *cm = ff_compat_crop_tab + MAX_NEG_CROP;
625         int sum;
626
627         for(;size > 0;size--) {
628                 sum = -lum_m4[0];
629                 sum += lum_m3[0] << 2;
630                 sum += lum_m2[0] << 1;
631                 lum_m4[0]=lum_m2[0];
632                 sum += lum_m1[0] << 2;
633                 sum += -lum[0];
634                 lum_m2[0] = cm[(sum + 4) >> 3];
635                 lum_m4++;
636                 lum_m3++;
637                 lum_m2++;
638                 lum_m1++;
639                 lum++;
640         }
641 }
642
643 /* deinterlacing : 2 temporal taps, 3 spatial taps linear filter. The
644    top field is copied as is, but the bottom field is deinterlaced
645    against the top field. */
646 FFMPEG_INLINE
647 void deinterlace_bottom_field(uint8_t *dst, int dst_wrap,
648                               const uint8_t *src1, int src_wrap,
649                               int width, int height)
650 {
651         const uint8_t *src_m2, *src_m1, *src_0, *src_p1, *src_p2;
652         int y;
653
654         src_m2 = src1;
655         src_m1 = src1;
656         src_0=&src_m1[src_wrap];
657         src_p1=&src_0[src_wrap];
658         src_p2=&src_p1[src_wrap];
659         for(y=0;y<(height-2);y+=2) {
660                 memcpy(dst,src_m1,width);
661                 dst += dst_wrap;
662                 deinterlace_line(dst,src_m2,src_m1,src_0,src_p1,src_p2,width);
663                 src_m2 = src_0;
664                 src_m1 = src_p1;
665                 src_0 = src_p2;
666                 src_p1 += 2*src_wrap;
667                 src_p2 += 2*src_wrap;
668                 dst += dst_wrap;
669         }
670         memcpy(dst,src_m1,width);
671         dst += dst_wrap;
672         /* do last line */
673         deinterlace_line(dst,src_m2,src_m1,src_0,src_0,src_0,width);
674 }
675
676 FFMPEG_INLINE
677 int deinterlace_bottom_field_inplace(uint8_t *src1, int src_wrap,
678                                      int width, int height)
679 {
680         uint8_t *src_m1, *src_0, *src_p1, *src_p2;
681         int y;
682         uint8_t *buf = (uint8_t *)av_malloc(width);
683         if (!buf)
684                 return AVERROR(ENOMEM);
685
686         src_m1 = src1;
687         memcpy(buf,src_m1,width);
688         src_0=&src_m1[src_wrap];
689         src_p1=&src_0[src_wrap];
690         src_p2=&src_p1[src_wrap];
691         for(y=0;y<(height-2);y+=2) {
692                 deinterlace_line_inplace(buf,src_m1,src_0,src_p1,src_p2,width);
693                 src_m1 = src_p1;
694                 src_0 = src_p2;
695                 src_p1 += 2*src_wrap;
696                 src_p2 += 2*src_wrap;
697         }
698         /* do last line */
699         deinterlace_line_inplace(buf,src_m1,src_0,src_0,src_0,width);
700         av_free(buf);
701         return 0;
702 }
703
704 #ifdef __GNUC__
705 #  pragma GCC diagnostic push
706 #  pragma GCC diagnostic ignored "-Wdeprecated-declarations"
707 #endif
708
709 FFMPEG_INLINE
710 int avpicture_deinterlace(AVPicture *dst, const AVPicture *src,
711                           enum AVPixelFormat pix_fmt, int width, int height)
712 {
713         int i, ret;
714
715         if (pix_fmt != AV_PIX_FMT_YUV420P &&
716             pix_fmt != AV_PIX_FMT_YUVJ420P &&
717             pix_fmt != AV_PIX_FMT_YUV422P &&
718             pix_fmt != AV_PIX_FMT_YUVJ422P &&
719             pix_fmt != AV_PIX_FMT_YUV444P &&
720             pix_fmt != AV_PIX_FMT_YUV411P &&
721             pix_fmt != AV_PIX_FMT_GRAY8)
722                 return -1;
723         if ((width & 3) != 0 || (height & 3) != 0)
724                 return -1;
725
726         for(i=0;i<3;i++) {
727                 if (i == 1) {
728                         switch(pix_fmt) {
729                         case AV_PIX_FMT_YUVJ420P:
730                         case AV_PIX_FMT_YUV420P:
731                                 width >>= 1;
732                                 height >>= 1;
733                                 break;
734                         case AV_PIX_FMT_YUV422P:
735                         case AV_PIX_FMT_YUVJ422P:
736                                 width >>= 1;
737                                 break;
738                         case AV_PIX_FMT_YUV411P:
739                                 width >>= 2;
740                                 break;
741                         default:
742                                 break;
743                         }
744                         if (pix_fmt == AV_PIX_FMT_GRAY8) {
745                                 break;
746                         }
747                 }
748                 if (src == dst) {
749                         ret = deinterlace_bottom_field_inplace(dst->data[i],
750                                                                dst->linesize[i],
751                                                                width, height);
752                         if (ret < 0)
753                                 return ret;
754                 } else {
755                         deinterlace_bottom_field(dst->data[i],dst->linesize[i],
756                                                  src->data[i], src->linesize[i],
757                                                  width, height);
758                 }
759         }
760         return 0;
761 }
762
763 #ifdef __GNUC__
764 #  pragma GCC diagnostic pop
765 #endif
766
767 #endif
768
769 #endif