git.sesse.net Git - vlc/blob - src/input/decoder.c

   1 /*****************************************************************************
   2  * decoder.c: Functions for the management of decoders
   3  *****************************************************************************
   4  * Copyright (C) 1999-2004 the VideoLAN team
   5  * $Id$
   6  *
   7  * Authors: Christophe Massiot <massiot@via.ecp.fr>
   8  *          Gildas Bazin <gbazin@videolan.org>
   9  *          Laurent Aimar <fenrir@via.ecp.fr>
  10  *
  11  * This program is free software; you can redistribute it and/or modify
  12  * it under the terms of the GNU General Public License as published by
  13  * the Free Software Foundation; either version 2 of the License, or
  14  * (at your option) any later version.
  15  *
  16  * This program is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  * GNU General Public License for more details.
  20  *
  21  * You should have received a copy of the GNU General Public License
  22  * along with this program; if not, write to the Free Software
  23  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  24  *****************************************************************************/
  25
  26 /*****************************************************************************
  27  * Preamble
  28  *****************************************************************************/
  29 #ifdef HAVE_CONFIG_H
  30 # include "config.h"
  31 #endif
  32 #include <assert.h>
  33
  34 #include <vlc_common.h>
  35
  36 #include <vlc_block.h>
  37 #include <vlc_vout.h>
  38 #include <vlc_aout.h>
  39 #include <vlc_sout.h>
  40 #include <vlc_codec.h>
  41 #include <vlc_spu.h>
  42 #include <vlc_meta.h>
  43 #include <vlc_dialog.h>
  44 #include <vlc_modules.h>
  45
  46 #include "audio_output/aout_internal.h"
  47 #include "stream_output/stream_output.h"
  48 #include "input_internal.h"
  49 #include "clock.h"
  50 #include "decoder.h"
  51 #include "event.h"
  52 #include "resource.h"
  53
  54 #include "../video_output/vout_control.h"
  55
  56 static decoder_t *CreateDecoder( input_thread_t *, es_format_t *, bool,
  57                                  sout_instance_t *p_sout );
  58 static void       DeleteDecoder( decoder_t * );
  59
  60 static void      *DecoderThread( vlc_object_t * );
  61 static void       DecoderProcess( decoder_t *, block_t * );
  62 static void       DecoderError( decoder_t *p_dec, block_t *p_block );
  63 static void       DecoderOutputChangePause( decoder_t *, bool b_paused, mtime_t i_date );
  64 static void       DecoderFlush( decoder_t * );
  65 static void       DecoderSignalBuffering( decoder_t *, bool );
  66 static void       DecoderFlushBuffering( decoder_t * );
  67
  68 static void       DecoderUnsupportedCodec( decoder_t *, vlc_fourcc_t );
  69
  70 /* Buffers allocation callbacks for the decoders */
  71 static aout_buffer_t *aout_new_buffer( decoder_t *, int );
  72 static void aout_del_buffer( decoder_t *, aout_buffer_t * );
  73
  74 static picture_t *vout_new_buffer( decoder_t * );
  75 static void vout_del_buffer( decoder_t *, picture_t * );
  76 static void vout_link_picture( decoder_t *, picture_t * );
  77 static void vout_unlink_picture( decoder_t *, picture_t * );
  78
  79 static subpicture_t *spu_new_buffer( decoder_t *, const subpicture_updater_t * );
  80 static void spu_del_buffer( decoder_t *, subpicture_t * );
  81
  82 struct decoder_owner_sys_t
  83 {
  84     int64_t         i_preroll_end;
  85
  86     input_thread_t  *p_input;
  87     input_clock_t   *p_clock;
  88     int             i_last_rate;
  89
  90     vout_thread_t   *p_spu_vout;
  91     int              i_spu_channel;
  92     int64_t          i_spu_order;
  93
  94     sout_instance_t         *p_sout;
  95     sout_packetizer_input_t *p_sout_input;
  96
  97     /* Some decoders require already packetized data (ie. not truncated) */
  98     decoder_t *p_packetizer;
  99     bool b_packetizer;
 100
 101     /* Current format in use by the output */
 102     video_format_t video;
 103     audio_format_t audio;
 104     es_format_t    sout;
 105
 106     /* */
 107     bool           b_fmt_description;
 108     es_format_t    fmt_description;
 109     vlc_meta_t     *p_description;
 110
 111     /* fifo */
 112     block_fifo_t *p_fifo;
 113
 114     /* Lock for communication with decoder thread */
 115     vlc_mutex_t lock;
 116     vlc_cond_t  wait_request;
 117     vlc_cond_t  wait_acknowledge;
 118
 119     /* -- These variables need locking on write(only) -- */
 120     aout_instance_t *p_aout;
 121     aout_input_t    *p_aout_input;
 122
 123     vout_thread_t   *p_vout;
 124
 125     /* -- Theses variables need locking on read *and* write -- */
 126     /* */
 127     /* Pause */
 128     bool b_paused;
 129     struct
 130     {
 131         mtime_t i_date;
 132         int     i_ignore;
 133     } pause;
 134
 135     /* Buffering */
 136     bool b_buffering;
 137     struct
 138     {
 139         bool b_first;
 140         bool b_full;
 141         int  i_count;
 142
 143         picture_t     *p_picture;
 144         picture_t     **pp_picture_next;
 145
 146         subpicture_t  *p_subpic;
 147         subpicture_t  **pp_subpic_next;
 148
 149         aout_buffer_t *p_audio;
 150         aout_buffer_t **pp_audio_next;
 151
 152         block_t       *p_block;
 153         block_t       **pp_block_next;
 154     } buffer;
 155
 156     /* Flushing */
 157     bool b_flushing;
 158
 159     /* CC */
 160     struct
 161     {
 162         bool b_supported;
 163         bool pb_present[4];
 164         decoder_t *pp_decoder[4];
 165     } cc;
 166
 167     /* Delay */
 168     mtime_t i_ts_delay;
 169 };
 170
 171 #define DECODER_MAX_BUFFERING_COUNT (4)
 172 #define DECODER_MAX_BUFFERING_AUDIO_DURATION (AOUT_MAX_PREPARE_TIME)
 173 #define DECODER_MAX_BUFFERING_VIDEO_DURATION (1*CLOCK_FREQ)
 174
 175 /* Pictures which are DECODER_BOGUS_VIDEO_DELAY or more in advance probably have
 176  * a bogus PTS and won't be displayed */
 177 #define DECODER_BOGUS_VIDEO_DELAY                ((mtime_t)(DEFAULT_PTS_DELAY * 30))
 178
 179 /* */
 180 #define DECODER_SPU_VOUT_WAIT_DURATION ((int)(0.200*CLOCK_FREQ))
 181
 182
 183 /*****************************************************************************
 184  * Public functions
 185  *****************************************************************************/
 186 picture_t *decoder_NewPicture( decoder_t *p_decoder )
 187 {
 188     picture_t *p_picture = p_decoder->pf_vout_buffer_new( p_decoder );
 189     if( !p_picture )
 190         msg_Warn( p_decoder, "can't get output picture" );
 191     return p_picture;
 192 }
 193 void decoder_DeletePicture( decoder_t *p_decoder, picture_t *p_picture )
 194 {
 195     p_decoder->pf_vout_buffer_del( p_decoder, p_picture );
 196 }
 197 void decoder_LinkPicture( decoder_t *p_decoder, picture_t *p_picture )
 198 {
 199     p_decoder->pf_picture_link( p_decoder, p_picture );
 200 }
 201 void decoder_UnlinkPicture( decoder_t *p_decoder, picture_t *p_picture )
 202 {
 203     p_decoder->pf_picture_unlink( p_decoder, p_picture );
 204 }
 205
 206 aout_buffer_t *decoder_NewAudioBuffer( decoder_t *p_decoder, int i_size )
 207 {
 208     if( !p_decoder->pf_aout_buffer_new )
 209         return NULL;
 210     return p_decoder->pf_aout_buffer_new( p_decoder, i_size );
 211 }
 212 void decoder_DeleteAudioBuffer( decoder_t *p_decoder, aout_buffer_t *p_buffer )
 213 {
 214     p_decoder->pf_aout_buffer_del( p_decoder, p_buffer );
 215 }
 216
 217 subpicture_t *decoder_NewSubpicture( decoder_t *p_decoder,
 218                                      const subpicture_updater_t *p_dyn )
 219 {
 220     subpicture_t *p_subpicture = p_decoder->pf_spu_buffer_new( p_decoder, p_dyn );
 221     if( !p_subpicture )
 222         msg_Warn( p_decoder, "can't get output subpicture" );
 223     return p_subpicture;
 224 }
 225
 226 void decoder_DeleteSubpicture( decoder_t *p_decoder, subpicture_t *p_subpicture )
 227 {
 228     p_decoder->pf_spu_buffer_del( p_decoder, p_subpicture );
 229 }
 230
 231 /* decoder_GetInputAttachments:
 232  */
 233 int decoder_GetInputAttachments( decoder_t *p_dec,
 234                                  input_attachment_t ***ppp_attachment,
 235                                  int *pi_attachment )
 236 {
 237     if( !p_dec->pf_get_attachments )
 238         return VLC_EGENERIC;
 239
 240     return p_dec->pf_get_attachments( p_dec, ppp_attachment, pi_attachment );
 241 }
 242 /* decoder_GetDisplayDate:
 243  */
 244 mtime_t decoder_GetDisplayDate( decoder_t *p_dec, mtime_t i_ts )
 245 {
 246     if( !p_dec->pf_get_display_date )
 247         return VLC_TS_INVALID;
 248
 249     return p_dec->pf_get_display_date( p_dec, i_ts );
 250 }
 251 /* decoder_GetDisplayRate:
 252  */
 253 int decoder_GetDisplayRate( decoder_t *p_dec )
 254 {
 255     if( !p_dec->pf_get_display_rate )
 256         return INPUT_RATE_DEFAULT;
 257
 258     return p_dec->pf_get_display_rate( p_dec );
 259 }
 260
 261 /**
 262  * Spawns a new decoder thread
 263  *
 264  * \param p_input the input thread
 265  * \param p_es the es descriptor
 266  * \return the spawned decoder object
 267  */
 268 decoder_t *input_DecoderNew( input_thread_t *p_input,
 269                              es_format_t *fmt, input_clock_t *p_clock,
 270                              sout_instance_t *p_sout  )
 271 {
 272     decoder_t *p_dec = NULL;
 273     const char *psz_type = p_sout ? N_("packetizer") : N_("decoder");
 274     int i_priority;
 275
 276     /* Create the decoder configuration structure */
 277     p_dec = CreateDecoder( p_input, fmt, p_sout != NULL, p_sout );
 278     if( p_dec == NULL )
 279     {
 280         msg_Err( p_input, "could not create %s", psz_type );
 281         dialog_Fatal( p_input, _("Streaming / Transcoding failed"),
 282                       _("VLC could not open the %s module."),
 283                       vlc_gettext( psz_type ) );
 284         return NULL;
 285     }
 286
 287     if( !p_dec->p_module )
 288     {
 289         DecoderUnsupportedCodec( p_dec, fmt->i_codec );
 290
 291         DeleteDecoder( p_dec );
 292         return NULL;
 293     }
 294
 295     p_dec->p_owner->p_clock = p_clock;
 296     assert( p_dec->fmt_out.i_cat != UNKNOWN_ES );
 297
 298     if( p_dec->fmt_out.i_cat == AUDIO_ES )
 299         i_priority = VLC_THREAD_PRIORITY_AUDIO;
 300     else
 301         i_priority = VLC_THREAD_PRIORITY_VIDEO;
 302
 303     /* Spawn the decoder thread */
 304     if( vlc_thread_create( p_dec, "decoder", DecoderThread, i_priority ) )
 305     {
 306         msg_Err( p_dec, "cannot spawn decoder thread" );
 307         module_unneed( p_dec, p_dec->p_module );
 308         DeleteDecoder( p_dec );
 309         return NULL;
 310     }
 311
 312     return p_dec;
 313 }
 314
 315 /**
 316  * Kills a decoder thread and waits until it's finished
 317  *
 318  * \param p_input the input thread
 319  * \param p_es the es descriptor
 320  * \return nothing
 321  */
 322 void input_DecoderDelete( decoder_t *p_dec )
 323 {
 324     decoder_owner_sys_t *p_owner = p_dec->p_owner;
 325
 326     vlc_object_kill( p_dec );
 327
 328     /* Make sure we aren't paused/buffering/waiting anymore */
 329     vlc_mutex_lock( &p_owner->lock );
 330     const bool b_was_paused = p_owner->b_paused;
 331     p_owner->b_paused = false;
 332     p_owner->b_buffering = false;
 333     p_owner->b_flushing = true;
 334     vlc_cond_signal( &p_owner->wait_request );
 335     vlc_mutex_unlock( &p_owner->lock );
 336
 337     vlc_thread_join( p_dec );
 338     p_owner->b_paused = b_was_paused;
 339
 340     module_unneed( p_dec, p_dec->p_module );
 341
 342     /* */
 343     if( p_dec->p_owner->cc.b_supported )
 344     {
 345         int i;
 346         for( i = 0; i < 4; i++ )
 347             input_DecoderSetCcState( p_dec, false, i );
 348     }
 349
 350     /* Delete decoder */
 351     DeleteDecoder( p_dec );
 352 }
 353
 354 /**
 355  * Put a block_t in the decoder's fifo.
 356  * Thread-safe w.r.t. the decoder. May be a cancellation point.
 357  *
 358  * \param p_dec the decoder object
 359  * \param p_block the data block
 360  */
 361 void input_DecoderDecode( decoder_t *p_dec, block_t *p_block, bool b_do_pace )
 362 {
 363     decoder_owner_sys_t *p_owner = p_dec->p_owner;
 364
 365     if( b_do_pace )
 366     {
 367         /* The fifo is not consummed when buffering and so will
 368          * deadlock vlc.
 369          * There is no need to lock as b_buffering is never modify
 370          * inside decoder thread. */
 371         if( !p_owner->b_buffering )
 372             block_FifoPace( p_owner->p_fifo, 10, SIZE_MAX );
 373     }
 374 #ifdef __arm__
 375     else if( block_FifoSize( p_owner->p_fifo ) > 50*1024*1024 /* 50 MiB */ )
 376 #else
 377     else if( block_FifoSize( p_owner->p_fifo ) > 400*1024*1024 /* 400 MiB, ie ~ 50mb/s for 60s */ )
 378 #endif
 379     {
 380         /* FIXME: ideally we would check the time amount of data
 381          * in the FIFO instead of its size. */
 382         msg_Warn( p_dec, "decoder/packetizer fifo full (data not "
 383                   "consumed quickly enough), resetting fifo!" );
 384         block_FifoEmpty( p_owner->p_fifo );
 385     }
 386
 387     block_FifoPut( p_owner->p_fifo, p_block );
 388 }
 389
 390 bool input_DecoderIsEmpty( decoder_t * p_dec )
 391 {
 392     decoder_owner_sys_t *p_owner = p_dec->p_owner;
 393     assert( !p_owner->b_buffering );
 394
 395     bool b_empty = block_FifoCount( p_dec->p_owner->p_fifo ) <= 0;
 396     if( b_empty )
 397     {
 398         vlc_mutex_lock( &p_owner->lock );
 399         /* TODO audio support */
 400         if( p_dec->fmt_out.i_cat == VIDEO_ES && p_owner->p_vout )
 401             b_empty = vout_IsEmpty( p_owner->p_vout );
 402         vlc_mutex_unlock( &p_owner->lock );
 403     }
 404     return b_empty;
 405 }
 406
 407 void input_DecoderIsCcPresent( decoder_t *p_dec, bool pb_present[4] )
 408 {
 409     decoder_owner_sys_t *p_owner = p_dec->p_owner;
 410     int i;
 411
 412     vlc_mutex_lock( &p_owner->lock );
 413     for( i = 0; i < 4; i++ )
 414         pb_present[i] =  p_owner->cc.pb_present[i];
 415     vlc_mutex_unlock( &p_owner->lock );
 416 }
 417 int input_DecoderSetCcState( decoder_t *p_dec, bool b_decode, int i_channel )
 418 {
 419     decoder_owner_sys_t *p_owner = p_dec->p_owner;
 420
 421     //msg_Warn( p_dec, "input_DecoderSetCcState: %d @%d", b_decode, i_channel );
 422
 423     if( i_channel < 0 || i_channel >= 4 || !p_owner->cc.pb_present[i_channel] )
 424         return VLC_EGENERIC;
 425
 426     if( b_decode )
 427     {
 428         static const vlc_fourcc_t fcc[4] = {
 429             VLC_FOURCC('c', 'c', '1', ' '),
 430             VLC_FOURCC('c', 'c', '2', ' '),
 431             VLC_FOURCC('c', 'c', '3', ' '),
 432             VLC_FOURCC('c', 'c', '4', ' '),
 433         };
 434         decoder_t *p_cc;
 435         es_format_t fmt;
 436
 437         es_format_Init( &fmt, SPU_ES, fcc[i_channel] );
 438         p_cc = CreateDecoder( p_owner->p_input, &fmt, false, p_owner->p_sout );
 439         if( !p_cc )
 440         {
 441             msg_Err( p_dec, "could not create decoder" );
 442             dialog_Fatal( p_dec, _("Streaming / Transcoding failed"), "%s",
 443                           _("VLC could not open the decoder module.") );
 444             return VLC_EGENERIC;
 445         }
 446         else if( !p_cc->p_module )
 447         {
 448             DecoderUnsupportedCodec( p_dec, fcc[i_channel] );
 449             DeleteDecoder( p_cc );
 450             return VLC_EGENERIC;
 451         }
 452         p_cc->p_owner->p_clock = p_owner->p_clock;
 453
 454         vlc_mutex_lock( &p_owner->lock );
 455         p_owner->cc.pp_decoder[i_channel] = p_cc;
 456         vlc_mutex_unlock( &p_owner->lock );
 457     }
 458     else
 459     {
 460         decoder_t *p_cc;
 461
 462         vlc_mutex_lock( &p_owner->lock );
 463         p_cc = p_owner->cc.pp_decoder[i_channel];
 464         p_owner->cc.pp_decoder[i_channel] = NULL;
 465         vlc_mutex_unlock( &p_owner->lock );
 466
 467         if( p_cc )
 468         {
 469             vlc_object_kill( p_cc );
 470             module_unneed( p_cc, p_cc->p_module );
 471             DeleteDecoder( p_cc );
 472         }
 473     }
 474     return VLC_SUCCESS;
 475 }
 476 int input_DecoderGetCcState( decoder_t *p_dec, bool *pb_decode, int i_channel )
 477 {
 478     decoder_owner_sys_t *p_owner = p_dec->p_owner;
 479
 480     *pb_decode = false;
 481     if( i_channel < 0 || i_channel >= 4 || !p_owner->cc.pb_present[i_channel] )
 482         return VLC_EGENERIC;
 483
 484     vlc_mutex_lock( &p_owner->lock );
 485     *pb_decode = p_owner->cc.pp_decoder[i_channel] != NULL;
 486     vlc_mutex_unlock( &p_owner->lock );
 487     return VLC_EGENERIC;
 488 }
 489
 490 void input_DecoderChangePause( decoder_t *p_dec, bool b_paused, mtime_t i_date )
 491 {
 492     decoder_owner_sys_t *p_owner = p_dec->p_owner;
 493
 494     vlc_mutex_lock( &p_owner->lock );
 495
 496     assert( !p_owner->b_paused || !b_paused );
 497
 498     p_owner->b_paused = b_paused;
 499     p_owner->pause.i_date = i_date;
 500     p_owner->pause.i_ignore = 0;
 501     vlc_cond_signal( &p_owner->wait_request );
 502
 503     DecoderOutputChangePause( p_dec, b_paused, i_date );
 504
 505     vlc_mutex_unlock( &p_owner->lock );
 506 }
 507
 508 void input_DecoderChangeDelay( decoder_t *p_dec, mtime_t i_delay )
 509 {
 510     decoder_owner_sys_t *p_owner = p_dec->p_owner;
 511
 512     vlc_mutex_lock( &p_owner->lock );
 513     p_owner->i_ts_delay = i_delay;
 514     vlc_mutex_unlock( &p_owner->lock );
 515 }
 516
 517 void input_DecoderStartBuffering( decoder_t *p_dec )
 518 {
 519     decoder_owner_sys_t *p_owner = p_dec->p_owner;
 520
 521     vlc_mutex_lock( &p_owner->lock );
 522
 523     DecoderFlush( p_dec );
 524
 525     p_owner->buffer.b_first = true;
 526     p_owner->buffer.b_full = false;
 527     p_owner->buffer.i_count = 0;
 528
 529     assert( !p_owner->buffer.p_picture && !p_owner->buffer.p_subpic &&
 530             !p_owner->buffer.p_audio && !p_owner->buffer.p_block );
 531
 532     p_owner->buffer.p_picture = NULL;
 533     p_owner->buffer.pp_picture_next = &p_owner->buffer.p_picture;
 534
 535     p_owner->buffer.p_subpic = NULL;
 536     p_owner->buffer.pp_subpic_next = &p_owner->buffer.p_subpic;
 537
 538     p_owner->buffer.p_audio = NULL;
 539     p_owner->buffer.pp_audio_next = &p_owner->buffer.p_audio;
 540
 541     p_owner->buffer.p_block = NULL;
 542     p_owner->buffer.pp_block_next = &p_owner->buffer.p_block;
 543
 544
 545     p_owner->b_buffering = true;
 546
 547     vlc_cond_signal( &p_owner->wait_request );
 548
 549     vlc_mutex_unlock( &p_owner->lock );
 550 }
 551
 552 void input_DecoderStopBuffering( decoder_t *p_dec )
 553 {
 554     decoder_owner_sys_t *p_owner = p_dec->p_owner;
 555
 556     vlc_mutex_lock( &p_owner->lock );
 557
 558     p_owner->b_buffering = false;
 559
 560     vlc_cond_signal( &p_owner->wait_request );
 561
 562     vlc_mutex_unlock( &p_owner->lock );
 563 }
 564
 565 void input_DecoderWaitBuffering( decoder_t *p_dec )
 566 {
 567     decoder_owner_sys_t *p_owner = p_dec->p_owner;
 568
 569     vlc_mutex_lock( &p_owner->lock );
 570
 571     while( vlc_object_alive( p_dec ) && p_owner->b_buffering && !p_owner->buffer.b_full )
 572     {
 573         block_FifoWake( p_owner->p_fifo );
 574         vlc_cond_wait( &p_owner->wait_acknowledge, &p_owner->lock );
 575     }
 576
 577     vlc_mutex_unlock( &p_owner->lock );
 578 }
 579
 580 void input_DecoderFrameNext( decoder_t *p_dec, mtime_t *pi_duration )
 581 {
 582     decoder_owner_sys_t *p_owner = p_dec->p_owner;
 583
 584     *pi_duration = 0;
 585
 586     vlc_mutex_lock( &p_owner->lock );
 587     if( p_dec->fmt_out.i_cat == VIDEO_ES )
 588     {
 589         if( p_owner->b_paused && p_owner->p_vout )
 590         {
 591             vout_NextPicture( p_owner->p_vout, pi_duration );
 592             p_owner->pause.i_ignore++;
 593             vlc_cond_signal( &p_owner->wait_request );
 594         }
 595     }
 596     else
 597     {
 598         /* TODO subtitle should not be flushed */
 599         DecoderFlush( p_dec );
 600     }
 601     vlc_mutex_unlock( &p_owner->lock );
 602 }
 603
 604 bool input_DecoderHasFormatChanged( decoder_t *p_dec, es_format_t *p_fmt, vlc_meta_t **pp_meta )
 605 {
 606     decoder_owner_sys_t *p_owner = p_dec->p_owner;
 607     bool b_changed;
 608
 609     vlc_mutex_lock( &p_owner->lock );
 610     b_changed = p_owner->b_fmt_description;
 611     if( b_changed )
 612     {
 613         if( p_fmt )
 614             es_format_Copy( p_fmt, &p_owner->fmt_description );
 615
 616         if( pp_meta )
 617         {
 618             *pp_meta = NULL;
 619             if( p_owner->p_description )
 620             {
 621                 *pp_meta = vlc_meta_New();
 622                 if( *pp_meta )
 623                     vlc_meta_Merge( *pp_meta, p_owner->p_description );
 624             }
 625         }
 626         p_owner->b_fmt_description = false;
 627     }
 628     vlc_mutex_unlock( &p_owner->lock );
 629     return b_changed;
 630 }
 631
 632 size_t input_DecoderGetFifoSize( decoder_t *p_dec )
 633 {
 634     decoder_owner_sys_t *p_owner = p_dec->p_owner;
 635
 636     return block_FifoSize( p_owner->p_fifo );
 637 }
 638
 639 void input_DecoderGetObjects( decoder_t *p_dec,
 640                               vout_thread_t **pp_vout, aout_instance_t **pp_aout )
 641 {
 642     decoder_owner_sys_t *p_owner = p_dec->p_owner;
 643
 644     vlc_mutex_lock( &p_owner->lock );
 645     if( pp_vout )
 646         *pp_vout = p_owner->p_vout ? vlc_object_hold( p_owner->p_vout ) : NULL;
 647     if( pp_aout )
 648         *pp_aout = p_owner->p_aout ? vlc_object_hold( p_owner->p_aout ) : NULL;
 649     vlc_mutex_unlock( &p_owner->lock );
 650 }
 651
 652 /*****************************************************************************
 653  * Internal functions
 654  *****************************************************************************/
 655 static int DecoderGetInputAttachments( decoder_t *p_dec,
 656                                        input_attachment_t ***ppp_attachment,
 657                                        int *pi_attachment )
 658 {
 659     return input_Control( p_dec->p_owner->p_input, INPUT_GET_ATTACHMENTS,
 660                           ppp_attachment, pi_attachment );
 661 }
 662 static mtime_t DecoderGetDisplayDate( decoder_t *p_dec, mtime_t i_ts )
 663 {
 664     decoder_owner_sys_t *p_owner = p_dec->p_owner;
 665
 666     vlc_mutex_lock( &p_owner->lock );
 667     if( p_owner->b_buffering || p_owner->b_paused )
 668         i_ts = VLC_TS_INVALID;
 669     vlc_mutex_unlock( &p_owner->lock );
 670
 671     if( !p_owner->p_clock || i_ts <= VLC_TS_INVALID )
 672         return i_ts;
 673
 674     if( input_clock_ConvertTS( p_owner->p_clock, NULL, &i_ts, NULL, INT64_MAX ) )
 675         return VLC_TS_INVALID;
 676
 677     return i_ts;
 678 }
 679 static int DecoderGetDisplayRate( decoder_t *p_dec )
 680 {
 681     decoder_owner_sys_t *p_owner = p_dec->p_owner;
 682
 683     if( !p_owner->p_clock )
 684         return INPUT_RATE_DEFAULT;
 685     return input_clock_GetRate( p_owner->p_clock );
 686 }
 687
 688 /* */
 689 static void DecoderUnsupportedCodec( decoder_t *p_dec, vlc_fourcc_t codec )
 690 {
 691     msg_Err( p_dec, "no suitable decoder module for fourcc `%4.4s'. "
 692              "VLC probably does not support this sound or video format.",
 693              (char*)&codec );
 694     dialog_Fatal( p_dec, _("No suitable decoder module"),
 695                  _("VLC does not support the audio or video format \"%4.4s\". "
 696                   "Unfortunately there is no way for you to fix this."),
 697                   (char*)&codec );
 698 }
 699
 700
 701 /**
 702  * Create a decoder object
 703  *
 704  * \param p_input the input thread
 705  * \param p_es the es descriptor
 706  * \param b_packetizer instead of a decoder
 707  * \return the decoder object
 708  */
 709 static decoder_t * CreateDecoder( input_thread_t *p_input,
 710                                   es_format_t *fmt, bool b_packetizer,
 711                                   sout_instance_t *p_sout )
 712 {
 713     decoder_t *p_dec;
 714     decoder_owner_sys_t *p_owner;
 715     es_format_t null_es_format;
 716
 717     p_dec = vlc_custom_create( p_input, sizeof( *p_dec ), VLC_OBJECT_DECODER,
 718                                "decoder" );
 719     if( p_dec == NULL )
 720         return NULL;
 721
 722     p_dec->pf_decode_audio = NULL;
 723     p_dec->pf_decode_video = NULL;
 724     p_dec->pf_decode_sub = NULL;
 725     p_dec->pf_get_cc = NULL;
 726     p_dec->pf_packetize = NULL;
 727
 728     /* Initialize the decoder */
 729     p_dec->p_module = NULL;
 730
 731     memset( &null_es_format, 0, sizeof(es_format_t) );
 732     es_format_Copy( &p_dec->fmt_in, fmt );
 733     es_format_Copy( &p_dec->fmt_out, &null_es_format );
 734
 735     p_dec->p_description = NULL;
 736
 737     /* Allocate our private structure for the decoder */
 738     p_dec->p_owner = p_owner = malloc( sizeof( decoder_owner_sys_t ) );
 739     if( p_dec->p_owner == NULL )
 740     {
 741         vlc_object_release( p_dec );
 742         return NULL;
 743     }
 744     p_dec->p_owner->i_preroll_end = VLC_TS_INVALID;
 745     p_dec->p_owner->i_last_rate = INPUT_RATE_DEFAULT;
 746     p_dec->p_owner->p_input = p_input;
 747     p_dec->p_owner->p_aout = NULL;
 748     p_dec->p_owner->p_aout_input = NULL;
 749     p_dec->p_owner->p_vout = NULL;
 750     p_dec->p_owner->p_spu_vout = NULL;
 751     p_dec->p_owner->i_spu_channel = 0;
 752     p_dec->p_owner->i_spu_order = 0;
 753     p_dec->p_owner->p_sout = p_sout;
 754     p_dec->p_owner->p_sout_input = NULL;
 755     p_dec->p_owner->p_packetizer = NULL;
 756     p_dec->p_owner->b_packetizer = b_packetizer;
 757
 758     /* decoder fifo */
 759     if( ( p_dec->p_owner->p_fifo = block_FifoNew() ) == NULL )
 760     {
 761         free( p_dec->p_owner );
 762         vlc_object_release( p_dec );
 763         return NULL;
 764     }
 765
 766     /* Set buffers allocation callbacks for the decoders */
 767     p_dec->pf_aout_buffer_new = aout_new_buffer;
 768     p_dec->pf_aout_buffer_del = aout_del_buffer;
 769     p_dec->pf_vout_buffer_new = vout_new_buffer;
 770     p_dec->pf_vout_buffer_del = vout_del_buffer;
 771     p_dec->pf_picture_link    = vout_link_picture;
 772     p_dec->pf_picture_unlink  = vout_unlink_picture;
 773     p_dec->pf_spu_buffer_new  = spu_new_buffer;
 774     p_dec->pf_spu_buffer_del  = spu_del_buffer;
 775     /* */
 776     p_dec->pf_get_attachments  = DecoderGetInputAttachments;
 777     p_dec->pf_get_display_date = DecoderGetDisplayDate;
 778     p_dec->pf_get_display_rate = DecoderGetDisplayRate;
 779
 780     vlc_object_attach( p_dec, p_input );
 781
 782     /* Find a suitable decoder/packetizer module */
 783     if( !b_packetizer )
 784         p_dec->p_module = module_need( p_dec, "decoder", "$codec", false );
 785     else
 786         p_dec->p_module = module_need( p_dec, "packetizer", "$packetizer", false );
 787
 788     /* Check if decoder requires already packetized data */
 789     if( !b_packetizer &&
 790         p_dec->b_need_packetized && !p_dec->fmt_in.b_packetized )
 791     {
 792         p_dec->p_owner->p_packetizer =
 793             vlc_custom_create( p_input, sizeof( decoder_t ),
 794                                VLC_OBJECT_DECODER, "packetizer" );
 795         if( p_dec->p_owner->p_packetizer )
 796         {
 797             es_format_Copy( &p_dec->p_owner->p_packetizer->fmt_in,
 798                             &p_dec->fmt_in );
 799
 800             es_format_Copy( &p_dec->p_owner->p_packetizer->fmt_out,
 801                             &null_es_format );
 802
 803             vlc_object_attach( p_dec->p_owner->p_packetizer, p_input );
 804
 805             p_dec->p_owner->p_packetizer->p_module =
 806                 module_need( p_dec->p_owner->p_packetizer,
 807                              "packetizer", "$packetizer", false );
 808
 809             if( !p_dec->p_owner->p_packetizer->p_module )
 810             {
 811                 es_format_Clean( &p_dec->p_owner->p_packetizer->fmt_in );
 812                 vlc_object_release( p_dec->p_owner->p_packetizer );
 813             }
 814         }
 815     }
 816
 817     /* Copy ourself the input replay gain */
 818     if( fmt->i_cat == AUDIO_ES )
 819     {
 820         for( unsigned i = 0; i < AUDIO_REPLAY_GAIN_MAX; i++ )
 821         {
 822             if( !p_dec->fmt_out.audio_replay_gain.pb_peak[i] )
 823             {
 824                 p_dec->fmt_out.audio_replay_gain.pb_peak[i] = fmt->audio_replay_gain.pb_peak[i];
 825                 p_dec->fmt_out.audio_replay_gain.pf_peak[i] = fmt->audio_replay_gain.pf_peak[i];
 826             }
 827             if( !p_dec->fmt_out.audio_replay_gain.pb_gain[i] )
 828             {
 829                 p_dec->fmt_out.audio_replay_gain.pb_gain[i] = fmt->audio_replay_gain.pb_gain[i];
 830                 p_dec->fmt_out.audio_replay_gain.pf_gain[i] = fmt->audio_replay_gain.pf_gain[i];
 831             }
 832         }
 833     }
 834
 835     /* */
 836     vlc_mutex_init( &p_owner->lock );
 837     vlc_cond_init( &p_owner->wait_request );
 838     vlc_cond_init( &p_owner->wait_acknowledge );
 839
 840     p_owner->b_fmt_description = false;
 841     es_format_Init( &p_owner->fmt_description, UNKNOWN_ES, 0 );
 842     p_owner->p_description = NULL;
 843
 844     p_owner->b_paused = false;
 845     p_owner->pause.i_date = VLC_TS_INVALID;
 846     p_owner->pause.i_ignore = 0;
 847
 848     p_owner->b_buffering = false;
 849     p_owner->buffer.b_first = true;
 850     p_owner->buffer.b_full = false;
 851     p_owner->buffer.i_count = 0;
 852     p_owner->buffer.p_picture = NULL;
 853     p_owner->buffer.p_subpic = NULL;
 854     p_owner->buffer.p_audio = NULL;
 855     p_owner->buffer.p_block = NULL;
 856
 857     p_owner->b_flushing = false;
 858
 859     /* */
 860     p_owner->cc.b_supported = false;
 861     if( !b_packetizer )
 862     {
 863         if( p_owner->p_packetizer && p_owner->p_packetizer->pf_get_cc )
 864             p_owner->cc.b_supported = true;
 865         if( p_dec->pf_get_cc )
 866             p_owner->cc.b_supported = true;
 867     }
 868
 869     for( unsigned i = 0; i < 4; i++ )
 870     {
 871         p_owner->cc.pb_present[i] = false;
 872         p_owner->cc.pp_decoder[i] = NULL;
 873     }
 874     p_owner->i_ts_delay = 0;
 875     return p_dec;
 876 }
 877
 878 /**
 879  * The decoding main loop
 880  *
 881  * \param p_dec the decoder
 882  */
 883 static void *DecoderThread( vlc_object_t *p_this )
 884 {
 885     decoder_t *p_dec = (decoder_t *)p_this;
 886     decoder_owner_sys_t *p_owner = p_dec->p_owner;
 887
 888     /* The decoder's main loop */
 889     for( ;; )
 890     {
 891         block_t *p_block = block_FifoGet( p_owner->p_fifo );
 892
 893         /* Make sure there is no cancellation point other than this one^^.
 894          * If you need one, be sure to push cleanup of p_block. */
 895         DecoderSignalBuffering( p_dec, p_block == NULL );
 896
 897         if( p_block )
 898         {
 899             int canc = vlc_savecancel();
 900
 901             if( p_dec->b_error )
 902                 DecoderError( p_dec, p_block );
 903             else
 904                 DecoderProcess( p_dec, p_block );
 905
 906             vlc_restorecancel( canc );
 907         }
 908     }
 909     return NULL;
 910 }
 911
 912 static block_t *DecoderBlockFlushNew()
 913 {
 914     block_t *p_null = block_Alloc( 128 );
 915     if( !p_null )
 916         return NULL;
 917
 918     p_null->i_flags |= BLOCK_FLAG_DISCONTINUITY |
 919                        BLOCK_FLAG_CORRUPTED |
 920                        BLOCK_FLAG_CORE_FLUSH;
 921     memset( p_null->p_buffer, 0, p_null->i_buffer );
 922
 923     return p_null;
 924 }
 925
 926 static void DecoderFlush( decoder_t *p_dec )
 927 {
 928     decoder_owner_sys_t *p_owner = p_dec->p_owner;
 929
 930     vlc_assert_locked( &p_owner->lock );
 931
 932     /* Empty the fifo */
 933     block_FifoEmpty( p_owner->p_fifo );
 934
 935     /* Monitor for flush end */
 936     p_owner->b_flushing = true;
 937     vlc_cond_signal( &p_owner->wait_request );
 938
 939     /* Send a special block */
 940     block_t *p_null = DecoderBlockFlushNew();
 941     if( !p_null )
 942         return;
 943     input_DecoderDecode( p_dec, p_null, false );
 944
 945     /* */
 946     while( vlc_object_alive( p_dec ) && p_owner->b_flushing )
 947         vlc_cond_wait( &p_owner->wait_acknowledge, &p_owner->lock );
 948 }
 949
 950 static void DecoderSignalBuffering( decoder_t *p_dec, bool b_full )
 951 {
 952     decoder_owner_sys_t *p_owner = p_dec->p_owner;
 953
 954     vlc_mutex_lock( &p_owner->lock );
 955
 956     if( p_owner->b_buffering )
 957     {
 958         if( b_full )
 959             p_owner->buffer.b_full = true;
 960         vlc_cond_signal( &p_owner->wait_acknowledge );
 961     }
 962
 963     vlc_mutex_unlock( &p_owner->lock );
 964 }
 965
 966 static bool DecoderIsFlushing( decoder_t *p_dec )
 967 {
 968     decoder_owner_sys_t *p_owner = p_dec->p_owner;
 969     bool b_flushing;
 970
 971     vlc_mutex_lock( &p_owner->lock );
 972
 973     b_flushing = p_owner->b_flushing;
 974
 975     vlc_mutex_unlock( &p_owner->lock );
 976
 977     return b_flushing;
 978 }
 979
 980 static void DecoderWaitUnblock( decoder_t *p_dec, bool *pb_reject )
 981 {
 982     decoder_owner_sys_t *p_owner = p_dec->p_owner;
 983
 984     vlc_assert_locked( &p_owner->lock );
 985
 986     while( !p_owner->b_flushing )
 987     {
 988         if( p_owner->b_paused )
 989         {
 990             if( p_owner->b_buffering && !p_owner->buffer.b_full )
 991                 break;
 992             if( p_owner->pause.i_ignore > 0 )
 993             {
 994                 p_owner->pause.i_ignore--;
 995                 break;
 996             }
 997         }
 998         else
 999         {
1000             if( !p_owner->b_buffering || !p_owner->buffer.b_full )
1001                 break;
1002         }
1003         vlc_cond_wait( &p_owner->wait_request, &p_owner->lock );
1004     }
1005
1006     if( pb_reject )
1007         *pb_reject = p_owner->b_flushing;
1008 }
1009
1010 static void DecoderOutputChangePause( decoder_t *p_dec, bool b_paused, mtime_t i_date )
1011 {
1012     decoder_owner_sys_t *p_owner = p_dec->p_owner;
1013
1014     vlc_assert_locked( &p_owner->lock );
1015
1016     /* XXX only audio and video output have to be paused.
1017      * - for sout it is useless
1018      * - for subs, it is done by the vout
1019      */
1020     if( p_dec->fmt_out.i_cat == AUDIO_ES )
1021     {
1022         if( p_owner->p_aout && p_owner->p_aout_input )
1023             aout_DecChangePause( p_owner->p_aout, p_owner->p_aout_input,
1024                                  b_paused, i_date );
1025     }
1026     else if( p_dec->fmt_out.i_cat == VIDEO_ES )
1027     {
1028         if( p_owner->p_vout )
1029             vout_ChangePause( p_owner->p_vout, b_paused, i_date );
1030     }
1031 }
1032 static inline void DecoderUpdatePreroll( int64_t *pi_preroll, const block_t *p )
1033 {
1034     if( p->i_flags & (BLOCK_FLAG_PREROLL|BLOCK_FLAG_DISCONTINUITY) )
1035         *pi_preroll = INT64_MAX;
1036     else if( p->i_dts > VLC_TS_INVALID )
1037         *pi_preroll = __MIN( *pi_preroll, p->i_dts );
1038     else if( p->i_pts > VLC_TS_INVALID )
1039         *pi_preroll = __MIN( *pi_preroll, p->i_pts );
1040 }
1041
1042 static mtime_t DecoderTeletextFixTs( mtime_t i_ts )
1043 {
1044     mtime_t current_date = mdate();
1045
1046     /* FIXME I don't really like that, es_out SHOULD do it using the video pts */
1047     if( i_ts <= VLC_TS_INVALID || i_ts > current_date + 10000000 || i_ts < current_date )
1048     {
1049         /* ETSI EN 300 472 Annex A : do not take into account the PTS
1050          * for teletext streams. */
1051         return current_date + 400000;
1052     }
1053     return i_ts;
1054 }
1055
1056 static void DecoderFixTs( decoder_t *p_dec, mtime_t *pi_ts0, mtime_t *pi_ts1,
1057                           mtime_t *pi_duration, int *pi_rate, mtime_t i_ts_bound, bool b_telx )
1058 {
1059     decoder_owner_sys_t *p_owner = p_dec->p_owner;
1060     input_clock_t   *p_clock = p_owner->p_clock;
1061
1062     vlc_assert_locked( &p_owner->lock );
1063
1064     const mtime_t i_es_delay = p_owner->i_ts_delay;
1065
1066     if( p_clock )
1067     {
1068         const bool b_ephemere = pi_ts1 && *pi_ts0 == *pi_ts1;
1069         int i_rate;
1070
1071         if( *pi_ts0 > VLC_TS_INVALID )
1072         {
1073             *pi_ts0 += i_es_delay;
1074             if( pi_ts1 && *pi_ts1 > VLC_TS_INVALID )
1075                 *pi_ts1 += i_es_delay;
1076             if( input_clock_ConvertTS( p_clock, &i_rate, pi_ts0, pi_ts1, i_ts_bound ) )
1077                 *pi_ts0 = VLC_TS_INVALID;
1078         }
1079         else
1080         {
1081             i_rate = input_clock_GetRate( p_clock );
1082         }
1083
1084         /* Do not create ephemere data because of rounding errors */
1085         if( !b_ephemere && pi_ts1 && *pi_ts0 == *pi_ts1 )
1086             *pi_ts1 += 1;
1087
1088         if( pi_duration )
1089             *pi_duration = ( *pi_duration * i_rate +
1090                                     INPUT_RATE_DEFAULT-1 ) / INPUT_RATE_DEFAULT;
1091
1092         if( pi_rate )
1093             *pi_rate = i_rate;
1094
1095         if( b_telx )
1096         {
1097             *pi_ts0 = DecoderTeletextFixTs( *pi_ts0 );
1098             if( pi_ts1 && *pi_ts1 <= VLC_TS_INVALID )
1099                 *pi_ts1 = *pi_ts0;
1100         }
1101     }
1102 }
1103
1104 /**
1105  * If *pb_reject, it does nothing, otherwise it waits for the given
1106  * deadline or a flush request (in which case it set *pi_reject to true.
1107  */
1108 static void DecoderWaitDate( decoder_t *p_dec,
1109                              bool *pb_reject, mtime_t i_deadline )
1110 {
1111     decoder_owner_sys_t *p_owner = p_dec->p_owner;
1112
1113     if( *pb_reject || i_deadline < 0 )
1114         return;
1115
1116     for( ;; )
1117     {
1118         vlc_mutex_lock( &p_owner->lock );
1119         if( p_owner->b_flushing || p_dec->b_die )
1120         {
1121             *pb_reject = true;
1122             vlc_mutex_unlock( &p_owner->lock );
1123             break;
1124         }
1125         int i_ret = vlc_cond_timedwait( &p_owner->wait_request, &p_owner->lock,
1126                                         i_deadline );
1127         vlc_mutex_unlock( &p_owner->lock );
1128         if( i_ret )
1129             break;
1130     }
1131 }
1132
1133 static void DecoderPlayAudio( decoder_t *p_dec, aout_buffer_t *p_audio,
1134                               int *pi_played_sum, int *pi_lost_sum )
1135 {
1136     decoder_owner_sys_t *p_owner = p_dec->p_owner;
1137     aout_instance_t *p_aout = p_owner->p_aout;
1138     aout_input_t    *p_aout_input = p_owner->p_aout_input;
1139
1140     /* */
1141     if( p_audio->i_pts <= VLC_TS_INVALID ) // FIXME --VLC_TS_INVALID verify audio_output/*
1142     {
1143         msg_Warn( p_dec, "non-dated audio buffer received" );
1144         *pi_lost_sum += 1;
1145         aout_BufferFree( p_audio );
1146         return;
1147     }
1148
1149     /* */
1150     vlc_mutex_lock( &p_owner->lock );
1151
1152     if( p_owner->b_buffering || p_owner->buffer.p_audio )
1153     {
1154         p_audio->p_next = NULL;
1155
1156         *p_owner->buffer.pp_audio_next = p_audio;
1157         p_owner->buffer.pp_audio_next = &p_audio->p_next;
1158
1159         p_owner->buffer.i_count++;
1160         if( p_owner->buffer.i_count > DECODER_MAX_BUFFERING_COUNT ||
1161             p_audio->i_pts - p_owner->buffer.p_audio->i_pts > DECODER_MAX_BUFFERING_AUDIO_DURATION )
1162         {
1163             p_owner->buffer.b_full = true;
1164             vlc_cond_signal( &p_owner->wait_acknowledge );
1165         }
1166     }
1167
1168     for( ;; )
1169     {
1170         bool b_has_more = false;
1171         bool b_reject;
1172         DecoderWaitUnblock( p_dec, &b_reject );
1173
1174         if( p_owner->b_buffering )
1175         {
1176             vlc_mutex_unlock( &p_owner->lock );
1177             return;
1178         }
1179
1180         /* */
1181         if( p_owner->buffer.p_audio )
1182         {
1183             p_audio = p_owner->buffer.p_audio;
1184
1185             p_owner->buffer.p_audio = p_audio->p_next;
1186             p_owner->buffer.i_count--;
1187
1188             b_has_more = p_owner->buffer.p_audio != NULL;
1189             if( !b_has_more )
1190                 p_owner->buffer.pp_audio_next = &p_owner->buffer.p_audio;
1191         }
1192
1193         /* */
1194         const bool b_dated = p_audio->i_pts > VLC_TS_INVALID;
1195         int i_rate = INPUT_RATE_DEFAULT;
1196
1197         DecoderFixTs( p_dec, &p_audio->i_pts, NULL, &p_audio->i_length,
1198                       &i_rate, AOUT_MAX_ADVANCE_TIME, false );
1199
1200         vlc_mutex_unlock( &p_owner->lock );
1201
1202         if( !p_aout || !p_aout_input ||
1203             p_audio->i_pts <= VLC_TS_INVALID ||
1204             i_rate < INPUT_RATE_DEFAULT/AOUT_MAX_INPUT_RATE ||
1205             i_rate > INPUT_RATE_DEFAULT*AOUT_MAX_INPUT_RATE )
1206             b_reject = true;
1207
1208         DecoderWaitDate( p_dec, &b_reject,
1209                          p_audio->i_pts - AOUT_MAX_PREPARE_TIME );
1210
1211         if( !b_reject )
1212         {
1213             if( !aout_DecPlay( p_aout, p_aout_input, p_audio, i_rate ) )
1214                 *pi_played_sum += 1;
1215             *pi_lost_sum += aout_DecGetResetLost( p_aout, p_aout_input );
1216         }
1217         else
1218         {
1219             if( b_dated )
1220                 msg_Warn( p_aout, "received buffer in the future" );
1221             else
1222                 msg_Warn( p_dec, "non-dated audio buffer received" );
1223
1224             *pi_lost_sum += 1;
1225             aout_BufferFree( p_audio );
1226         }
1227
1228         if( !b_has_more )
1229             break;
1230
1231         vlc_mutex_lock( &p_owner->lock );
1232         if( !p_owner->buffer.p_audio )
1233         {
1234             vlc_mutex_unlock( &p_owner->lock );
1235             break;
1236         }
1237     }
1238 }
1239
1240 static void DecoderDecodeAudio( decoder_t *p_dec, block_t *p_block )
1241 {
1242     decoder_owner_sys_t *p_owner = p_dec->p_owner;
1243     input_thread_t  *p_input = p_owner->p_input;
1244     aout_buffer_t   *p_aout_buf;
1245     int i_decoded = 0;
1246     int i_lost = 0;
1247     int i_played = 0;
1248
1249     while( (p_aout_buf = p_dec->pf_decode_audio( p_dec, &p_block )) )
1250     {
1251         aout_instance_t *p_aout = p_owner->p_aout;
1252         aout_input_t    *p_aout_input = p_owner->p_aout_input;
1253
1254         if( p_dec->b_die )
1255         {
1256             /* It prevent freezing VLC in case of broken decoder */
1257             aout_DecDeleteBuffer( p_aout, p_aout_input, p_aout_buf );
1258             if( p_block )
1259                 block_Release( p_block );
1260             break;
1261         }
1262         i_decoded++;
1263
1264         if( p_owner->i_preroll_end > VLC_TS_INVALID &&
1265             p_aout_buf->i_pts < p_owner->i_preroll_end )
1266         {
1267             aout_DecDeleteBuffer( p_aout, p_aout_input, p_aout_buf );
1268             continue;
1269         }
1270
1271         if( p_owner->i_preroll_end > VLC_TS_INVALID )
1272         {
1273             msg_Dbg( p_dec, "End of audio preroll" );
1274             if( p_owner->p_aout && p_owner->p_aout_input )
1275                 aout_DecFlush( p_owner->p_aout, p_owner->p_aout_input );
1276             /* */
1277             p_owner->i_preroll_end = VLC_TS_INVALID;
1278         }
1279
1280         DecoderPlayAudio( p_dec, p_aout_buf, &i_played, &i_lost );
1281     }
1282
1283     /* Update ugly stat */
1284     if( i_decoded > 0 || i_lost > 0 || i_played > 0 )
1285     {
1286         vlc_mutex_lock( &p_input->p->counters.counters_lock);
1287
1288         stats_UpdateInteger( p_dec, p_input->p->counters.p_lost_abuffers,
1289                              i_lost, NULL );
1290         stats_UpdateInteger( p_dec, p_input->p->counters.p_played_abuffers,
1291                              i_played, NULL );
1292         stats_UpdateInteger( p_dec, p_input->p->counters.p_decoded_audio,
1293                              i_decoded, NULL );
1294
1295         vlc_mutex_unlock( &p_input->p->counters.counters_lock);
1296     }
1297 }
1298 static void DecoderGetCc( decoder_t *p_dec, decoder_t *p_dec_cc )
1299 {
1300     decoder_owner_sys_t *p_owner = p_dec->p_owner;
1301     block_t *p_cc;
1302     bool pb_present[4];
1303     bool b_processed = false;
1304     int i;
1305     int i_cc_decoder;
1306
1307     assert( p_dec_cc->pf_get_cc != NULL );
1308
1309     /* Do not try retreiving CC if not wanted (sout) or cannot be retreived */
1310     if( !p_owner->cc.b_supported )
1311         return;
1312
1313     p_cc = p_dec_cc->pf_get_cc( p_dec_cc, pb_present );
1314     if( !p_cc )
1315         return;
1316
1317     vlc_mutex_lock( &p_owner->lock );
1318     for( i = 0, i_cc_decoder = 0; i < 4; i++ )
1319     {
1320         p_owner->cc.pb_present[i] |= pb_present[i];
1321         if( p_owner->cc.pp_decoder[i] )
1322             i_cc_decoder++;
1323     }
1324
1325     for( i = 0; i < 4; i++ )
1326     {
1327         if( !p_owner->cc.pp_decoder[i] )
1328             continue;
1329
1330         if( i_cc_decoder > 1 )
1331             DecoderProcess( p_owner->cc.pp_decoder[i], block_Duplicate( p_cc ) );
1332         else
1333             DecoderProcess( p_owner->cc.pp_decoder[i], p_cc );
1334         i_cc_decoder--;
1335         b_processed = true;
1336     }
1337     vlc_mutex_unlock( &p_owner->lock );
1338
1339     if( !b_processed )
1340         block_Release( p_cc );
1341 }
1342
1343 static void DecoderPlayVideo( decoder_t *p_dec, picture_t *p_picture,
1344                               int *pi_played_sum, int *pi_lost_sum )
1345 {
1346     decoder_owner_sys_t *p_owner = p_dec->p_owner;
1347     vout_thread_t  *p_vout = p_owner->p_vout;
1348     bool b_first_buffered;
1349
1350     if( p_picture->date <= VLC_TS_INVALID )
1351     {
1352         msg_Warn( p_vout, "non-dated video buffer received" );
1353         *pi_lost_sum += 1;
1354         vout_ReleasePicture( p_vout, p_picture );
1355         return;
1356     }
1357
1358     /* */
1359     vlc_mutex_lock( &p_owner->lock );
1360
1361     if( ( p_owner->b_buffering && !p_owner->buffer.b_first ) || p_owner->buffer.p_picture )
1362     {
1363         p_picture->p_next = NULL;
1364
1365         *p_owner->buffer.pp_picture_next = p_picture;
1366         p_owner->buffer.pp_picture_next = &p_picture->p_next;
1367
1368         p_owner->buffer.i_count++;
1369         if( p_owner->buffer.i_count > DECODER_MAX_BUFFERING_COUNT ||
1370             p_picture->date - p_owner->buffer.p_picture->date > DECODER_MAX_BUFFERING_VIDEO_DURATION )
1371         {
1372             p_owner->buffer.b_full = true;
1373             vlc_cond_signal( &p_owner->wait_acknowledge );
1374         }
1375     }
1376     b_first_buffered = p_owner->buffer.p_picture != NULL;
1377
1378     for( ;; b_first_buffered = false )
1379     {
1380         bool b_has_more = false;
1381
1382         bool b_reject;
1383
1384         DecoderWaitUnblock( p_dec, &b_reject );
1385
1386         if( p_owner->b_buffering && !p_owner->buffer.b_first )
1387         {
1388             vlc_mutex_unlock( &p_owner->lock );
1389             return;
1390         }
1391         bool b_buffering_first = p_owner->b_buffering;
1392
1393         /* */
1394         if( p_owner->buffer.p_picture )
1395         {
1396             p_picture = p_owner->buffer.p_picture;
1397
1398             p_owner->buffer.p_picture = p_picture->p_next;
1399             p_owner->buffer.i_count--;
1400
1401             b_has_more = p_owner->buffer.p_picture != NULL;
1402             if( !b_has_more )
1403                 p_owner->buffer.pp_picture_next = &p_owner->buffer.p_picture;
1404         }
1405
1406         /* */
1407         if( b_buffering_first )
1408         {
1409             assert( p_owner->buffer.b_first );
1410             assert( !p_owner->buffer.i_count );
1411             msg_Dbg( p_dec, "Received first picture" );
1412             p_owner->buffer.b_first = false;
1413             p_picture->b_force = true;
1414         }
1415
1416         const bool b_dated = p_picture->date > VLC_TS_INVALID;
1417         int i_rate = INPUT_RATE_DEFAULT;
1418         DecoderFixTs( p_dec, &p_picture->date, NULL, NULL,
1419                       &i_rate, DECODER_BOGUS_VIDEO_DELAY, false );
1420
1421         vlc_mutex_unlock( &p_owner->lock );
1422
1423         /* */
1424         if( !p_picture->b_force && p_picture->date <= VLC_TS_INVALID ) // FIXME --VLC_TS_INVALID verify video_output/*
1425             b_reject = true;
1426
1427         if( !b_reject )
1428         {
1429             if( i_rate != p_owner->i_last_rate || b_first_buffered )
1430             {
1431                 /* Be sure to not display old picture after our own */
1432                 vout_Flush( p_vout, p_picture->date );
1433                 p_owner->i_last_rate = i_rate;
1434             }
1435             vout_PutPicture( p_vout, p_picture );
1436         }
1437         else
1438         {
1439             if( b_dated )
1440                 msg_Warn( p_vout, "early picture skipped" );
1441             else
1442                 msg_Warn( p_vout, "non-dated video buffer received" );
1443
1444             *pi_lost_sum += 1;
1445             vout_ReleasePicture( p_vout, p_picture );
1446         }
1447         int i_tmp_display;
1448         int i_tmp_lost;
1449         vout_GetResetStatistic( p_vout, &i_tmp_display, &i_tmp_lost );
1450
1451         *pi_played_sum += i_tmp_display;
1452         *pi_lost_sum += i_tmp_lost;
1453
1454         if( !b_has_more || b_buffering_first )
1455             break;
1456
1457         vlc_mutex_lock( &p_owner->lock );
1458         if( !p_owner->buffer.p_picture )
1459         {
1460             vlc_mutex_unlock( &p_owner->lock );
1461             break;
1462         }
1463     }
1464 }
1465
1466 static void DecoderDecodeVideo( decoder_t *p_dec, block_t *p_block )
1467 {
1468     decoder_owner_sys_t *p_owner = p_dec->p_owner;
1469     input_thread_t *p_input = p_owner->p_input;
1470     picture_t      *p_pic;
1471     int i_lost = 0;
1472     int i_decoded = 0;
1473     int i_displayed = 0;
1474
1475     while( (p_pic = p_dec->pf_decode_video( p_dec, &p_block )) )
1476     {
1477         vout_thread_t  *p_vout = p_owner->p_vout;
1478         if( p_dec->b_die )
1479         {
1480             /* It prevent freezing VLC in case of broken decoder */
1481             vout_ReleasePicture( p_vout, p_pic );
1482             if( p_block )
1483                 block_Release( p_block );
1484             break;
1485         }
1486
1487         i_decoded++;
1488
1489         if( p_owner->i_preroll_end > VLC_TS_INVALID && p_pic->date < p_owner->i_preroll_end )
1490         {
1491             vout_ReleasePicture( p_vout, p_pic );
1492             continue;
1493         }
1494
1495         if( p_owner->i_preroll_end > VLC_TS_INVALID )
1496         {
1497             msg_Dbg( p_dec, "End of video preroll" );
1498             if( p_vout )
1499                 vout_Flush( p_vout, VLC_TS_INVALID+1 );
1500             /* */
1501             p_owner->i_preroll_end = VLC_TS_INVALID;
1502         }
1503
1504         if( p_dec->pf_get_cc &&
1505             ( !p_owner->p_packetizer || !p_owner->p_packetizer->pf_get_cc ) )
1506             DecoderGetCc( p_dec, p_dec );
1507
1508         DecoderPlayVideo( p_dec, p_pic, &i_displayed, &i_lost );
1509     }
1510     if( i_decoded > 0 || i_lost > 0 || i_displayed > 0 )
1511     {
1512         vlc_mutex_lock( &p_input->p->counters.counters_lock );
1513
1514         stats_UpdateInteger( p_dec, p_input->p->counters.p_decoded_video,
1515                              i_decoded, NULL );
1516         stats_UpdateInteger( p_dec, p_input->p->counters.p_lost_pictures,
1517                              i_lost , NULL);
1518
1519         stats_UpdateInteger( p_dec, p_input->p->counters.p_displayed_pictures,
1520                              i_displayed, NULL);
1521
1522         vlc_mutex_unlock( &p_input->p->counters.counters_lock );
1523     }
1524 }
1525
1526 static void DecoderPlaySpu( decoder_t *p_dec, subpicture_t *p_subpic,
1527                             bool b_telx )
1528 {
1529     decoder_owner_sys_t *p_owner = p_dec->p_owner;
1530     vout_thread_t *p_vout = p_owner->p_spu_vout;
1531
1532     /* */
1533     if( p_subpic->i_start <= VLC_TS_INVALID && !b_telx )
1534     {
1535         msg_Warn( p_dec, "non-dated spu buffer received" );
1536         subpicture_Delete( p_subpic );
1537         return;
1538     }
1539
1540     /* */
1541     vlc_mutex_lock( &p_owner->lock );
1542
1543     if( p_owner->b_buffering || p_owner->buffer.p_subpic )
1544     {
1545         p_subpic->p_next = NULL;
1546
1547         *p_owner->buffer.pp_subpic_next = p_subpic;
1548         p_owner->buffer.pp_subpic_next = &p_subpic->p_next;
1549
1550         p_owner->buffer.i_count++;
1551         /* XXX it is important to be full after the first one */
1552         if( p_owner->buffer.i_count > 0 )
1553         {
1554             p_owner->buffer.b_full = true;
1555             vlc_cond_signal( &p_owner->wait_acknowledge );
1556         }
1557     }
1558
1559     for( ;; )
1560     {
1561         bool b_has_more = false;
1562         bool b_reject;
1563         DecoderWaitUnblock( p_dec, &b_reject );
1564
1565         if( p_owner->b_buffering )
1566         {
1567             vlc_mutex_unlock( &p_owner->lock );
1568             return;
1569         }
1570
1571         /* */
1572         if( p_owner->buffer.p_subpic )
1573         {
1574             p_subpic = p_owner->buffer.p_subpic;
1575
1576             p_owner->buffer.p_subpic = p_subpic->p_next;
1577             p_owner->buffer.i_count--;
1578
1579             b_has_more = p_owner->buffer.p_subpic != NULL;
1580             if( !b_has_more )
1581                 p_owner->buffer.pp_subpic_next = &p_owner->buffer.p_subpic;
1582         }
1583
1584         /* */
1585         DecoderFixTs( p_dec, &p_subpic->i_start, &p_subpic->i_stop, NULL,
1586                       NULL, INT64_MAX, b_telx );
1587
1588         vlc_mutex_unlock( &p_owner->lock );
1589
1590         if( p_subpic->i_start <= VLC_TS_INVALID )
1591             b_reject = true;
1592
1593         DecoderWaitDate( p_dec, &b_reject,
1594                          p_subpic->i_start - SPU_MAX_PREPARE_TIME );
1595
1596         if( !b_reject )
1597             vout_PutSubpicture( p_vout, p_subpic );
1598         else
1599             subpicture_Delete( p_subpic );
1600
1601         if( !b_has_more )
1602             break;
1603         vlc_mutex_lock( &p_owner->lock );
1604         if( !p_owner->buffer.p_subpic )
1605         {
1606             vlc_mutex_unlock( &p_owner->lock );
1607             break;
1608         }
1609     }
1610 }
1611
1612 static void DecoderPlaySout( decoder_t *p_dec, block_t *p_sout_block,
1613                              bool b_telx )
1614 {
1615     decoder_owner_sys_t *p_owner = p_dec->p_owner;
1616
1617     assert( p_owner->p_clock );
1618     assert( !p_sout_block->p_next );
1619
1620     vlc_mutex_lock( &p_owner->lock );
1621
1622     if( p_owner->b_buffering || p_owner->buffer.p_block )
1623     {
1624         block_ChainLastAppend( &p_owner->buffer.pp_block_next, p_sout_block );
1625
1626         p_owner->buffer.i_count++;
1627         /* XXX it is important to be full after the first one */
1628         if( p_owner->buffer.i_count > 0 )
1629         {
1630             p_owner->buffer.b_full = true;
1631             vlc_cond_signal( &p_owner->wait_acknowledge );
1632         }
1633     }
1634
1635     for( ;; )
1636     {
1637         bool b_has_more = false;
1638         bool b_reject;
1639         DecoderWaitUnblock( p_dec, &b_reject );
1640
1641         if( p_owner->b_buffering )
1642         {
1643             vlc_mutex_unlock( &p_owner->lock );
1644             return;
1645         }
1646
1647         /* */
1648         if( p_owner->buffer.p_block )
1649         {
1650             p_sout_block = p_owner->buffer.p_block;
1651
1652             p_owner->buffer.p_block = p_sout_block->p_next;
1653             p_owner->buffer.i_count--;
1654
1655             b_has_more = p_owner->buffer.p_block != NULL;
1656             if( !b_has_more )
1657                 p_owner->buffer.pp_block_next = &p_owner->buffer.p_block;
1658         }
1659         p_sout_block->p_next = NULL;
1660
1661         DecoderFixTs( p_dec, &p_sout_block->i_dts, &p_sout_block->i_pts,
1662                       &p_sout_block->i_length,
1663                       &p_sout_block->i_rate, INT64_MAX, b_telx );
1664
1665         vlc_mutex_unlock( &p_owner->lock );
1666
1667         if( !b_reject )
1668             sout_InputSendBuffer( p_owner->p_sout_input, p_sout_block ); // FIXME --VLC_TS_INVALID inspect stream_output/*
1669         else
1670             block_Release( p_sout_block );
1671
1672         if( !b_has_more )
1673             break;
1674         vlc_mutex_lock( &p_owner->lock );
1675         if( !p_owner->buffer.p_block )
1676         {
1677             vlc_mutex_unlock( &p_owner->lock );
1678             break;
1679         }
1680     }
1681 }
1682
1683 /* */
1684 static void DecoderFlushBuffering( decoder_t *p_dec )
1685 {
1686     decoder_owner_sys_t *p_owner = p_dec->p_owner;
1687
1688     vlc_assert_locked( &p_owner->lock );
1689
1690     while( p_owner->buffer.p_picture )
1691     {
1692         picture_t *p_picture = p_owner->buffer.p_picture;
1693
1694         p_owner->buffer.p_picture = p_picture->p_next;
1695         p_owner->buffer.i_count--;
1696
1697         if( p_owner->p_vout )
1698         {
1699             vout_ReleasePicture( p_owner->p_vout, p_picture );
1700         }
1701
1702         if( !p_owner->buffer.p_picture )
1703             p_owner->buffer.pp_picture_next = &p_owner->buffer.p_picture;
1704     }
1705     while( p_owner->buffer.p_audio )
1706     {
1707         aout_buffer_t *p_audio = p_owner->buffer.p_audio;
1708
1709         p_owner->buffer.p_audio = p_audio->p_next;
1710         p_owner->buffer.i_count--;
1711
1712         aout_BufferFree( p_audio );
1713
1714         if( !p_owner->buffer.p_audio )
1715             p_owner->buffer.pp_audio_next = &p_owner->buffer.p_audio;
1716     }
1717     while( p_owner->buffer.p_subpic )
1718     {
1719         subpicture_t *p_subpic = p_owner->buffer.p_subpic;
1720
1721         p_owner->buffer.p_subpic = p_subpic->p_next;
1722         p_owner->buffer.i_count--;
1723
1724         subpicture_Delete( p_subpic );
1725
1726         if( !p_owner->buffer.p_subpic )
1727             p_owner->buffer.pp_subpic_next = &p_owner->buffer.p_subpic;
1728     }
1729     if( p_owner->buffer.p_block )
1730     {
1731         block_ChainRelease( p_owner->buffer.p_block );
1732
1733         p_owner->buffer.i_count = 0;
1734         p_owner->buffer.p_block = NULL;
1735         p_owner->buffer.pp_block_next = &p_owner->buffer.p_block;
1736     }
1737 }
1738
1739 /* This function process a block for sout
1740  */
1741 static void DecoderProcessSout( decoder_t *p_dec, block_t *p_block )
1742 {
1743     decoder_owner_sys_t *p_owner = (decoder_owner_sys_t *)p_dec->p_owner;
1744     const bool b_telx = p_dec->fmt_in.i_codec == VLC_CODEC_TELETEXT;
1745     block_t *p_sout_block;
1746
1747     while( ( p_sout_block =
1748                  p_dec->pf_packetize( p_dec, p_block ? &p_block : NULL ) ) )
1749     {
1750         if( !p_owner->p_sout_input )
1751         {
1752             es_format_Copy( &p_owner->sout, &p_dec->fmt_out );
1753
1754             p_owner->sout.i_group = p_dec->fmt_in.i_group;
1755             p_owner->sout.i_id = p_dec->fmt_in.i_id;
1756             if( p_dec->fmt_in.psz_language )
1757             {
1758                 free( p_owner->sout.psz_language );
1759                 p_owner->sout.psz_language =
1760                     strdup( p_dec->fmt_in.psz_language );
1761             }
1762
1763             p_owner->p_sout_input =
1764                 sout_InputNew( p_owner->p_sout,
1765                                &p_owner->sout );
1766
1767             if( p_owner->p_sout_input == NULL )
1768             {
1769                 msg_Err( p_dec, "cannot create packetizer output (%4.4s)",
1770                          (char *)&p_owner->sout.i_codec );
1771                 p_dec->b_error = true;
1772
1773                 while( p_sout_block )
1774                 {
1775                     block_t *p_next = p_sout_block->p_next;
1776                     block_Release( p_sout_block );
1777                     p_sout_block = p_next;
1778                 }
1779                 break;
1780             }
1781         }
1782
1783         while( p_sout_block )
1784         {
1785             block_t *p_next = p_sout_block->p_next;
1786
1787             p_sout_block->p_next = NULL;
1788
1789             DecoderPlaySout( p_dec, p_sout_block, b_telx );
1790
1791             p_sout_block = p_next;
1792         }
1793     }
1794 }
1795
1796 /* This function process a video block
1797  */
1798 static void DecoderProcessVideo( decoder_t *p_dec, block_t *p_block, bool b_flush )
1799 {
1800     decoder_owner_sys_t *p_owner = (decoder_owner_sys_t *)p_dec->p_owner;
1801
1802     if( p_owner->p_packetizer )
1803     {
1804         block_t *p_packetized_block;
1805         decoder_t *p_packetizer = p_owner->p_packetizer;
1806
1807         while( (p_packetized_block =
1808                 p_packetizer->pf_packetize( p_packetizer, p_block ? &p_block : NULL )) )
1809         {
1810             if( p_packetizer->fmt_out.i_extra && !p_dec->fmt_in.i_extra )
1811             {
1812                 es_format_Clean( &p_dec->fmt_in );
1813                 es_format_Copy( &p_dec->fmt_in, &p_packetizer->fmt_out );
1814             }
1815             if( p_packetizer->pf_get_cc )
1816                 DecoderGetCc( p_dec, p_packetizer );
1817
1818             while( p_packetized_block )
1819             {
1820                 block_t *p_next = p_packetized_block->p_next;
1821                 p_packetized_block->p_next = NULL;
1822
1823                 DecoderDecodeVideo( p_dec, p_packetized_block );
1824
1825                 p_packetized_block = p_next;
1826             }
1827         }
1828         /* The packetizer does not output a block that tell the decoder to flush
1829          * do it ourself */
1830         if( b_flush )
1831         {
1832             block_t *p_null = DecoderBlockFlushNew();
1833             if( p_null )
1834                 DecoderDecodeVideo( p_dec, p_null );
1835         }
1836     }
1837     else if( p_block )
1838     {
1839         DecoderDecodeVideo( p_dec, p_block );
1840     }
1841
1842     if( b_flush && p_owner->p_vout )
1843         vout_Flush( p_owner->p_vout, VLC_TS_INVALID+1 );
1844 }
1845
1846 /* This function process a audio block
1847  */
1848 static void DecoderProcessAudio( decoder_t *p_dec, block_t *p_block, bool b_flush )
1849 {
1850     decoder_owner_sys_t *p_owner = (decoder_owner_sys_t *)p_dec->p_owner;
1851
1852     if( p_owner->p_packetizer )
1853     {
1854         block_t *p_packetized_block;
1855         decoder_t *p_packetizer = p_owner->p_packetizer;
1856
1857         while( (p_packetized_block =
1858                 p_packetizer->pf_packetize( p_packetizer, p_block ? &p_block : NULL )) )
1859         {
1860             if( p_packetizer->fmt_out.i_extra && !p_dec->fmt_in.i_extra )
1861             {
1862                 es_format_Clean( &p_dec->fmt_in );
1863                 es_format_Copy( &p_dec->fmt_in, &p_packetizer->fmt_out );
1864             }
1865
1866             while( p_packetized_block )
1867             {
1868                 block_t *p_next = p_packetized_block->p_next;
1869                 p_packetized_block->p_next = NULL;
1870
1871                 DecoderDecodeAudio( p_dec, p_packetized_block );
1872
1873                 p_packetized_block = p_next;
1874             }
1875         }
1876         /* The packetizer does not output a block that tell the decoder to flush
1877          * do it ourself */
1878         if( b_flush )
1879         {
1880             block_t *p_null = DecoderBlockFlushNew();
1881             if( p_null )
1882                 DecoderDecodeAudio( p_dec, p_null );
1883         }
1884     }
1885     else if( p_block )
1886     {
1887         DecoderDecodeAudio( p_dec, p_block );
1888     }
1889
1890     if( b_flush && p_owner->p_aout && p_owner->p_aout_input )
1891         aout_DecFlush( p_owner->p_aout, p_owner->p_aout_input );
1892 }
1893
1894 /* This function process a subtitle block
1895  */
1896 static void DecoderProcessSpu( decoder_t *p_dec, block_t *p_block, bool b_flush )
1897 {
1898     decoder_owner_sys_t *p_owner = p_dec->p_owner;
1899     const bool b_telx = p_dec->fmt_in.i_codec == VLC_CODEC_TELETEXT;
1900
1901     input_thread_t *p_input = p_owner->p_input;
1902     vout_thread_t *p_vout;
1903     subpicture_t *p_spu;
1904
1905     while( (p_spu = p_dec->pf_decode_sub( p_dec, p_block ? &p_block : NULL ) ) )
1906     {
1907         vlc_mutex_lock( &p_input->p->counters.counters_lock );
1908         stats_UpdateInteger( p_dec, p_input->p->counters.p_decoded_sub, 1, NULL );
1909         vlc_mutex_unlock( &p_input->p->counters.counters_lock );
1910
1911         p_vout = input_resource_HoldVout( p_input->p->p_resource );
1912         if( p_vout && p_owner->p_spu_vout == p_vout )
1913         {
1914             /* Preroll does not work very well with subtitle */
1915             if( p_spu->i_start > VLC_TS_INVALID &&
1916                 p_spu->i_start < p_owner->i_preroll_end &&
1917                 ( p_spu->i_stop <= VLC_TS_INVALID || p_spu->i_stop < p_owner->i_preroll_end ) )
1918             {
1919                 subpicture_Delete( p_spu );
1920             }
1921             else
1922             {
1923                 DecoderPlaySpu( p_dec, p_spu, b_telx );
1924             }
1925         }
1926         else
1927         {
1928             subpicture_Delete( p_spu );
1929         }
1930         if( p_vout )
1931             vlc_object_release( p_vout );
1932     }
1933
1934     if( b_flush && p_owner->p_spu_vout )
1935     {
1936         p_vout = input_resource_HoldVout( p_input->p->p_resource );
1937
1938         if( p_vout && p_owner->p_spu_vout == p_vout )
1939             vout_FlushSubpictureChannel( p_vout, p_owner->i_spu_channel );
1940
1941         if( p_vout )
1942             vlc_object_release( p_vout );
1943     }
1944 }
1945
1946 /* */
1947 static void DecoderProcessOnFlush( decoder_t *p_dec )
1948 {
1949     decoder_owner_sys_t *p_owner = p_dec->p_owner;
1950
1951     vlc_mutex_lock( &p_owner->lock );
1952     DecoderFlushBuffering( p_dec );
1953
1954     if( p_owner->b_flushing )
1955     {
1956         p_owner->b_flushing = false;
1957         vlc_cond_signal( &p_owner->wait_acknowledge );
1958     }
1959     vlc_mutex_unlock( &p_owner->lock );
1960 }
1961
1962 /**
1963  * Decode a block
1964  *
1965  * \param p_dec the decoder object
1966  * \param p_block the block to decode
1967  * \return VLC_SUCCESS or an error code
1968  */
1969 static void DecoderProcess( decoder_t *p_dec, block_t *p_block )
1970 {
1971     decoder_owner_sys_t *p_owner = (decoder_owner_sys_t *)p_dec->p_owner;
1972     const bool b_flush_request = p_block && (p_block->i_flags & BLOCK_FLAG_CORE_FLUSH);
1973
1974     if( p_block && p_block->i_buffer <= 0 )
1975     {
1976         assert( !b_flush_request );
1977         block_Release( p_block );
1978         return;
1979     }
1980
1981 #ifdef ENABLE_SOUT
1982     if( p_owner->b_packetizer )
1983     {
1984         if( p_block )
1985             p_block->i_flags &= ~BLOCK_FLAG_CORE_PRIVATE_MASK;
1986
1987         DecoderProcessSout( p_dec, p_block );
1988     }
1989     else
1990 #endif
1991     {
1992         bool b_flush = false;
1993
1994         if( p_block )
1995         {
1996             const bool b_flushing = p_owner->i_preroll_end == INT64_MAX;
1997             DecoderUpdatePreroll( &p_owner->i_preroll_end, p_block );
1998
1999             b_flush = !b_flushing && b_flush_request;
2000
2001             p_block->i_flags &= ~BLOCK_FLAG_CORE_PRIVATE_MASK;
2002         }
2003
2004         if( p_dec->fmt_out.i_cat == AUDIO_ES )
2005         {
2006             DecoderProcessAudio( p_dec, p_block, b_flush );
2007         }
2008         else if( p_dec->fmt_out.i_cat == VIDEO_ES )
2009         {
2010             DecoderProcessVideo( p_dec, p_block, b_flush );
2011         }
2012         else if( p_dec->fmt_out.i_cat == SPU_ES )
2013         {
2014             DecoderProcessSpu( p_dec, p_block, b_flush );
2015         }
2016         else
2017         {
2018             msg_Err( p_dec, "unknown ES format" );
2019             p_dec->b_error = true;
2020         }
2021     }
2022
2023     /* */
2024     if( b_flush_request )
2025         DecoderProcessOnFlush( p_dec );
2026 }
2027
2028 static void DecoderError( decoder_t *p_dec, block_t *p_block )
2029 {
2030     const bool b_flush_request = p_block && (p_block->i_flags & BLOCK_FLAG_CORE_FLUSH);
2031
2032     /* */
2033     if( p_block )
2034         block_Release( p_block );
2035
2036     if( b_flush_request )
2037         DecoderProcessOnFlush( p_dec );
2038 }
2039
2040
2041 /**
2042  * Destroys a decoder object
2043  *
2044  * \param p_dec the decoder object
2045  * \return nothing
2046  */
2047 static void DeleteDecoder( decoder_t * p_dec )
2048 {
2049     decoder_owner_sys_t *p_owner = p_dec->p_owner;
2050
2051     msg_Dbg( p_dec, "killing decoder fourcc `%4.4s', %u PES in FIFO",
2052              (char*)&p_dec->fmt_in.i_codec,
2053              (unsigned)block_FifoCount( p_owner->p_fifo ) );
2054
2055     /* Free all packets still in the decoder fifo. */
2056     block_FifoEmpty( p_owner->p_fifo );
2057     block_FifoRelease( p_owner->p_fifo );
2058
2059     /* */
2060     vlc_mutex_lock( &p_owner->lock );
2061     DecoderFlushBuffering( p_dec );
2062     vlc_mutex_unlock( &p_owner->lock );
2063
2064     /* Cleanup */
2065     if( p_owner->p_aout_input )
2066         aout_DecDelete( p_owner->p_aout, p_owner->p_aout_input );
2067     if( p_owner->p_aout )
2068     {
2069         input_resource_RequestAout( p_owner->p_input->p->p_resource,
2070                                      p_owner->p_aout );
2071         input_SendEventAout( p_owner->p_input );
2072         p_owner->p_aout = NULL;
2073     }
2074     if( p_owner->p_vout )
2075     {
2076         /* Hack to make sure all the the pictures are freed by the decoder
2077          * and that the vout is not paused anymore */
2078         vout_Reset( p_owner->p_vout );
2079
2080         /* */
2081         input_resource_RequestVout( p_owner->p_input->p->p_resource, p_owner->p_vout, NULL, 0, true );
2082         input_SendEventVout( p_owner->p_input );
2083     }
2084
2085 #ifdef ENABLE_SOUT
2086     if( p_owner->p_sout_input )
2087     {
2088         sout_InputDelete( p_owner->p_sout_input );
2089         es_format_Clean( &p_owner->sout );
2090     }
2091 #endif
2092
2093     if( p_dec->fmt_out.i_cat == SPU_ES )
2094     {
2095         vout_thread_t *p_vout;
2096
2097         p_vout = input_resource_HoldVout( p_owner->p_input->p->p_resource );
2098         if( p_vout )
2099         {
2100             if( p_owner->p_spu_vout == p_vout )
2101                 vout_FlushSubpictureChannel( p_vout, p_owner->i_spu_channel );
2102             vlc_object_release( p_vout );
2103         }
2104     }
2105
2106     es_format_Clean( &p_dec->fmt_in );
2107     es_format_Clean( &p_dec->fmt_out );
2108     if( p_dec->p_description )
2109         vlc_meta_Delete( p_dec->p_description );
2110     es_format_Clean( &p_owner->fmt_description );
2111     if( p_owner->p_description )
2112         vlc_meta_Delete( p_owner->p_description );
2113
2114     if( p_owner->p_packetizer )
2115     {
2116         module_unneed( p_owner->p_packetizer,
2117                        p_owner->p_packetizer->p_module );
2118         es_format_Clean( &p_owner->p_packetizer->fmt_in );
2119         es_format_Clean( &p_owner->p_packetizer->fmt_out );
2120         if( p_owner->p_packetizer->p_description )
2121             vlc_meta_Delete( p_owner->p_packetizer->p_description );
2122         vlc_object_release( p_owner->p_packetizer );
2123     }
2124
2125     vlc_cond_destroy( &p_owner->wait_acknowledge );
2126     vlc_cond_destroy( &p_owner->wait_request );
2127     vlc_mutex_destroy( &p_owner->lock );
2128
2129     vlc_object_release( p_dec );
2130
2131     free( p_owner );
2132 }
2133
2134 /*****************************************************************************
2135  * Buffers allocation callbacks for the decoders
2136  *****************************************************************************/
2137 static void DecoderUpdateFormatLocked( decoder_t *p_dec )
2138 {
2139     decoder_owner_sys_t *p_owner = p_dec->p_owner;
2140
2141     vlc_assert_locked( &p_owner->lock );
2142
2143     p_owner->b_fmt_description = true;
2144
2145     /* Copy es_format */
2146     es_format_Clean( &p_owner->fmt_description );
2147     es_format_Copy( &p_owner->fmt_description, &p_dec->fmt_out );
2148
2149     /* Move p_description */
2150     if( p_owner->p_description && p_dec->p_description )
2151         vlc_meta_Delete( p_owner->p_description );
2152     p_owner->p_description = p_dec->p_description;
2153     p_dec->p_description = NULL;
2154 }
2155 static vout_thread_t *aout_request_vout( void *p_private,
2156                                          vout_thread_t *p_vout, video_format_t *p_fmt, bool b_recyle )
2157 {
2158     decoder_t *p_dec = p_private;
2159     input_thread_t *p_input = p_dec->p_owner->p_input;
2160
2161     p_vout = input_resource_RequestVout( p_input->p->p_resource, p_vout, p_fmt, 1, b_recyle );
2162     input_SendEventVout( p_input );
2163
2164     return p_vout;
2165 }
2166
2167 static aout_buffer_t *aout_new_buffer( decoder_t *p_dec, int i_samples )
2168 {
2169     decoder_owner_sys_t *p_owner = p_dec->p_owner;
2170     aout_buffer_t *p_buffer;
2171
2172     if( p_owner->p_aout_input != NULL &&
2173         ( p_dec->fmt_out.audio.i_rate != p_owner->audio.i_rate ||
2174           p_dec->fmt_out.audio.i_original_channels !=
2175               p_owner->audio.i_original_channels ||
2176           p_dec->fmt_out.audio.i_bytes_per_frame !=
2177               p_owner->audio.i_bytes_per_frame ) )
2178     {
2179         aout_input_t *p_aout_input = p_owner->p_aout_input;
2180
2181         /* Parameters changed, restart the aout */
2182         vlc_mutex_lock( &p_owner->lock );
2183
2184         DecoderFlushBuffering( p_dec );
2185
2186         p_owner->p_aout_input = NULL;
2187         aout_DecDelete( p_owner->p_aout, p_aout_input );
2188
2189         vlc_mutex_unlock( &p_owner->lock );
2190     }
2191
2192     if( p_owner->p_aout_input == NULL )
2193     {
2194         const int i_force_dolby = var_InheritInteger( p_dec, "force-dolby-surround" );
2195         audio_sample_format_t format;
2196         aout_input_t *p_aout_input;
2197         aout_instance_t *p_aout;
2198         aout_request_vout_t request_vout;
2199
2200         p_dec->fmt_out.audio.i_format = p_dec->fmt_out.i_codec;
2201         p_owner->audio = p_dec->fmt_out.audio;
2202
2203         memcpy( &format, &p_owner->audio, sizeof( audio_sample_format_t ) );
2204         if( i_force_dolby &&
2205             (format.i_original_channels&AOUT_CHAN_PHYSMASK) ==
2206                 (AOUT_CHAN_LEFT|AOUT_CHAN_RIGHT) )
2207         {
2208             if( i_force_dolby == 1 )
2209             {
2210                 format.i_original_channels = format.i_original_channels |
2211                                              AOUT_CHAN_DOLBYSTEREO;
2212             }
2213             else /* i_force_dolby == 2 */
2214             {
2215                 format.i_original_channels = format.i_original_channels &
2216                                              ~AOUT_CHAN_DOLBYSTEREO;
2217             }
2218         }
2219
2220         request_vout.pf_request_vout = aout_request_vout;
2221         request_vout.p_private = p_dec;
2222
2223         p_aout = p_owner->p_aout;
2224         if( !p_aout )
2225             p_aout = input_resource_RequestAout( p_owner->p_input->p->p_resource, NULL );
2226         p_aout_input = aout_DecNew( p_dec, &p_aout,
2227                                     &format, &p_dec->fmt_out.audio_replay_gain, &request_vout );
2228
2229         vlc_mutex_lock( &p_owner->lock );
2230
2231         p_owner->p_aout = p_aout;
2232         p_owner->p_aout_input = p_aout_input;
2233         DecoderUpdateFormatLocked( p_dec );
2234
2235         vlc_mutex_unlock( &p_owner->lock );
2236
2237         input_SendEventAout( p_owner->p_input );
2238
2239         if( p_owner->p_aout_input == NULL )
2240         {
2241             msg_Err( p_dec, "failed to create audio output" );
2242             p_dec->b_error = true;
2243             return NULL;
2244         }
2245         p_dec->fmt_out.audio.i_bytes_per_frame =
2246             p_owner->audio.i_bytes_per_frame;
2247     }
2248
2249     p_buffer = aout_DecNewBuffer( p_owner->p_aout_input, i_samples );
2250
2251     return p_buffer;
2252 }
2253
2254 static void aout_del_buffer( decoder_t *p_dec, aout_buffer_t *p_buffer )
2255 {
2256     decoder_owner_sys_t *p_owner = p_dec->p_owner;
2257
2258     aout_DecDeleteBuffer( p_owner->p_aout,
2259                           p_owner->p_aout_input, p_buffer );
2260 }
2261
2262 static picture_t *vout_new_buffer( decoder_t *p_dec )
2263 {
2264     decoder_owner_sys_t *p_owner = p_dec->p_owner;
2265
2266     if( p_owner->p_vout == NULL ||
2267         p_dec->fmt_out.video.i_width != p_owner->video.i_width ||
2268         p_dec->fmt_out.video.i_height != p_owner->video.i_height ||
2269         p_dec->fmt_out.video.i_visible_width != p_owner->video.i_visible_width ||
2270         p_dec->fmt_out.video.i_visible_height != p_owner->video.i_visible_height ||
2271         p_dec->fmt_out.video.i_x_offset != p_owner->video.i_x_offset  ||
2272         p_dec->fmt_out.video.i_y_offset != p_owner->video.i_y_offset  ||
2273         p_dec->fmt_out.i_codec != p_owner->video.i_chroma ||
2274         (int64_t)p_dec->fmt_out.video.i_sar_num * p_owner->video.i_sar_den !=
2275         (int64_t)p_dec->fmt_out.video.i_sar_den * p_owner->video.i_sar_num )
2276     {
2277         vout_thread_t *p_vout;
2278
2279         if( !p_dec->fmt_out.video.i_width ||
2280             !p_dec->fmt_out.video.i_height )
2281         {
2282             /* Can't create a new vout without display size */
2283             return NULL;
2284         }
2285
2286         video_format_t fmt = p_dec->fmt_out.video;
2287         fmt.i_chroma = p_dec->fmt_out.i_codec;
2288         p_owner->video = fmt;
2289
2290         if( !fmt.i_visible_width || !fmt.i_visible_height )
2291         {
2292             if( p_dec->fmt_in.video.i_visible_width &&
2293                 p_dec->fmt_in.video.i_visible_height )
2294             {
2295                 fmt.i_visible_width  = p_dec->fmt_in.video.i_visible_width;
2296                 fmt.i_visible_height = p_dec->fmt_in.video.i_visible_height;
2297             }
2298             else
2299             {
2300                 fmt.i_visible_width  = fmt.i_width;
2301                 fmt.i_visible_height = fmt.i_height;
2302             }
2303         }
2304
2305         if( fmt.i_visible_height == 1088 &&
2306             var_CreateGetBool( p_dec, "hdtv-fix" ) )
2307         {
2308             fmt.i_visible_height = 1080;
2309             if( !(fmt.i_sar_num % 136))
2310             {
2311                 fmt.i_sar_num *= 135;
2312                 fmt.i_sar_den *= 136;
2313             }
2314             msg_Warn( p_dec, "Fixing broken HDTV stream (display_height=1088)");
2315         }
2316
2317         if( !fmt.i_sar_num || !fmt.i_sar_den )
2318         {
2319             fmt.i_sar_num = 1;
2320             fmt.i_sar_den = 1;
2321         }
2322
2323         vlc_ureduce( &fmt.i_sar_num, &fmt.i_sar_den,
2324                      fmt.i_sar_num, fmt.i_sar_den, 50000 );
2325
2326         vlc_mutex_lock( &p_owner->lock );
2327
2328         DecoderFlushBuffering( p_dec );
2329
2330         p_vout = p_owner->p_vout;
2331         p_owner->p_vout = NULL;
2332         vlc_mutex_unlock( &p_owner->lock );
2333
2334         unsigned dpb_size;
2335         switch( p_dec->fmt_in.i_codec )
2336         {
2337         case VLC_CODEC_H264:
2338         case VLC_CODEC_DIRAC: /* FIXME valid ? */
2339             dpb_size = 18;
2340             break;
2341         case VLC_CODEC_VP5:
2342         case VLC_CODEC_VP6:
2343         case VLC_CODEC_VP6F:
2344         case VLC_CODEC_VP8:
2345             dpb_size = 3;
2346             break;
2347         default:
2348             dpb_size = 2;
2349             break;
2350         }
2351         p_vout = input_resource_RequestVout( p_owner->p_input->p->p_resource,
2352                                              p_vout, &fmt,
2353                                              dpb_size + 1 + DECODER_MAX_BUFFERING_COUNT,
2354                                              true );
2355         vlc_mutex_lock( &p_owner->lock );
2356         p_owner->p_vout = p_vout;
2357
2358         DecoderUpdateFormatLocked( p_dec );
2359
2360         vlc_mutex_unlock( &p_owner->lock );
2361
2362         input_SendEventVout( p_owner->p_input );
2363         if( p_vout == NULL )
2364         {
2365             msg_Err( p_dec, "failed to create video output" );
2366             p_dec->b_error = true;
2367             return NULL;
2368         }
2369     }
2370
2371     /* Get a new picture
2372      */
2373     for( ;; )
2374     {
2375         if( p_dec->b_die || p_dec->b_error )
2376             return NULL;
2377
2378         picture_t *p_picture = vout_GetPicture( p_owner->p_vout );
2379         if( p_picture )
2380             return p_picture;
2381
2382         if( DecoderIsFlushing( p_dec ) )
2383             return NULL;
2384
2385         /* */
2386         DecoderSignalBuffering( p_dec, true );
2387
2388         /* Check the decoder doesn't leak pictures */
2389         vout_FixLeaks( p_owner->p_vout );
2390
2391         /* FIXME add a vout_WaitPictureAvailable (timedwait) */
2392         msleep( VOUT_OUTMEM_SLEEP );
2393     }
2394 }
2395
2396 static void vout_del_buffer( decoder_t *p_dec, picture_t *p_pic )
2397 {
2398     vout_ReleasePicture( p_dec->p_owner->p_vout, p_pic );
2399 }
2400
2401 static void vout_link_picture( decoder_t *p_dec, picture_t *p_pic )
2402 {
2403     vout_HoldPicture( p_dec->p_owner->p_vout, p_pic );
2404 }
2405
2406 static void vout_unlink_picture( decoder_t *p_dec, picture_t *p_pic )
2407 {
2408     vout_ReleasePicture( p_dec->p_owner->p_vout, p_pic );
2409 }
2410
2411 static subpicture_t *spu_new_buffer( decoder_t *p_dec,
2412                                      const subpicture_updater_t *p_updater )
2413 {
2414     decoder_owner_sys_t *p_owner = p_dec->p_owner;
2415     vout_thread_t *p_vout = NULL;
2416     subpicture_t *p_subpic;
2417     int i_attempts = 30;
2418
2419     while( i_attempts-- )
2420     {
2421         if( p_dec->b_die || p_dec->b_error )
2422             break;
2423
2424         p_vout = input_resource_HoldVout( p_owner->p_input->p->p_resource );
2425         if( p_vout )
2426             break;
2427
2428         msleep( DECODER_SPU_VOUT_WAIT_DURATION );
2429     }
2430
2431     if( !p_vout )
2432     {
2433         msg_Warn( p_dec, "no vout found, dropping subpicture" );
2434         return NULL;
2435     }
2436
2437     if( p_owner->p_spu_vout != p_vout )
2438     {
2439         vlc_mutex_lock( &p_owner->lock );
2440
2441         DecoderFlushBuffering( p_dec );
2442
2443         vlc_mutex_unlock( &p_owner->lock );
2444
2445         p_owner->i_spu_channel = vout_RegisterSubpictureChannel( p_vout );
2446         p_owner->i_spu_order = 0;
2447         p_owner->p_spu_vout = p_vout;
2448     }
2449
2450     p_subpic = subpicture_New( p_updater );
2451     if( p_subpic )
2452     {
2453         p_subpic->i_channel = p_owner->i_spu_channel;
2454         p_subpic->i_order = p_owner->i_spu_order++;
2455         p_subpic->b_subtitle = true;
2456     }
2457
2458     vlc_object_release( p_vout );
2459
2460     return p_subpic;
2461 }
2462
2463 static void spu_del_buffer( decoder_t *p_dec, subpicture_t *p_subpic )
2464 {
2465     decoder_owner_sys_t *p_owner = p_dec->p_owner;
2466     vout_thread_t *p_vout = NULL;
2467
2468     p_vout = input_resource_HoldVout( p_owner->p_input->p->p_resource );
2469     if( !p_vout || p_owner->p_spu_vout != p_vout )
2470     {
2471         if( p_vout )
2472             vlc_object_release( p_vout );
2473         msg_Warn( p_dec, "no vout found, leaking subpicture" );
2474         return;
2475     }
2476
2477     subpicture_Delete( p_subpic );
2478
2479     vlc_object_release( p_vout );
2480 }
2481