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