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