85e9bf7a045834fe8261c2ba5ad7c9925a179258
[vlc.git] / modules / codec / avcodec / video.c
1 /*****************************************************************************
2  * video.c: video decoder using the libavcodec library
3  *****************************************************************************
4  * Copyright (C) 1999-2001 VLC authors and VideoLAN
5  * $Id$
6  *
7  * Authors: Laurent Aimar <fenrir@via.ecp.fr>
8  *          Gildas Bazin <gbazin@videolan.org>
9  *
10  * This program is free software; you can redistribute it and/or modify it
11  * under the terms of the GNU Lesser General Public License as published by
12  * the Free Software Foundation; either version 2.1 of the License, or
13  * (at your option) any later version.
14  *
15  * This program is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18  * GNU Lesser General Public License for more details.
19  *
20  * You should have received a copy of the GNU Lesser General Public License
21  * along with this program; if not, write to the Free Software Foundation,
22  * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
23  *****************************************************************************/
24
25 /*****************************************************************************
26  * Preamble
27  *****************************************************************************/
28 #ifdef HAVE_CONFIG_H
29 # include "config.h"
30 #endif
31
32 #include <vlc_common.h>
33 #include <vlc_codec.h>
34 #include <vlc_avcodec.h>
35 #include <vlc_cpu.h>
36 #include <vlc_atomic.h>
37 #include <assert.h>
38
39 #include <libavcodec/avcodec.h>
40 #include <libavutil/mem.h>
41 #include <libavutil/pixdesc.h>
42 #if (LIBAVUTIL_VERSION_MICRO >= 100 && LIBAVUTIL_VERSION_INT >= AV_VERSION_INT( 55, 16, 101 ) )
43 #include <libavutil/mastering_display_metadata.h>
44 #endif
45
46 #include "avcodec.h"
47 #include "va.h"
48
49 /*****************************************************************************
50  * decoder_sys_t : decoder descriptor
51  *****************************************************************************/
52 struct decoder_sys_t
53 {
54     AVCODEC_COMMON_MEMBERS
55
56     /* Video decoder specific part */
57     mtime_t i_pts;
58
59     /* for frame skipping algo */
60     bool b_hurry_up;
61     bool b_from_preroll;
62     enum AVDiscard i_skip_frame;
63
64     /* how many decoded frames are late */
65     int     i_late_frames;
66     mtime_t i_late_frames_start;
67     mtime_t i_last_late_delay;
68
69     /* for direct rendering */
70     bool        b_direct_rendering;
71     atomic_bool b_dr_failure;
72
73     /* Hack to force display of still pictures */
74     bool b_first_frame;
75
76
77     /* */
78     bool palette_sent;
79
80     /* VA API */
81     vlc_va_t *p_va;
82     enum PixelFormat pix_fmt;
83     int profile;
84     int level;
85
86     vlc_sem_t sem_mt;
87 };
88
89 static inline void wait_mt(decoder_sys_t *sys)
90 {
91     vlc_sem_wait(&sys->sem_mt);
92 }
93
94 static inline void post_mt(decoder_sys_t *sys)
95 {
96     vlc_sem_post(&sys->sem_mt);
97 }
98
99 /*****************************************************************************
100  * Local prototypes
101  *****************************************************************************/
102 static void ffmpeg_InitCodec      ( decoder_t * );
103 static int lavc_GetFrame(struct AVCodecContext *, AVFrame *, int);
104 static enum PixelFormat ffmpeg_GetFormat( AVCodecContext *,
105                                           const enum PixelFormat * );
106 static int  DecodeVideo( decoder_t *, block_t * );
107 static void Flush( decoder_t * );
108
109 static uint32_t ffmpeg_CodecTag( vlc_fourcc_t fcc )
110 {
111     uint8_t *p = (uint8_t*)&fcc;
112     return p[0] | (p[1] << 8) | (p[2] << 16) | (p[3] << 24);
113 }
114
115 /*****************************************************************************
116  * Local Functions
117  *****************************************************************************/
118
119 /**
120  * Sets the decoder output format.
121  */
122 static int lavc_GetVideoFormat(decoder_t *dec, video_format_t *restrict fmt,
123                                AVCodecContext *ctx, enum AVPixelFormat pix_fmt,
124                                enum AVPixelFormat sw_pix_fmt)
125 {
126     int width = ctx->coded_width;
127     int height = ctx->coded_height;
128
129     video_format_Init(fmt, 0);
130
131     if (pix_fmt == sw_pix_fmt)
132     {   /* software decoding */
133         int aligns[AV_NUM_DATA_POINTERS];
134
135         if (GetVlcChroma(fmt, pix_fmt))
136             return -1;
137
138         /* The libavcodec palette can only be fetched when the first output
139          * frame is decoded. Assume that the current chroma is RGB32 while we
140          * are waiting for a valid palette. Indeed, fmt_out.video.p_palette
141          * doesn't trigger a new vout request, but a new chroma yes. */
142         if (pix_fmt == AV_PIX_FMT_PAL8 && !dec->fmt_out.video.p_palette)
143             fmt->i_chroma = VLC_CODEC_RGB32;
144
145         avcodec_align_dimensions2(ctx, &width, &height, aligns);
146     }
147     else /* hardware decoding */
148         fmt->i_chroma = vlc_va_GetChroma(pix_fmt, sw_pix_fmt);
149
150     if( width == 0 || height == 0 || width > 8192 || height > 8192 )
151     {
152         msg_Err(dec, "Invalid frame size %dx%d.", width, height);
153         return -1; /* invalid display size */
154     }
155
156     fmt->i_width = width;
157     fmt->i_height = height;
158     fmt->i_visible_width = ctx->width;
159     fmt->i_visible_height = ctx->height;
160
161     /* If an aspect-ratio was specified in the input format then force it */
162     if (dec->fmt_in.video.i_sar_num > 0 && dec->fmt_in.video.i_sar_den > 0)
163     {
164         fmt->i_sar_num = dec->fmt_in.video.i_sar_num;
165         fmt->i_sar_den = dec->fmt_in.video.i_sar_den;
166     }
167     else
168     {
169         fmt->i_sar_num = ctx->sample_aspect_ratio.num;
170         fmt->i_sar_den = ctx->sample_aspect_ratio.den;
171
172         if (fmt->i_sar_num == 0 || fmt->i_sar_den == 0)
173             fmt->i_sar_num = fmt->i_sar_den = 1;
174     }
175
176     if (dec->fmt_in.video.i_frame_rate > 0
177      && dec->fmt_in.video.i_frame_rate_base > 0)
178     {
179         fmt->i_frame_rate = dec->fmt_in.video.i_frame_rate;
180         fmt->i_frame_rate_base = dec->fmt_in.video.i_frame_rate_base;
181     }
182     else if (ctx->framerate.num > 0 && ctx->framerate.den > 0)
183     {
184         fmt->i_frame_rate = ctx->framerate.num;
185         fmt->i_frame_rate_base = ctx->framerate.den;
186 # if LIBAVCODEC_VERSION_MICRO <  100
187         // for some reason libav don't thinkg framerate presents actually same thing as in ffmpeg
188         fmt->i_frame_rate_base *= __MAX(ctx->ticks_per_frame, 1);
189 # endif
190     }
191     else if (ctx->time_base.num > 0 && ctx->time_base.den > 0)
192     {
193         fmt->i_frame_rate = ctx->time_base.den;
194         fmt->i_frame_rate_base = ctx->time_base.num
195                                  * __MAX(ctx->ticks_per_frame, 1);
196     }
197
198     if( ctx->color_range == AVCOL_RANGE_JPEG )
199         fmt->b_color_range_full = true;
200
201     switch( ctx->colorspace )
202     {
203         case AVCOL_SPC_BT709:
204             fmt->space = COLOR_SPACE_BT709;
205             break;
206         case AVCOL_SPC_SMPTE170M:
207         case AVCOL_SPC_BT470BG:
208             fmt->space = COLOR_SPACE_BT601;
209             break;
210         case AVCOL_SPC_BT2020_NCL:
211         case AVCOL_SPC_BT2020_CL:
212             fmt->space = COLOR_SPACE_BT2020;
213             break;
214         default:
215             break;
216     }
217
218     switch( ctx->color_trc )
219     {
220         case AVCOL_TRC_LINEAR:
221             fmt->transfer = TRANSFER_FUNC_LINEAR;
222             break;
223         case AVCOL_TRC_GAMMA22:
224             fmt->transfer = TRANSFER_FUNC_SRGB;
225             break;
226         case AVCOL_TRC_BT709:
227             fmt->transfer = TRANSFER_FUNC_BT709;
228             break;
229         case AVCOL_TRC_SMPTE170M:
230         case AVCOL_TRC_BT2020_10:
231         case AVCOL_TRC_BT2020_12:
232             fmt->transfer = TRANSFER_FUNC_BT2020;
233             break;
234 #if LIBAVUTIL_VERSION_CHECK( 55, 14, 0, 31, 100)
235         case AVCOL_TRC_ARIB_STD_B67:
236             fmt->transfer = TRANSFER_FUNC_ARIB_B67;
237             break;
238 #endif
239 #if LIBAVUTIL_VERSION_CHECK( 55, 17, 0, 37, 100)
240         case AVCOL_TRC_SMPTE2084:
241             fmt->transfer = TRANSFER_FUNC_SMPTE_ST2084;
242             break;
243         case AVCOL_TRC_SMPTE240M:
244             fmt->transfer = TRANSFER_FUNC_SMPTE_240;
245             break;
246         case AVCOL_TRC_GAMMA28:
247             fmt->transfer = TRANSFER_FUNC_BT470_BG;
248             break;
249 #endif
250         default:
251             break;
252     }
253
254     switch( ctx->color_primaries )
255     {
256         case AVCOL_PRI_BT709:
257             fmt->primaries = COLOR_PRIMARIES_BT709;
258             break;
259         case AVCOL_PRI_BT470BG:
260             fmt->primaries = COLOR_PRIMARIES_BT601_625;
261             break;
262         case AVCOL_PRI_SMPTE170M:
263         case AVCOL_PRI_SMPTE240M:
264             fmt->primaries = COLOR_PRIMARIES_BT601_525;
265             break;
266         case AVCOL_PRI_BT2020:
267             fmt->primaries = COLOR_PRIMARIES_BT2020;
268             break;
269         default:
270             break;
271     }
272
273     switch( ctx->chroma_sample_location )
274     {
275         case AVCHROMA_LOC_LEFT:
276             fmt->chroma_location = CHROMA_LOCATION_LEFT;
277             break;
278         case AVCHROMA_LOC_CENTER:
279             fmt->chroma_location = CHROMA_LOCATION_CENTER;
280             break;
281         case AVCHROMA_LOC_TOPLEFT:
282             fmt->chroma_location = CHROMA_LOCATION_TOP_LEFT;
283             break;
284         default:
285             break;
286     }
287
288     return 0;
289 }
290
291 static int lavc_UpdateVideoFormat(decoder_t *dec, AVCodecContext *ctx,
292                                   enum AVPixelFormat fmt,
293                                   enum AVPixelFormat swfmt)
294 {
295     video_format_t fmt_out;
296     int val;
297
298     val = lavc_GetVideoFormat(dec, &fmt_out, ctx, fmt, swfmt);
299     if (val)
300         return val;
301
302     fmt_out.p_palette = dec->fmt_out.video.p_palette;
303     dec->fmt_out.video.p_palette = NULL;
304
305     es_format_Clean(&dec->fmt_out);
306     es_format_Init(&dec->fmt_out, VIDEO_ES, fmt_out.i_chroma);
307     dec->fmt_out.video = fmt_out;
308     dec->fmt_out.video.orientation = dec->fmt_in.video.orientation;
309     dec->fmt_out.video.projection_mode = dec->fmt_in.video.projection_mode;
310     dec->fmt_out.video.pose = dec->fmt_in.video.pose;
311     if ( dec->fmt_in.video.mastering.max_luminance )
312         dec->fmt_out.video.mastering = dec->fmt_in.video.mastering;
313     dec->fmt_out.video.lighting = dec->fmt_in.video.lighting;
314     return decoder_UpdateVideoFormat(dec);
315 }
316
317 /**
318  * Copies a picture from the libavcodec-allocate buffer to a picture_t.
319  * This is used when not in direct rendering mode.
320  */
321 static int lavc_CopyPicture(decoder_t *dec, picture_t *pic, AVFrame *frame)
322 {
323     decoder_sys_t *sys = dec->p_sys;
324
325     if (!FindVlcChroma(sys->p_context->pix_fmt))
326     {
327         const char *name = av_get_pix_fmt_name(sys->p_context->pix_fmt);
328
329         msg_Err(dec, "Unsupported decoded output format %d (%s)",
330                 sys->p_context->pix_fmt, (name != NULL) ? name : "unknown");
331         return VLC_EGENERIC;
332     }
333
334     for (int plane = 0; plane < pic->i_planes; plane++)
335     {
336         const uint8_t *src = frame->data[plane];
337         uint8_t *dst = pic->p[plane].p_pixels;
338         size_t src_stride = frame->linesize[plane];
339         size_t dst_stride = pic->p[plane].i_pitch;
340         size_t size = __MIN(src_stride, dst_stride);
341
342         for (int line = 0; line < pic->p[plane].i_visible_lines; line++)
343         {
344             memcpy(dst, src, size);
345             src += src_stride;
346             dst += dst_stride;
347         }
348     }
349     return VLC_SUCCESS;
350 }
351
352 static int OpenVideoCodec( decoder_t *p_dec )
353 {
354     decoder_sys_t *p_sys = p_dec->p_sys;
355     int ret;
356
357     if( p_sys->p_context->extradata_size <= 0 )
358     {
359         if( p_sys->p_codec->id == AV_CODEC_ID_VC1 ||
360             p_sys->p_codec->id == AV_CODEC_ID_THEORA )
361         {
362             msg_Warn( p_dec, "waiting for extra data for codec %s",
363                       p_sys->p_codec->name );
364             return 1;
365         }
366     }
367
368     p_sys->p_context->width  = p_dec->fmt_in.video.i_visible_width;
369     p_sys->p_context->height = p_dec->fmt_in.video.i_visible_height;
370
371     p_sys->p_context->coded_width = p_dec->fmt_in.video.i_width;
372     p_sys->p_context->coded_height = p_dec->fmt_in.video.i_height;
373
374     p_sys->p_context->bits_per_coded_sample = p_dec->fmt_in.video.i_bits_per_pixel;
375     p_sys->pix_fmt = AV_PIX_FMT_NONE;
376     p_sys->profile = -1;
377     p_sys->level = -1;
378
379     post_mt( p_sys );
380     ret = ffmpeg_OpenCodec( p_dec );
381     wait_mt( p_sys );
382     if( ret < 0 )
383         return ret;
384
385     switch( p_sys->p_context->active_thread_type )
386     {
387         case FF_THREAD_FRAME:
388             msg_Dbg( p_dec, "using frame thread mode with %d threads",
389                      p_sys->p_context->thread_count );
390             break;
391         case FF_THREAD_SLICE:
392             msg_Dbg( p_dec, "using slice thread mode with %d threads",
393                      p_sys->p_context->thread_count );
394             break;
395         case 0:
396             if( p_sys->p_context->thread_count > 1 )
397                 msg_Warn( p_dec, "failed to enable threaded decoding" );
398             break;
399         default:
400             msg_Warn( p_dec, "using unknown thread mode with %d threads",
401                       p_sys->p_context->thread_count );
402             break;
403     }
404     return 0;
405 }
406
407 /*****************************************************************************
408  * InitVideo: initialize the video decoder
409  *****************************************************************************
410  * the ffmpeg codec will be opened, some memory allocated. The vout is not yet
411  * opened (done after the first decoded frame).
412  *****************************************************************************/
413 int InitVideoDec( decoder_t *p_dec, AVCodecContext *p_context,
414                   const AVCodec *p_codec )
415 {
416     decoder_sys_t *p_sys;
417     int i_val;
418
419     /* Allocate the memory needed to store the decoder's structure */
420     if( ( p_dec->p_sys = p_sys = calloc( 1, sizeof(decoder_sys_t) ) ) == NULL )
421         return VLC_ENOMEM;
422
423     p_sys->p_context = p_context;
424     p_sys->p_codec = p_codec;
425     p_sys->b_delayed_open = true;
426     p_sys->p_va = NULL;
427     vlc_sem_init( &p_sys->sem_mt, 0 );
428
429     /* ***** Fill p_context with init values ***** */
430     p_context->codec_tag = ffmpeg_CodecTag( p_dec->fmt_in.i_original_fourcc ?
431                                 p_dec->fmt_in.i_original_fourcc : p_dec->fmt_in.i_codec );
432
433     /*  ***** Get configuration of ffmpeg plugin ***** */
434     p_context->workaround_bugs =
435         var_InheritInteger( p_dec, "avcodec-workaround-bugs" );
436     p_context->err_recognition =
437         var_InheritInteger( p_dec, "avcodec-error-resilience" );
438
439     if( var_CreateGetBool( p_dec, "grayscale" ) )
440         p_context->flags |= AV_CODEC_FLAG_GRAY;
441
442     /* ***** Output always the frames ***** */
443     p_context->flags |= AV_CODEC_FLAG_OUTPUT_CORRUPT;
444
445     i_val = var_CreateGetInteger( p_dec, "avcodec-skiploopfilter" );
446     if( i_val >= 4 ) p_context->skip_loop_filter = AVDISCARD_ALL;
447     else if( i_val == 3 ) p_context->skip_loop_filter = AVDISCARD_NONKEY;
448     else if( i_val == 2 ) p_context->skip_loop_filter = AVDISCARD_BIDIR;
449     else if( i_val == 1 ) p_context->skip_loop_filter = AVDISCARD_NONREF;
450     else p_context->skip_loop_filter = AVDISCARD_DEFAULT;
451
452     if( var_CreateGetBool( p_dec, "avcodec-fast" ) )
453         p_context->flags2 |= AV_CODEC_FLAG2_FAST;
454
455     /* ***** libavcodec frame skipping ***** */
456     p_sys->b_hurry_up = var_CreateGetBool( p_dec, "avcodec-hurry-up" );
457
458     i_val = var_CreateGetInteger( p_dec, "avcodec-skip-frame" );
459     if( i_val >= 4 ) p_context->skip_frame = AVDISCARD_ALL;
460     else if( i_val == 3 ) p_context->skip_frame = AVDISCARD_NONKEY;
461     else if( i_val == 2 ) p_context->skip_frame = AVDISCARD_BIDIR;
462     else if( i_val == 1 ) p_context->skip_frame = AVDISCARD_NONREF;
463     else if( i_val == -1 ) p_context->skip_frame = AVDISCARD_NONE;
464     else p_context->skip_frame = AVDISCARD_DEFAULT;
465     p_sys->i_skip_frame = p_context->skip_frame;
466
467     i_val = var_CreateGetInteger( p_dec, "avcodec-skip-idct" );
468     if( i_val >= 4 ) p_context->skip_idct = AVDISCARD_ALL;
469     else if( i_val == 3 ) p_context->skip_idct = AVDISCARD_NONKEY;
470     else if( i_val == 2 ) p_context->skip_idct = AVDISCARD_BIDIR;
471     else if( i_val == 1 ) p_context->skip_idct = AVDISCARD_NONREF;
472     else if( i_val == -1 ) p_context->skip_idct = AVDISCARD_NONE;
473     else p_context->skip_idct = AVDISCARD_DEFAULT;
474
475     /* ***** libavcodec direct rendering ***** */
476     p_sys->b_direct_rendering = false;
477     atomic_init(&p_sys->b_dr_failure, false);
478     if( var_CreateGetBool( p_dec, "avcodec-dr" ) &&
479        (p_codec->capabilities & AV_CODEC_CAP_DR1) &&
480         /* No idea why ... but this fixes flickering on some TSCC streams */
481         p_sys->p_codec->id != AV_CODEC_ID_TSCC &&
482         p_sys->p_codec->id != AV_CODEC_ID_CSCD &&
483         p_sys->p_codec->id != AV_CODEC_ID_CINEPAK )
484     {
485         /* Some codecs set pix_fmt only after the 1st frame has been decoded,
486          * so we need to do another check in ffmpeg_GetFrameBuf() */
487         p_sys->b_direct_rendering = true;
488     }
489
490     p_context->get_format = ffmpeg_GetFormat;
491     /* Always use our get_buffer wrapper so we can calculate the
492      * PTS correctly */
493     p_context->get_buffer2 = lavc_GetFrame;
494     p_context->refcounted_frames = true;
495     p_context->opaque = p_dec;
496
497     int i_thread_count = var_InheritInteger( p_dec, "avcodec-threads" );
498     if( i_thread_count <= 0 )
499     {
500         i_thread_count = vlc_GetCPUCount();
501         if( i_thread_count > 1 )
502             i_thread_count++;
503
504         //FIXME: take in count the decoding time
505         i_thread_count = __MIN( i_thread_count, p_codec->id == AV_CODEC_ID_HEVC ? 6 : 4 );
506     }
507     i_thread_count = __MIN( i_thread_count, 16 );
508     msg_Dbg( p_dec, "allowing %d thread(s) for decoding", i_thread_count );
509     p_context->thread_count = i_thread_count;
510     p_context->thread_safe_callbacks = true;
511
512     switch( p_codec->id )
513     {
514         case AV_CODEC_ID_MPEG4:
515         case AV_CODEC_ID_H263:
516             p_context->thread_type = 0;
517             break;
518         case AV_CODEC_ID_MPEG1VIDEO:
519         case AV_CODEC_ID_MPEG2VIDEO:
520             p_context->thread_type &= ~FF_THREAD_SLICE;
521             /* fall through */
522 # if (LIBAVCODEC_VERSION_INT < AV_VERSION_INT(55, 1, 0))
523         case AV_CODEC_ID_H264:
524         case AV_CODEC_ID_VC1:
525         case AV_CODEC_ID_WMV3:
526             p_context->thread_type &= ~FF_THREAD_FRAME;
527 # endif
528         default:
529             break;
530     }
531
532     if( p_context->thread_type & FF_THREAD_FRAME )
533         p_dec->i_extra_picture_buffers = 2 * p_context->thread_count;
534
535     /* ***** misc init ***** */
536     p_sys->i_pts = VLC_TS_INVALID;
537     p_sys->b_first_frame = true;
538     p_sys->i_late_frames = 0;
539     p_sys->b_from_preroll = false;
540
541     /* Set output properties */
542     p_dec->fmt_out.i_cat = VIDEO_ES;
543     if( GetVlcChroma( &p_dec->fmt_out.video, p_context->pix_fmt ) != VLC_SUCCESS )
544     {
545         /* we are doomed. but not really, because most codecs set their pix_fmt later on */
546         p_dec->fmt_out.i_codec = VLC_CODEC_I420;
547     }
548     p_dec->fmt_out.i_codec = p_dec->fmt_out.video.i_chroma;
549
550     p_dec->fmt_out.video.orientation = p_dec->fmt_in.video.orientation;
551
552     if( p_dec->fmt_in.video.p_palette ) {
553         p_sys->palette_sent = false;
554         p_dec->fmt_out.video.p_palette = malloc( sizeof(video_palette_t) );
555         if( p_dec->fmt_out.video.p_palette )
556             *p_dec->fmt_out.video.p_palette = *p_dec->fmt_in.video.p_palette;
557     } else
558         p_sys->palette_sent = true;
559
560     /* ***** init this codec with special data ***** */
561     ffmpeg_InitCodec( p_dec );
562
563     /* ***** Open the codec ***** */
564     if( OpenVideoCodec( p_dec ) < 0 )
565     {
566         vlc_sem_destroy( &p_sys->sem_mt );
567         free( p_sys );
568         return VLC_EGENERIC;
569     }
570
571     p_dec->pf_decode = DecodeVideo;
572     p_dec->pf_flush  = Flush;
573
574     return VLC_SUCCESS;
575 }
576
577 /*****************************************************************************
578  * Flush:
579  *****************************************************************************/
580 static void Flush( decoder_t *p_dec )
581 {
582     decoder_sys_t *p_sys = p_dec->p_sys;
583     AVCodecContext *p_context = p_sys->p_context;
584
585     p_sys->i_pts = VLC_TS_INVALID; /* To make sure we recover properly */
586     p_sys->i_late_frames = 0;
587
588     /* Abort pictures in order to unblock all avcodec workers threads waiting
589      * for a picture. This will avoid a deadlock between avcodec_flush_buffers
590      * and workers threads */
591     decoder_AbortPictures( p_dec, true );
592
593     post_mt( p_sys );
594     /* do not flush buffers if codec hasn't been opened (theora/vorbis/VC1) */
595     if( avcodec_is_open( p_context ) )
596         avcodec_flush_buffers( p_context );
597     wait_mt( p_sys );
598
599     /* Reset cancel state to false */
600     decoder_AbortPictures( p_dec, false );
601 }
602
603 static bool check_block_validity( decoder_sys_t *p_sys, block_t *block )
604 {
605     if( !block)
606         return true;
607
608     if( block->i_flags & (BLOCK_FLAG_DISCONTINUITY|BLOCK_FLAG_CORRUPTED) )
609     {
610         p_sys->i_pts = VLC_TS_INVALID; /* To make sure we recover properly */
611
612         p_sys->i_late_frames = 0;
613         if( block->i_flags & BLOCK_FLAG_CORRUPTED )
614         {
615             block_Release( block );
616             return false;
617         }
618     }
619     return true;
620 }
621
622 static bool check_block_being_late( decoder_sys_t *p_sys, block_t *block, mtime_t current_time)
623 {
624     if( !block )
625         return false;
626     if( block->i_flags & BLOCK_FLAG_PREROLL )
627     {
628         /* Do not care about late frames when prerolling
629          * TODO avoid decoding of non reference frame
630          * (ie all B except for H264 where it depends only on nal_ref_idc) */
631         p_sys->i_late_frames = 0;
632         p_sys->b_from_preroll = true;
633         p_sys->i_last_late_delay = INT64_MAX;
634     }
635
636     if( p_sys->i_late_frames <= 0 )
637         return false;
638
639     if( current_time - p_sys->i_late_frames_start > (5*CLOCK_FREQ))
640     {
641         if( p_sys->i_pts > VLC_TS_INVALID )
642         {
643             p_sys->i_pts = VLC_TS_INVALID; /* To make sure we recover properly */
644         }
645         if( block )
646             block_Release( block );
647         p_sys->i_late_frames--;
648         return true;
649     }
650     return false;
651 }
652
653 static bool check_frame_should_be_dropped( decoder_sys_t *p_sys, AVCodecContext *p_context, bool *b_need_output_picture )
654 {
655     if( p_sys->i_late_frames <= 4)
656         return false;
657
658     *b_need_output_picture = false;
659     if( p_sys->i_late_frames < 12 )
660     {
661         p_context->skip_frame =
662                 (p_sys->i_skip_frame <= AVDISCARD_NONREF) ?
663                 AVDISCARD_NONREF : p_sys->i_skip_frame;
664     }
665     else
666     {
667         /* picture too late, won't decode
668          * but break picture until a new I, and for mpeg4 ...*/
669         p_sys->i_late_frames--; /* needed else it will never be decrease */
670         return true;
671     }
672     return false;
673 }
674
675 static void interpolate_next_pts( decoder_t *p_dec, AVFrame *frame )
676 {
677     decoder_sys_t *p_sys = p_dec->p_sys;
678     AVCodecContext *p_context = p_sys->p_context;
679
680     if( p_sys->i_pts <= VLC_TS_INVALID )
681         return;
682
683     /* interpolate the next PTS */
684     if( p_dec->fmt_in.video.i_frame_rate > 0 &&
685         p_dec->fmt_in.video.i_frame_rate_base > 0 )
686     {
687         p_sys->i_pts += CLOCK_FREQ * (2 + frame->repeat_pict) *
688             p_dec->fmt_in.video.i_frame_rate_base /
689             (2 * p_dec->fmt_in.video.i_frame_rate);
690     }
691     else if( p_context->time_base.den > 0 )
692     {
693         int i_tick = p_context->ticks_per_frame;
694         if( i_tick <= 0 )
695             i_tick = 1;
696
697         p_sys->i_pts += CLOCK_FREQ * (2 + frame->repeat_pict) *
698             i_tick * p_context->time_base.num /
699             (2 * p_context->time_base.den);
700     }
701 }
702
703 static void update_late_frame_count( decoder_t *p_dec, block_t *p_block, mtime_t current_time, mtime_t i_pts )
704 {
705     decoder_sys_t *p_sys = p_dec->p_sys;
706    /* Update frame late count (except when doing preroll) */
707    mtime_t i_display_date = VLC_TS_INVALID;
708    if( !p_block || !(p_block->i_flags & BLOCK_FLAG_PREROLL) )
709        i_display_date = decoder_GetDisplayDate( p_dec, i_pts );
710
711    if( i_display_date > VLC_TS_INVALID && i_display_date <= current_time )
712    {
713        /* Out of preroll, consider only late frames on rising delay */
714        if( p_sys->b_from_preroll )
715        {
716            if( p_sys->i_last_late_delay > current_time - i_display_date )
717            {
718                p_sys->i_last_late_delay = current_time - i_display_date;
719                return;
720            }
721            p_sys->b_from_preroll = false;
722        }
723
724        p_sys->i_late_frames++;
725        if( p_sys->i_late_frames == 1 )
726            p_sys->i_late_frames_start = current_time;
727
728    }
729    else
730    {
731        p_sys->i_late_frames = 0;
732    }
733 }
734
735
736 /*****************************************************************************
737  * DecodeBlock: Called to decode one or more frames
738  *****************************************************************************/
739 static picture_t *DecodeBlock( decoder_t *p_dec, block_t **pp_block, bool *error )
740 {
741     decoder_sys_t *p_sys = p_dec->p_sys;
742     AVCodecContext *p_context = p_sys->p_context;
743     /* Boolean if we assume that we should get valid pic as result */
744     bool b_need_output_picture = true;
745
746     /* Boolean for END_OF_SEQUENCE */
747     bool eos_spotted = false;
748
749
750     block_t *p_block;
751     mtime_t current_time = VLC_TS_INVALID;
752
753     if( !p_context->extradata_size && p_dec->fmt_in.i_extra )
754     {
755         ffmpeg_InitCodec( p_dec );
756         if( p_sys->b_delayed_open )
757             OpenVideoCodec( p_dec );
758     }
759
760     p_block = pp_block ? *pp_block : NULL;
761     if(!p_block && !(p_sys->p_codec->capabilities & AV_CODEC_CAP_DELAY) )
762         return NULL;
763
764     if( p_sys->b_delayed_open )
765     {
766         if( p_block )
767             block_Release( p_block );
768         return NULL;
769     }
770
771     if( !check_block_validity( p_sys, p_block ) )
772         return NULL;
773
774     current_time = mdate();
775     if( p_dec->b_frame_drop_allowed &&  check_block_being_late( p_sys, p_block, current_time) )
776     {
777         msg_Err( p_dec, "more than 5 seconds of late video -> "
778                  "dropping frame (computer too slow ?)" );
779         return NULL;
780     }
781
782
783     /* A good idea could be to decode all I pictures and see for the other */
784
785     /* Defaults that if we aren't in prerolling, we want output picture
786        same for if we are flushing (p_block==NULL) */
787     if( !p_block || !(p_block->i_flags & BLOCK_FLAG_PREROLL) )
788         b_need_output_picture = true;
789     else
790         b_need_output_picture = false;
791
792     /* Change skip_frame config only if hurry_up is enabled */
793     if( p_sys->b_hurry_up )
794     {
795         p_context->skip_frame = p_sys->i_skip_frame;
796
797         /* Check also if we should/can drop the block and move to next block
798             as trying to catchup the speed*/
799         if( p_dec->b_frame_drop_allowed &&
800             check_frame_should_be_dropped( p_sys, p_context, &b_need_output_picture ) )
801         {
802             if( p_block )
803                 block_Release( p_block );
804             msg_Warn( p_dec, "More than 11 late frames, dropping frame" );
805             return NULL;
806         }
807     }
808     if( !b_need_output_picture )
809     {
810         p_context->skip_frame = __MAX( p_context->skip_frame,
811                                               AVDISCARD_NONREF );
812     }
813
814     /*
815      * Do the actual decoding now */
816
817     /* Don't forget that libavcodec requires a little more bytes
818      * that the real frame size */
819     if( p_block && p_block->i_buffer > 0 )
820     {
821         eos_spotted = ( p_block->i_flags & BLOCK_FLAG_END_OF_SEQUENCE ) != 0;
822
823         p_block = block_Realloc( p_block, 0,
824                             p_block->i_buffer + FF_INPUT_BUFFER_PADDING_SIZE );
825         if( !p_block )
826             return NULL;
827         p_block->i_buffer -= FF_INPUT_BUFFER_PADDING_SIZE;
828         *pp_block = p_block;
829         memset( p_block->p_buffer + p_block->i_buffer, 0,
830                 FF_INPUT_BUFFER_PADDING_SIZE );
831     }
832
833     while( !p_block || p_block->i_buffer > 0 || eos_spotted )
834     {
835         int i_used;
836         AVPacket pkt;
837
838         post_mt( p_sys );
839
840         av_init_packet( &pkt );
841         if( p_block )
842         {
843             pkt.data = p_block->p_buffer;
844             pkt.size = p_block->i_buffer;
845             pkt.pts = p_block->i_pts > VLC_TS_INVALID ? p_block->i_pts : AV_NOPTS_VALUE;
846             pkt.dts = p_block->i_dts > VLC_TS_INVALID ? p_block->i_dts : AV_NOPTS_VALUE;
847         }
848         else
849         {
850             /* Return delayed frames if codec has CODEC_CAP_DELAY */
851             pkt.data = NULL;
852             pkt.size = 0;
853         }
854
855         if( !p_sys->palette_sent )
856         {
857             uint8_t *pal = av_packet_new_side_data(&pkt, AV_PKT_DATA_PALETTE, AVPALETTE_SIZE);
858             if (pal) {
859                 memcpy(pal, p_dec->fmt_in.video.p_palette->palette, AVPALETTE_SIZE);
860                 p_sys->palette_sent = true;
861             }
862         }
863
864         /* Make sure we don't reuse the same timestamps twice */
865         if( p_block )
866         {
867             p_block->i_pts =
868             p_block->i_dts = VLC_TS_INVALID;
869         }
870
871 #if LIBAVCODEC_VERSION_CHECK( 57, 0, 0xFFFFFFFFU, 64, 101 )
872         if( !b_need_output_picture )
873             pkt.flags |= AV_PKT_FLAG_DISCARD;
874 #endif
875
876         int ret = avcodec_send_packet(p_context, &pkt);
877         if( ret != 0 && ret != AVERROR(EAGAIN) )
878         {
879             if (ret == AVERROR(ENOMEM) || ret == AVERROR(EINVAL))
880             {
881                 msg_Err(p_dec, "avcodec_send_packet critical error");
882                 *error = true;
883             }
884             av_packet_unref( &pkt );
885             break;
886         }
887         i_used = ret != AVERROR(EAGAIN) ? pkt.size : 0;
888         av_packet_unref( &pkt );
889
890         AVFrame *frame = av_frame_alloc();
891         if (unlikely(frame == NULL))
892         {
893             *error = true;
894             break;
895         }
896
897         ret = avcodec_receive_frame(p_context, frame);
898         if( ret != 0 && ret != AVERROR(EAGAIN) )
899         {
900             if (ret == AVERROR(ENOMEM) || ret == AVERROR(EINVAL))
901             {
902                 msg_Err(p_dec, "avcodec_receive_frame critical error");
903                 *error = true;
904             }
905             av_frame_free(&frame);
906             break;
907         }
908         bool not_received_frame = ret;
909
910         wait_mt( p_sys );
911
912         if( eos_spotted )
913             p_sys->b_first_frame = true;
914
915         if( p_block )
916         {
917             if( p_block->i_buffer <= 0 )
918                 eos_spotted = false;
919
920             /* Consumed bytes */
921             p_block->p_buffer += i_used;
922             p_block->i_buffer -= i_used;
923         }
924
925         /* Nothing to display */
926         if( not_received_frame )
927         {
928             av_frame_free(&frame);
929             if( i_used == 0 ) break;
930             continue;
931         }
932
933         /* Compute the PTS */
934 #ifdef FF_API_PKT_PTS
935         mtime_t i_pts = frame->pts;
936 #else
937         mtime_t i_pts = frame->pkt_pts;
938 #endif
939         if (i_pts == AV_NOPTS_VALUE )
940             i_pts = frame->pkt_dts;
941
942         if( i_pts == AV_NOPTS_VALUE )
943             i_pts = p_sys->i_pts;
944
945         /* Interpolate the next PTS */
946         if( i_pts > VLC_TS_INVALID )
947             p_sys->i_pts = i_pts;
948
949         interpolate_next_pts( p_dec, frame );
950
951         update_late_frame_count( p_dec, p_block, current_time, i_pts);
952
953         if( ( !p_sys->p_va && !frame->linesize[0] ) ||
954            ( p_dec->b_frame_drop_allowed && (frame->flags & AV_FRAME_FLAG_CORRUPT) ) )
955         {
956             av_frame_free(&frame);
957             continue;
958         }
959
960 #if !LIBAVCODEC_VERSION_CHECK( 57, 0, 0xFFFFFFFFU, 64, 101 )
961         if( !b_need_output_picture )
962         {
963             av_frame_free(&frame);
964             continue;
965         }
966 #endif
967
968         if( p_context->pix_fmt == AV_PIX_FMT_PAL8
969          && !p_dec->fmt_out.video.p_palette )
970         {
971             /* See AV_PIX_FMT_PAL8 comment in avc_GetVideoFormat(): update the
972              * fmt_out palette and change the fmt_out chroma to request a new
973              * vout */
974             assert( p_dec->fmt_out.video.i_chroma != VLC_CODEC_RGBP );
975
976             video_palette_t *p_palette;
977             p_palette = p_dec->fmt_out.video.p_palette
978                       = malloc( sizeof(video_palette_t) );
979             if( !p_palette )
980             {
981                 *error = true;
982                 av_frame_free(&frame);
983                 break;
984             }
985             static_assert( sizeof(p_palette->palette) == AVPALETTE_SIZE,
986                            "Palette size mismatch between vlc and libavutil" );
987             assert( frame->data[1] != NULL );
988             memcpy( p_palette->palette, frame->data[1], AVPALETTE_SIZE );
989             p_palette->i_entries = AVPALETTE_COUNT;
990             p_dec->fmt_out.video.i_chroma = VLC_CODEC_RGBP;
991             if( decoder_UpdateVideoFormat( p_dec ) )
992             {
993                 av_frame_free(&frame);
994                 continue;
995             }
996         }
997
998         picture_t *p_pic = frame->opaque;
999         if( p_pic == NULL )
1000         {   /* When direct rendering is not used, get_format() and get_buffer()
1001              * might not be called. The output video format must be set here
1002              * then picture buffer can be allocated. */
1003             if (p_sys->p_va == NULL
1004              && lavc_UpdateVideoFormat(p_dec, p_context, p_context->pix_fmt,
1005                                        p_context->pix_fmt) == 0)
1006                 p_pic = decoder_NewPicture(p_dec);
1007
1008             if( !p_pic )
1009             {
1010                 av_frame_free(&frame);
1011                 break;
1012             }
1013
1014             /* Fill picture_t from AVFrame */
1015             if( lavc_CopyPicture( p_dec, p_pic, frame ) != VLC_SUCCESS )
1016             {
1017                 *error = true;
1018                 av_frame_free(&frame);
1019                 picture_Release( p_pic );
1020                 break;
1021             }
1022         }
1023         else
1024         {
1025             if( p_sys->p_va != NULL )
1026                 vlc_va_Extract( p_sys->p_va, p_pic, frame->data[3] );
1027             picture_Hold( p_pic );
1028         }
1029
1030         if( !p_dec->fmt_in.video.i_sar_num || !p_dec->fmt_in.video.i_sar_den )
1031         {
1032             /* Fetch again the aspect ratio in case it changed */
1033             p_dec->fmt_out.video.i_sar_num
1034                 = p_context->sample_aspect_ratio.num;
1035             p_dec->fmt_out.video.i_sar_den
1036                 = p_context->sample_aspect_ratio.den;
1037
1038             if( !p_dec->fmt_out.video.i_sar_num || !p_dec->fmt_out.video.i_sar_den )
1039             {
1040                 p_dec->fmt_out.video.i_sar_num = 1;
1041                 p_dec->fmt_out.video.i_sar_den = 1;
1042             }
1043         }
1044
1045         p_pic->date = i_pts;
1046         /* Hack to force display of still pictures */
1047         p_pic->b_force = p_sys->b_first_frame;
1048         p_pic->i_nb_fields = 2 + frame->repeat_pict;
1049         p_pic->b_progressive = !frame->interlaced_frame;
1050         p_pic->b_top_field_first = frame->top_field_first;
1051
1052         bool format_changed = false;
1053 #if (LIBAVUTIL_VERSION_MICRO >= 100 && LIBAVUTIL_VERSION_INT >= AV_VERSION_INT( 55, 16, 101 ) )
1054 #define FROM_AVRAT(default_factor, avrat) \
1055     (uint64_t)(default_factor) * (avrat).num / (avrat).den
1056         const AVFrameSideData *metadata =
1057                 av_frame_get_side_data( frame,
1058                                         AV_FRAME_DATA_MASTERING_DISPLAY_METADATA );
1059         if ( metadata )
1060         {
1061             const AVMasteringDisplayMetadata *hdr_meta =
1062                     (const AVMasteringDisplayMetadata *) metadata->data;
1063             if ( hdr_meta->has_luminance )
1064             {
1065 #define ST2086_LUMA_FACTOR 10000
1066                 p_pic->format.mastering.max_luminance =
1067                         FROM_AVRAT(ST2086_LUMA_FACTOR, hdr_meta->max_luminance);
1068                 p_pic->format.mastering.min_luminance =
1069                         FROM_AVRAT(ST2086_LUMA_FACTOR, hdr_meta->min_luminance);
1070             }
1071             if ( hdr_meta->has_primaries )
1072             {
1073 #define ST2086_RED   2
1074 #define ST2086_GREEN 0
1075 #define ST2086_BLUE  1
1076 #define LAV_RED    0
1077 #define LAV_GREEN  1
1078 #define LAV_BLUE   2
1079 #define ST2086_PRIM_FACTOR 50000
1080                 p_pic->format.mastering.primaries[ST2086_RED*2   + 0] =
1081                         FROM_AVRAT(ST2086_PRIM_FACTOR, hdr_meta->display_primaries[LAV_RED][0]);
1082                 p_pic->format.mastering.primaries[ST2086_RED*2   + 1] =
1083                         FROM_AVRAT(ST2086_PRIM_FACTOR, hdr_meta->display_primaries[LAV_RED][1]);
1084                 p_pic->format.mastering.primaries[ST2086_GREEN*2 + 0] =
1085                         FROM_AVRAT(ST2086_PRIM_FACTOR, hdr_meta->display_primaries[LAV_GREEN][0]);
1086                 p_pic->format.mastering.primaries[ST2086_GREEN*2 + 1] =
1087                         FROM_AVRAT(ST2086_PRIM_FACTOR, hdr_meta->display_primaries[LAV_GREEN][1]);
1088                 p_pic->format.mastering.primaries[ST2086_BLUE*2  + 0] =
1089                         FROM_AVRAT(ST2086_PRIM_FACTOR, hdr_meta->display_primaries[LAV_BLUE][0]);
1090                 p_pic->format.mastering.primaries[ST2086_BLUE*2  + 1] =
1091                         FROM_AVRAT(ST2086_PRIM_FACTOR, hdr_meta->display_primaries[LAV_BLUE][1]);
1092                 p_pic->format.mastering.white_point[0] =
1093                         FROM_AVRAT(ST2086_PRIM_FACTOR, hdr_meta->white_point[0]);
1094                 p_pic->format.mastering.white_point[1] =
1095                         FROM_AVRAT(ST2086_PRIM_FACTOR, hdr_meta->white_point[1]);
1096             }
1097
1098             if ( memcmp( &p_dec->fmt_out.video.mastering,
1099                          &p_pic->format.mastering,
1100                          sizeof(p_pic->format.mastering) ) )
1101             {
1102                 p_dec->fmt_out.video.mastering = p_pic->format.mastering;
1103                 format_changed = true;
1104             }
1105 #undef FROM_AVRAT
1106         }
1107 #endif
1108 #if (LIBAVUTIL_VERSION_MICRO >= 100 && LIBAVUTIL_VERSION_INT >= AV_VERSION_INT( 55, 60, 100 ) )
1109         const AVFrameSideData *metadata_lt =
1110                 av_frame_get_side_data( frame,
1111                                         AV_FRAME_DATA_CONTENT_LIGHT_LEVEL );
1112         if ( metadata_lt )
1113         {
1114             const AVContentLightMetadata *light_meta =
1115                     (const AVContentLightMetadata *) metadata_lt->data;
1116             p_pic->format.lighting.MaxCLL = light_meta->MaxCLL;
1117             p_pic->format.lighting.MaxFALL = light_meta->MaxFALL;
1118             if ( memcmp( &p_dec->fmt_out.video.lighting,
1119                          &p_pic->format.lighting,
1120                          sizeof(p_pic->format.lighting) ) )
1121             {
1122                 p_dec->fmt_out.video.lighting  = p_pic->format.lighting;
1123                 format_changed = true;
1124             }
1125         }
1126 #endif
1127         av_frame_free(&frame);
1128
1129         if (format_changed)
1130             decoder_UpdateVideoFormat( p_dec );
1131
1132         /* Send decoded frame to vout */
1133         if (i_pts > VLC_TS_INVALID)
1134         {
1135             p_sys->b_first_frame = false;
1136             return p_pic;
1137         }
1138         else
1139             picture_Release( p_pic );
1140     }
1141
1142     if( p_block )
1143         block_Release( p_block );
1144     return NULL;
1145 }
1146
1147 static int DecodeVideo( decoder_t *p_dec, block_t *p_block )
1148 {
1149     block_t **pp_block = p_block ? &p_block : NULL;
1150     picture_t *p_pic;
1151     bool error = false;
1152     while( ( p_pic = DecodeBlock( p_dec, pp_block, &error ) ) != NULL )
1153         decoder_QueueVideo( p_dec, p_pic );
1154     return error ? VLCDEC_ECRITICAL : VLCDEC_SUCCESS;
1155 }
1156
1157 /*****************************************************************************
1158  * EndVideo: decoder destruction
1159  *****************************************************************************
1160  * This function is called when the thread ends after a successful
1161  * initialization.
1162  *****************************************************************************/
1163 void EndVideoDec( decoder_t *p_dec )
1164 {
1165     decoder_sys_t *p_sys = p_dec->p_sys;
1166
1167     post_mt( p_sys );
1168
1169     /* do not flush buffers if codec hasn't been opened (theora/vorbis/VC1) */
1170     if( avcodec_is_open( p_sys->p_context ) )
1171         avcodec_flush_buffers( p_sys->p_context );
1172
1173     wait_mt( p_sys );
1174
1175     ffmpeg_CloseCodec( p_dec );
1176
1177     if( p_sys->p_va )
1178         vlc_va_Delete( p_sys->p_va, p_sys->p_context );
1179
1180     vlc_sem_destroy( &p_sys->sem_mt );
1181 }
1182
1183 /*****************************************************************************
1184  * ffmpeg_InitCodec: setup codec extra initialization data for ffmpeg
1185  *****************************************************************************/
1186 static void ffmpeg_InitCodec( decoder_t *p_dec )
1187 {
1188     decoder_sys_t *p_sys = p_dec->p_sys;
1189     int i_size = p_dec->fmt_in.i_extra;
1190
1191     if( !i_size ) return;
1192
1193     if( p_sys->p_codec->id == AV_CODEC_ID_SVQ3 )
1194     {
1195         uint8_t *p;
1196
1197         p_sys->p_context->extradata_size = i_size + 12;
1198         p = p_sys->p_context->extradata =
1199             av_malloc( p_sys->p_context->extradata_size +
1200                        FF_INPUT_BUFFER_PADDING_SIZE );
1201         if( !p )
1202             return;
1203
1204         memcpy( &p[0],  "SVQ3", 4 );
1205         memset( &p[4], 0, 8 );
1206         memcpy( &p[12], p_dec->fmt_in.p_extra, i_size );
1207
1208         /* Now remove all atoms before the SMI one */
1209         if( p_sys->p_context->extradata_size > 0x5a &&
1210             strncmp( (char*)&p[0x56], "SMI ", 4 ) )
1211         {
1212             uint8_t *psz = &p[0x52];
1213
1214             while( psz < &p[p_sys->p_context->extradata_size - 8] )
1215             {
1216                 int i_size = GetDWBE( psz );
1217                 if( i_size <= 1 )
1218                 {
1219                     /* FIXME handle 1 as long size */
1220                     break;
1221                 }
1222                 if( !strncmp( (char*)&psz[4], "SMI ", 4 ) )
1223                 {
1224                     memmove( &p[0x52], psz,
1225                              &p[p_sys->p_context->extradata_size] - psz );
1226                     break;
1227                 }
1228
1229                 psz += i_size;
1230             }
1231         }
1232     }
1233     else
1234     {
1235         p_sys->p_context->extradata_size = i_size;
1236         p_sys->p_context->extradata =
1237             av_malloc( i_size + FF_INPUT_BUFFER_PADDING_SIZE );
1238         if( p_sys->p_context->extradata )
1239         {
1240             memcpy( p_sys->p_context->extradata,
1241                     p_dec->fmt_in.p_extra, i_size );
1242             memset( p_sys->p_context->extradata + i_size,
1243                     0, FF_INPUT_BUFFER_PADDING_SIZE );
1244         }
1245     }
1246 }
1247
1248 static void lavc_ReleaseFrame(void *opaque, uint8_t *data)
1249 {
1250     (void) data;
1251     picture_t *picture = opaque;
1252
1253     picture_Release(picture);
1254 }
1255
1256 static int lavc_va_GetFrame(struct AVCodecContext *ctx, AVFrame *frame,
1257                             picture_t *pic)
1258 {
1259     decoder_t *dec = ctx->opaque;
1260     vlc_va_t *va = dec->p_sys->p_va;
1261
1262     if (vlc_va_Get(va, pic, &frame->data[0]))
1263     {
1264         msg_Err(dec, "hardware acceleration picture allocation failed");
1265         picture_Release(pic);
1266         return -1;
1267     }
1268     assert(frame->data[0] != NULL);
1269     /* data[0] must be non-NULL for libavcodec internal checks.
1270      * data[3] actually contains the format-specific surface handle. */
1271     frame->data[3] = frame->data[0];
1272
1273     void (*release)(void *, uint8_t *) = va->release;
1274     if (va->release == NULL)
1275         release = lavc_ReleaseFrame;
1276
1277     frame->buf[0] = av_buffer_create(frame->data[0], 0, release, pic, 0);
1278     if (unlikely(frame->buf[0] == NULL))
1279     {
1280         release(pic, frame->data[0]);
1281         return -1;
1282     }
1283
1284     frame->opaque = pic;
1285     return 0;
1286 }
1287
1288 static int lavc_dr_GetFrame(struct AVCodecContext *ctx, AVFrame *frame,
1289                             picture_t *pic)
1290 {
1291     decoder_t *dec = (decoder_t *)ctx->opaque;
1292     decoder_sys_t *sys = dec->p_sys;
1293
1294     if (ctx->pix_fmt == AV_PIX_FMT_PAL8)
1295         goto error;
1296
1297     int width = frame->width;
1298     int height = frame->height;
1299     int aligns[AV_NUM_DATA_POINTERS];
1300
1301     avcodec_align_dimensions2(ctx, &width, &height, aligns);
1302
1303     /* Check that the picture is suitable for libavcodec */
1304     assert(pic->p[0].i_pitch >= width * pic->p[0].i_pixel_pitch);
1305     assert(pic->p[0].i_lines >= height);
1306
1307     for (int i = 0; i < pic->i_planes; i++)
1308     {
1309         if (pic->p[i].i_pitch % aligns[i])
1310         {
1311             if (!atomic_exchange(&sys->b_dr_failure, true))
1312                 msg_Warn(dec, "plane %d: pitch not aligned (%d%%%d): disabling direct rendering",
1313                          i, pic->p[i].i_pitch, aligns[i]);
1314             goto error;
1315         }
1316         if (((uintptr_t)pic->p[i].p_pixels) % aligns[i])
1317         {
1318             if (!atomic_exchange(&sys->b_dr_failure, true))
1319                 msg_Warn(dec, "plane %d not aligned: disabling direct rendering", i);
1320             goto error;
1321         }
1322     }
1323
1324     /* Allocate buffer references and initialize planes */
1325     assert(pic->i_planes < PICTURE_PLANE_MAX);
1326     static_assert(PICTURE_PLANE_MAX <= AV_NUM_DATA_POINTERS, "Oops!");
1327
1328     for (int i = 0; i < pic->i_planes; i++)
1329     {
1330         uint8_t *data = pic->p[i].p_pixels;
1331         int size = pic->p[i].i_pitch * pic->p[i].i_lines;
1332
1333         frame->data[i] = data;
1334         frame->linesize[i] = pic->p[i].i_pitch;
1335         frame->buf[i] = av_buffer_create(data, size, lavc_ReleaseFrame,
1336                                          pic, 0);
1337         if (unlikely(frame->buf[i] == NULL))
1338         {
1339             while (i > 0)
1340                 av_buffer_unref(&frame->buf[--i]);
1341             goto error;
1342         }
1343         picture_Hold(pic);
1344     }
1345
1346     frame->opaque = pic;
1347     /* The loop above held one reference to the picture for each plane. */
1348     picture_Release(pic);
1349     return 0;
1350 error:
1351     picture_Release(pic);
1352     return -1;
1353 }
1354
1355 /**
1356  * Callback used by libavcodec to get a frame buffer.
1357  *
1358  * It is used for direct rendering as well as to get the right PTS for each
1359  * decoded picture (even in indirect rendering mode).
1360  */
1361 static int lavc_GetFrame(struct AVCodecContext *ctx, AVFrame *frame, int flags)
1362 {
1363     decoder_t *dec = ctx->opaque;
1364     decoder_sys_t *sys = dec->p_sys;
1365     picture_t *pic;
1366
1367     for (unsigned i = 0; i < AV_NUM_DATA_POINTERS; i++)
1368     {
1369         frame->data[i] = NULL;
1370         frame->linesize[i] = 0;
1371         frame->buf[i] = NULL;
1372     }
1373     frame->opaque = NULL;
1374
1375     wait_mt(sys);
1376     if (sys->p_va == NULL)
1377     {
1378         if (!sys->b_direct_rendering)
1379         {
1380             post_mt(sys);
1381             return avcodec_default_get_buffer2(ctx, frame, flags);
1382         }
1383
1384         /* Most unaccelerated decoders do not call get_format(), so we need to
1385          * update the output video format here. The MT semaphore must be held
1386          * to protect p_dec->fmt_out. */
1387         if (lavc_UpdateVideoFormat(dec, ctx, ctx->pix_fmt, ctx->pix_fmt))
1388         {
1389             post_mt(sys);
1390             return -1;
1391         }
1392     }
1393     post_mt(sys);
1394
1395     pic = decoder_NewPicture(dec);
1396     if (pic == NULL)
1397         return -ENOMEM;
1398
1399     if (sys->p_va != NULL)
1400         return lavc_va_GetFrame(ctx, frame, pic);
1401
1402     /* Some codecs set pix_fmt only after the 1st frame has been decoded,
1403      * so we need to check for direct rendering again. */
1404     int ret = lavc_dr_GetFrame(ctx, frame, pic);
1405     if (ret)
1406         ret = avcodec_default_get_buffer2(ctx, frame, flags);
1407     return ret;
1408 }
1409
1410 static enum PixelFormat ffmpeg_GetFormat( AVCodecContext *p_context,
1411                                           const enum PixelFormat *pi_fmt )
1412 {
1413     decoder_t *p_dec = p_context->opaque;
1414     decoder_sys_t *p_sys = p_dec->p_sys;
1415     video_format_t fmt;
1416
1417     /* Enumerate available formats */
1418     enum PixelFormat swfmt = avcodec_default_get_format(p_context, pi_fmt);
1419     bool can_hwaccel = false;
1420
1421     for( size_t i = 0; pi_fmt[i] != AV_PIX_FMT_NONE; i++ )
1422     {
1423         const AVPixFmtDescriptor *dsc = av_pix_fmt_desc_get(pi_fmt[i]);
1424         if (dsc == NULL)
1425             continue;
1426         bool hwaccel = (dsc->flags & AV_PIX_FMT_FLAG_HWACCEL) != 0;
1427
1428         msg_Dbg( p_dec, "available %sware decoder output format %d (%s)",
1429                  hwaccel ? "hard" : "soft", pi_fmt[i], dsc->name );
1430         if (hwaccel)
1431             can_hwaccel = true;
1432     }
1433
1434     /* If the format did not actually change (e.g. seeking), try to reuse the
1435      * existing output format, and if present, hardware acceleration back-end.
1436      * This avoids resetting the pipeline downstream. This also avoids
1437      * needlessly probing for hardware acceleration support. */
1438     if (p_sys->pix_fmt != AV_PIX_FMT_NONE
1439      && lavc_GetVideoFormat(p_dec, &fmt, p_context, p_sys->pix_fmt, swfmt) == 0
1440      && fmt.i_width == p_dec->fmt_out.video.i_width
1441      && fmt.i_height == p_dec->fmt_out.video.i_height
1442      && p_context->profile == p_sys->profile
1443      && p_context->level <= p_sys->level)
1444     {
1445         for (size_t i = 0; pi_fmt[i] != AV_PIX_FMT_NONE; i++)
1446             if (pi_fmt[i] == p_sys->pix_fmt)
1447             {
1448                 msg_Dbg(p_dec, "reusing decoder output format %d", pi_fmt[i]);
1449                 return p_sys->pix_fmt;
1450             }
1451     }
1452
1453     if (p_sys->p_va != NULL)
1454     {
1455         msg_Err(p_dec, "existing hardware acceleration cannot be reused");
1456         vlc_va_Delete(p_sys->p_va, p_context);
1457         p_sys->p_va = NULL;
1458     }
1459
1460     p_sys->profile = p_context->profile;
1461     p_sys->level = p_context->level;
1462
1463     if (!can_hwaccel)
1464         return swfmt;
1465
1466 #if (LIBAVCODEC_VERSION_MICRO >= 100) \
1467   && (LIBAVCODEC_VERSION_INT < AV_VERSION_INT(57, 83, 101))
1468     if (p_context->active_thread_type)
1469     {
1470         msg_Warn(p_dec, "thread type %d: disabling hardware acceleration",
1471                  p_context->active_thread_type);
1472         return swfmt;
1473     }
1474 #endif
1475
1476     wait_mt(p_sys);
1477
1478     for( size_t i = 0; pi_fmt[i] != AV_PIX_FMT_NONE; i++ )
1479     {
1480         enum PixelFormat hwfmt = pi_fmt[i];
1481
1482         p_dec->fmt_out.video.i_chroma = vlc_va_GetChroma(hwfmt, swfmt);
1483         if (p_dec->fmt_out.video.i_chroma == 0)
1484             continue; /* Unknown brand of hardware acceleration */
1485         if (p_context->width == 0 || p_context->height == 0)
1486         {   /* should never happen */
1487             msg_Err(p_dec, "unspecified video dimensions");
1488             continue;
1489         }
1490         if (lavc_UpdateVideoFormat(p_dec, p_context, hwfmt, swfmt))
1491             continue; /* Unsupported brand of hardware acceleration */
1492         post_mt(p_sys);
1493
1494         picture_t *test_pic = decoder_NewPicture(p_dec);
1495         assert(!test_pic || test_pic->format.i_chroma == p_dec->fmt_out.video.i_chroma);
1496         vlc_va_t *va = vlc_va_New(VLC_OBJECT(p_dec), p_context, hwfmt,
1497                                   &p_dec->fmt_in,
1498                                   test_pic ? test_pic->p_sys : NULL);
1499         if (test_pic)
1500             picture_Release(test_pic);
1501         if (va == NULL)
1502         {
1503             wait_mt(p_sys);
1504             continue; /* Unsupported codec profile or such */
1505         }
1506
1507         if (va->description != NULL)
1508             msg_Info(p_dec, "Using %s for hardware decoding", va->description);
1509
1510         p_sys->p_va = va;
1511         p_sys->pix_fmt = hwfmt;
1512         p_context->draw_horiz_band = NULL;
1513         return pi_fmt[i];
1514     }
1515
1516     post_mt(p_sys);
1517     /* Fallback to default behaviour */
1518     p_sys->pix_fmt = swfmt;
1519     return swfmt;
1520 }