Cycles: Make BVH wider prior to packing
[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         return stream->avg_frame_rate;
524 #endif
525 }
526
527 #if LIBAVUTIL_VERSION_INT < AV_VERSION_INT(51, 32, 0)
528 #  define AV_OPT_SEARCH_FAKE_OBJ 0
529 #endif
530
531 #if LIBAVCODEC_VERSION_INT < AV_VERSION_INT(54, 59, 100)
532 #  define FFMPEG_HAVE_DEPRECATED_FLAGS2
533 #endif
534
535 /* Since FFmpeg-1.1 this constant have AV_ prefix. */
536 #if LIBAVUTIL_VERSION_INT < AV_VERSION_INT(52, 3, 100)
537 #  define AV_PIX_FMT_BGR32 PIX_FMT_BGR32
538 #  define AV_PIX_FMT_YUV422P PIX_FMT_YUV422P
539 #  define AV_PIX_FMT_BGRA PIX_FMT_BGRA
540 #  define AV_PIX_FMT_ARGB PIX_FMT_ARGB
541 #  define AV_PIX_FMT_RGBA PIX_FMT_RGBA
542 #endif
543
544 /* New API from FFmpeg-2.0 which soon became recommended one. */
545 #if LIBAVUTIL_VERSION_INT < AV_VERSION_INT(52, 38, 100)
546 #  define av_frame_alloc avcodec_alloc_frame
547 #  define av_frame_free avcodec_free_frame
548 #  define av_frame_unref avcodec_get_frame_defaults
549 #endif
550
551 #if LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(57, 24, 102)
552
553 /* NOTE: The code in this block are from FFmpeg 2.6.4, which is licensed by LGPL. */
554
555 #define MAX_NEG_CROP 1024
556
557 #define times4(x) x, x, x, x
558 #define times256(x) times4(times4(times4(times4(times4(x)))))
559
560 static const uint8_t ff_compat_crop_tab[256 + 2 * MAX_NEG_CROP] = {
561 times256(0x00),
562 0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0A,0x0B,0x0C,0x0D,0x0E,0x0F,
563 0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17,0x18,0x19,0x1A,0x1B,0x1C,0x1D,0x1E,0x1F,
564 0x20,0x21,0x22,0x23,0x24,0x25,0x26,0x27,0x28,0x29,0x2A,0x2B,0x2C,0x2D,0x2E,0x2F,
565 0x30,0x31,0x32,0x33,0x34,0x35,0x36,0x37,0x38,0x39,0x3A,0x3B,0x3C,0x3D,0x3E,0x3F,
566 0x40,0x41,0x42,0x43,0x44,0x45,0x46,0x47,0x48,0x49,0x4A,0x4B,0x4C,0x4D,0x4E,0x4F,
567 0x50,0x51,0x52,0x53,0x54,0x55,0x56,0x57,0x58,0x59,0x5A,0x5B,0x5C,0x5D,0x5E,0x5F,
568 0x60,0x61,0x62,0x63,0x64,0x65,0x66,0x67,0x68,0x69,0x6A,0x6B,0x6C,0x6D,0x6E,0x6F,
569 0x70,0x71,0x72,0x73,0x74,0x75,0x76,0x77,0x78,0x79,0x7A,0x7B,0x7C,0x7D,0x7E,0x7F,
570 0x80,0x81,0x82,0x83,0x84,0x85,0x86,0x87,0x88,0x89,0x8A,0x8B,0x8C,0x8D,0x8E,0x8F,
571 0x90,0x91,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0x9A,0x9B,0x9C,0x9D,0x9E,0x9F,
572 0xA0,0xA1,0xA2,0xA3,0xA4,0xA5,0xA6,0xA7,0xA8,0xA9,0xAA,0xAB,0xAC,0xAD,0xAE,0xAF,
573 0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,0xB8,0xB9,0xBA,0xBB,0xBC,0xBD,0xBE,0xBF,
574 0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF,
575 0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xD7,0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0xDF,
576 0xE0,0xE1,0xE2,0xE3,0xE4,0xE5,0xE6,0xE7,0xE8,0xE9,0xEA,0xEB,0xEC,0xED,0xEE,0xEF,
577 0xF0,0xF1,0xF2,0xF3,0xF4,0xF5,0xF6,0xF7,0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF,
578 times256(0xFF)
579 };
580
581 #undef times4
582 #undef times256
583
584 /* filter parameters: [-1 4 2 4 -1] // 8 */
585 FFMPEG_INLINE
586 void deinterlace_line(uint8_t *dst,
587                       const uint8_t *lum_m4, const uint8_t *lum_m3,
588                       const uint8_t *lum_m2, const uint8_t *lum_m1,
589                       const uint8_t *lum,
590                       int size)
591 {
592         const uint8_t *cm = ff_compat_crop_tab + MAX_NEG_CROP;
593         int sum;
594
595         for(;size > 0;size--) {
596                 sum = -lum_m4[0];
597                 sum += lum_m3[0] << 2;
598                 sum += lum_m2[0] << 1;
599                 sum += lum_m1[0] << 2;
600                 sum += -lum[0];
601                 dst[0] = cm[(sum + 4) >> 3];
602                 lum_m4++;
603                 lum_m3++;
604                 lum_m2++;
605                 lum_m1++;
606                 lum++;
607                 dst++;
608         }
609 }
610
611 FFMPEG_INLINE
612 void deinterlace_line_inplace(uint8_t *lum_m4, uint8_t *lum_m3,
613                               uint8_t *lum_m2, uint8_t *lum_m1,
614                               uint8_t *lum, int size)
615 {
616         const uint8_t *cm = ff_compat_crop_tab + MAX_NEG_CROP;
617         int sum;
618
619         for(;size > 0;size--) {
620                 sum = -lum_m4[0];
621                 sum += lum_m3[0] << 2;
622                 sum += lum_m2[0] << 1;
623                 lum_m4[0]=lum_m2[0];
624                 sum += lum_m1[0] << 2;
625                 sum += -lum[0];
626                 lum_m2[0] = cm[(sum + 4) >> 3];
627                 lum_m4++;
628                 lum_m3++;
629                 lum_m2++;
630                 lum_m1++;
631                 lum++;
632         }
633 }
634
635 /* deinterlacing : 2 temporal taps, 3 spatial taps linear filter. The
636    top field is copied as is, but the bottom field is deinterlaced
637    against the top field. */
638 FFMPEG_INLINE
639 void deinterlace_bottom_field(uint8_t *dst, int dst_wrap,
640                               const uint8_t *src1, int src_wrap,
641                               int width, int height)
642 {
643         const uint8_t *src_m2, *src_m1, *src_0, *src_p1, *src_p2;
644         int y;
645
646         src_m2 = src1;
647         src_m1 = src1;
648         src_0=&src_m1[src_wrap];
649         src_p1=&src_0[src_wrap];
650         src_p2=&src_p1[src_wrap];
651         for(y=0;y<(height-2);y+=2) {
652                 memcpy(dst,src_m1,width);
653                 dst += dst_wrap;
654                 deinterlace_line(dst,src_m2,src_m1,src_0,src_p1,src_p2,width);
655                 src_m2 = src_0;
656                 src_m1 = src_p1;
657                 src_0 = src_p2;
658                 src_p1 += 2*src_wrap;
659                 src_p2 += 2*src_wrap;
660                 dst += dst_wrap;
661         }
662         memcpy(dst,src_m1,width);
663         dst += dst_wrap;
664         /* do last line */
665         deinterlace_line(dst,src_m2,src_m1,src_0,src_0,src_0,width);
666 }
667
668 FFMPEG_INLINE
669 int deinterlace_bottom_field_inplace(uint8_t *src1, int src_wrap,
670                                      int width, int height)
671 {
672         uint8_t *src_m1, *src_0, *src_p1, *src_p2;
673         int y;
674         uint8_t *buf = (uint8_t *)av_malloc(width);
675         if (!buf)
676                 return AVERROR(ENOMEM);
677
678         src_m1 = src1;
679         memcpy(buf,src_m1,width);
680         src_0=&src_m1[src_wrap];
681         src_p1=&src_0[src_wrap];
682         src_p2=&src_p1[src_wrap];
683         for(y=0;y<(height-2);y+=2) {
684                 deinterlace_line_inplace(buf,src_m1,src_0,src_p1,src_p2,width);
685                 src_m1 = src_p1;
686                 src_0 = src_p2;
687                 src_p1 += 2*src_wrap;
688                 src_p2 += 2*src_wrap;
689         }
690         /* do last line */
691         deinterlace_line_inplace(buf,src_m1,src_0,src_0,src_0,width);
692         av_free(buf);
693         return 0;
694 }
695
696 #ifdef __GNUC__
697 #  pragma GCC diagnostic push
698 #  pragma GCC diagnostic ignored "-Wdeprecated-declarations"
699 #endif
700
701 FFMPEG_INLINE
702 int avpicture_deinterlace(AVPicture *dst, const AVPicture *src,
703                           enum AVPixelFormat pix_fmt, int width, int height)
704 {
705         int i, ret;
706
707         if (pix_fmt != AV_PIX_FMT_YUV420P &&
708             pix_fmt != AV_PIX_FMT_YUVJ420P &&
709             pix_fmt != AV_PIX_FMT_YUV422P &&
710             pix_fmt != AV_PIX_FMT_YUVJ422P &&
711             pix_fmt != AV_PIX_FMT_YUV444P &&
712             pix_fmt != AV_PIX_FMT_YUV411P &&
713             pix_fmt != AV_PIX_FMT_GRAY8)
714                 return -1;
715         if ((width & 3) != 0 || (height & 3) != 0)
716                 return -1;
717
718         for(i=0;i<3;i++) {
719                 if (i == 1) {
720                         switch(pix_fmt) {
721                         case AV_PIX_FMT_YUVJ420P:
722                         case AV_PIX_FMT_YUV420P:
723                                 width >>= 1;
724                                 height >>= 1;
725                                 break;
726                         case AV_PIX_FMT_YUV422P:
727                         case AV_PIX_FMT_YUVJ422P:
728                                 width >>= 1;
729                                 break;
730                         case AV_PIX_FMT_YUV411P:
731                                 width >>= 2;
732                                 break;
733                         default:
734                                 break;
735                         }
736                         if (pix_fmt == AV_PIX_FMT_GRAY8) {
737                                 break;
738                         }
739                 }
740                 if (src == dst) {
741                         ret = deinterlace_bottom_field_inplace(dst->data[i],
742                                                                dst->linesize[i],
743                                                                width, height);
744                         if (ret < 0)
745                                 return ret;
746                 } else {
747                         deinterlace_bottom_field(dst->data[i],dst->linesize[i],
748                                                  src->data[i], src->linesize[i],
749                                                  width, height);
750                 }
751         }
752         return 0;
753 }
754
755 #ifdef __GNUC__
756 #  pragma GCC diagnostic pop
757 #endif
758
759 #endif
760
761 #endif