VLC  4.0.0-dev
vlc_codec.h
Go to the documentation of this file.
1 /*****************************************************************************
2  * vlc_codec.h: Definition of the decoder and encoder structures
3  *****************************************************************************
4  * Copyright (C) 1999-2003 VLC authors and VideoLAN
5  *
6  * Authors: Gildas Bazin <gbazin@netcourrier.com>
7  *
8  * This program is free software; you can redistribute it and/or modify it
9  * under the terms of the GNU Lesser General Public License as published by
10  * the Free Software Foundation; either version 2.1 of the License, or
11  * (at your option) any later version.
12  *
13  * This program is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16  * GNU Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public License
19  * along with this program; if not, write to the Free Software Foundation,
20  * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
21  *****************************************************************************/
22 
23 #ifndef VLC_CODEC_H
24 #define VLC_CODEC_H 1
25 
26 #include <assert.h>
27 
28 #include <vlc_block.h>
29 #include <vlc_es.h>
30 #include <vlc_vout_window.h>
31 #include <vlc_picture.h>
32 #include <vlc_subpicture.h>
33 
34 /**
35  * \defgroup decoder Decoder
36  * \ingroup input
37  * Audio, video and text decoders
38  * @{
39  *
40  * \file
41  * Decoder and encoder modules interface
42  */
43 
45 
47 {
48  union
49  {
50  struct
51  {
52  vlc_decoder_device * (*get_device)( decoder_t * );
54 
55  /* cf. decoder_NewPicture, can be called from any decoder thread */
56  picture_t* (*buffer_new)( decoder_t * );
57  /* cf. decoder_AbortPictures */
58  void (*abort_pictures)( decoder_t *, bool b_abort );
59  /* cf.decoder_QueueVideo */
60  void (*queue)( decoder_t *, picture_t * );
61  /* cf.decoder_QueueCC */
62  void (*queue_cc)( decoder_t *, block_t *,
63  const decoder_cc_desc_t * );
64 
65  /* Display date
66  * cf. decoder_GetDisplayDate */
68  /* Display rate
69  * cf. decoder_GetDisplayRate */
70  float (*get_display_rate)( decoder_t * );
71  } video;
72  struct
73  {
74  int (*format_update)( decoder_t * );
75 
76  /* cf.decoder_QueueAudio */
77  void (*queue)( decoder_t *, block_t * );
78  } audio;
79  struct
80  {
81  /* cf. decoder_NewSubpicture */
82  subpicture_t* (*buffer_new)( decoder_t *,
84 
85  /* cf.decoder_QueueSub */
86  void (*queue)( decoder_t *, subpicture_t *);
87  } spu;
88  };
89 
90  /* Input attachments
91  * cf. decoder_GetInputAttachments */
92  int (*get_attachments)( decoder_t *p_dec,
93  input_attachment_t ***ppp_attachment,
94  int *pi_attachment );
95 };
96 
97 /*
98  * BIG FAT WARNING : the code relies in the first 4 members of filter_t
99  * and decoder_t to be the same, so if you have anything to add, do it
100  * at the end of the structure.
101  */
102 struct decoder_t
103 {
104  struct vlc_object_t obj;
106  /* Module properties */
107  module_t * p_module;
108  void *p_sys;
110  /* Input format ie from demuxer (XXX: a lot of field could be invalid) */
111  es_format_t fmt_in;
113  /* Output format of decoder/packetizer */
114  es_format_t fmt_out;
116  /* Tell the decoder if it is allowed to drop frames */
117  bool b_frame_drop_allowed;
119  /**
120  * Number of extra (ie in addition to the DPB) picture buffers
121  * needed for decoding.
122  */
123  int i_extra_picture_buffers;
125  union
126  {
127 # define VLCDEC_SUCCESS VLC_SUCCESS
128 # define VLCDEC_ECRITICAL VLC_EGENERIC
129 # define VLCDEC_RELOAD (-100)
130  /* This function is called to decode one packetized block.
131  *
132  * The module implementation will own the input block (p_block) and should
133  * process and release it. Depending of the decoder type, the module should
134  * send output frames/blocks via decoder_QueueVideo(), decoder_QueueAudio()
135  * or decoder_QueueSub().
136  *
137  * If p_block is NULL, the decoder asks the module to drain itself. The
138  * module should return all available output frames/block via the queue
139  * functions.
140  *
141  * Return values can be:
142  * VLCDEC_SUCCESS: pf_decode will be called again
143  * VLCDEC_ECRITICAL: in case of critical error, pf_decode won't be called
144  * again.
145  * VLCDEC_RELOAD: Request that the decoder should be reloaded. The current
146  * module will be unloaded. Reloading a module may cause a loss of frames.
147  * When returning this status, the implementation shouldn't release or
148  * modify the p_block in argument (The same p_block will be feed to the
149  * next decoder module).
150  */
151  int ( * pf_decode ) ( decoder_t *, block_t *p_block );
153  /* This function is called in a loop with the same pp_block argument until
154  * it returns NULL. This allows a module implementation to return more than
155  * one output blocks for one input block.
156  *
157  * pp_block or *pp_block can be NULL.
158  *
159  * If pp_block and *pp_block are not NULL, the module implementation will
160  * own the input block (*pp_block) and should process and release it. The
161  * module can also process a part of the block. In that case, it should
162  * modify (*pp_block)->p_buffer/i_buffer accordingly and return a valid
163  * output block. The module can also set *pp_block to NULL when the input
164  * block is consumed.
165  *
166  * If pp_block is not NULL but *pp_block is NULL, a previous call of the pf
167  * function has set the *pp_block to NULL. Here, the module can return new
168  * output block for the same, already processed, input block (the
169  * pf_packetize function will be called as long as the module return an
170  * output block).
171  *
172  * When the pf function returns NULL, the next call to this function will
173  * have a new a valid pp_block (if the packetizer is not drained).
174  *
175  * If pp_block is NULL, the packetizer asks the module to drain itself. In
176  * that case, the module has to return all output frames available (the
177  * pf_packetize function will be called as long as the module return an
178  * output block).
179  */
180  block_t * ( * pf_packetize )( decoder_t *, block_t **pp_block );
181  };
182 
183  /* */
184  void ( * pf_flush ) ( decoder_t * );
186  /* Closed Caption (CEA 608/708) extraction.
187  * If set, it *may* be called after pf_packetize returned data. It should
188  * return CC for the pictures returned by the last pf_packetize call only,
189  * channel bitmaps will be used to known which cc channel are present (but
190  * globaly, not necessary for the current packet. Video decoders should use
191  * the decoder_QueueCc() function to pass closed captions. */
192  block_t * ( * pf_get_cc ) ( decoder_t *, decoder_cc_desc_t * );
194  /* Meta data at codec level
195  * The decoder owner set it back to NULL once it has retreived what it needs.
196  * The decoder owner is responsible of its release except when you overwrite it.
197  */
198  vlc_meta_t *p_description;
200  /* Private structure for the owner of the decoder */
201  const struct decoder_owner_callbacks *cbs;
202 };
203 
204 /* struct for packetizer get_cc polling/decoder queue_cc
205  * until we have a proper metadata way */
206 struct decoder_cc_desc_t
207 {
208  uint8_t i_608_channels; /* 608 channels bitmap */
209  uint64_t i_708_channels; /* 708 */
210  int i_reorder_depth; /* reorder depth, -1 for no reorder, 0 for old P/B flag based */
211 };
212 
213 /**
214  * @}
215  */
216 
217 /**
218  * \defgroup encoder Encoder
219  * \ingroup sout
220  * Audio, video and text encoders
221  * @{
222  */
223 
224 struct encoder_t
225 {
226  struct vlc_object_t obj;
228  /* Module properties */
229  module_t * p_module;
230  void *p_sys;
232  /* Properties of the input data fed to the encoder */
233  es_format_t fmt_in;
235  /* Properties of the output of the encoder */
236  es_format_t fmt_out;
238  block_t * ( * pf_encode_video )( encoder_t *, picture_t * );
239  block_t * ( * pf_encode_audio )( encoder_t *, block_t * );
240  block_t * ( * pf_encode_sub )( encoder_t *, subpicture_t * );
242  /* Common encoder options */
243  int i_threads; /* Number of threads to use during encoding */
244  int i_iframes; /* One I frame per i_iframes */
245  int i_bframes; /* One B frame per i_bframes */
246  int i_tolerance; /* Bitrate tolerance */
248  /* Encoder config */
249  config_chain_t *p_cfg;
250 };
251 
252 /**
253  * @}
254  *
255  * \ingroup decoder
256  * @{
257  */
258 
259 /**
260  * Creates/Updates the output decoder device.
261  *
262  * This function notifies the video output pipeline of a new video output
263  * format (fmt_out.video). If there was no decoder device so far or a new
264  * decoder device is required, a new decoder device will be set up.
265  * decoder_UpdateVideoOutput() can then be used.
266  *
267  * If the format is unchanged, this function has no effects and returns zero.
268  *
269  * \param dec the decoder object
270  *
271  * \note
272  * This function is not reentrant.
273  *
274  * @return the received of the held decoder device, NULL not to get one
275  */
277 {
278  vlc_assert( dec->fmt_in.i_cat == VIDEO_ES && dec->cbs != NULL );
279  if ( unlikely(dec->fmt_in.i_cat != VIDEO_ES || dec->cbs == NULL ) )
280  return NULL;
281 
282  if ( dec->cbs->video.get_device == NULL )
283  return NULL; /* TODO make it mandatory for all decoder owners */
284 
285  return dec->cbs->video.get_device( dec );
286 }
287 
288 /**
289  * Creates/Updates the rest of the video output pipeline.
290  *
291  * After a call to decoder_GetDecoderDevice() this function notifies the
292  * video output pipeline of a new video output format (fmt_out.video). If there
293  * was no video output from the decoder so far, a new decoder video output will
294  * be set up. decoder_NewPicture() can then be used to allocate picture buffers.
295  *
296  * If the format is unchanged, this function has no effects and returns zero.
297  *
298  * \note
299  * This function is not reentrant.
300  *
301  * @return 0 if the video output was set up successfully, -1 otherwise.
302  */
304 
305 /**
306  * Updates the video output format.
307  *
308  * This function notifies the video output pipeline of a new video output
309  * format (fmt_out.video). If there was no video output from the decoder so far
310  * or if the video output format has changed, a new video output will be set
311  * up. decoder_NewPicture() can then be used to allocate picture buffers.
312  *
313  * If the format is unchanged, this function has no effects and returns zero.
314  *
315  * \note
316  * This function is not reentrant.
317  *
318  * @return 0 if the video output was set up successfully, -1 otherwise.
319  */
321 
322 /**
323  * Allocates an output picture buffer.
324  *
325  * This function pulls an output picture buffer for the decoder from the
326  * buffer pool of the video output. The picture must be released with
327  * picture_Release() when it is no longer referenced by the decoder.
328  *
329  * \note
330  * This function is reentrant. However, decoder_UpdateVideoFormat() cannot be
331  * used concurrently; the caller is responsible for serialization.
332  *
333  * \warning
334  * The behaviour is undefined if decoder_UpdateVideoFormat() was not called or
335  * if the last call returned an error.
336  *
337  * \return a picture buffer on success, NULL on error
338  */
340 
341 /**
342  * Abort any calls of decoder_NewPicture
343  *
344  * If b_abort is true, all pending and futures calls of decoder_NewPicture
345  * will be aborted. This function can be used by asynchronous video decoders
346  * to unblock a thread that is waiting for a picture.
347  */
348 VLC_API void decoder_AbortPictures( decoder_t *dec, bool b_abort );
349 
350 /**
351  * Initialize a decoder structure before creating the decoder.
352  *
353  * To be used by decoder owners.
354  * By default frame drop is not allowed.
355  */
356 VLC_API void decoder_Init( decoder_t *dec, const es_format_t * );
357 
358 /**
359  * Destroy a decoder and reset the structure.
360  *
361  * To be used by decoder owners.
362  */
363 VLC_API void decoder_Destroy( decoder_t *p_dec );
364 
365 /**
366  * Unload a decoder module and reset the input/output formats.
367  *
368  * To be used by decoder owners.
369  */
370 VLC_API void decoder_Clean( decoder_t *p_dec );
371 
372 /**
373  * This function queues a single picture to the video output.
374  *
375  * \note
376  * The caller doesn't own the picture anymore after this call (even in case of
377  * error).
378  * FIXME: input_DecoderFrameNext won't work if a module use this function.
379  */
380 static inline void decoder_QueueVideo( decoder_t *dec, picture_t *p_pic )
381 {
382  vlc_assert( dec->fmt_in.i_cat == VIDEO_ES && dec->cbs != NULL );
383  vlc_assert( p_pic->p_next == NULL );
384  vlc_assert( dec->cbs->video.queue != NULL );
385  dec->cbs->video.queue( dec, p_pic );
386 }
387 
388 /**
389  * This function queues the Closed Captions
390  *
391  * \param dec the decoder object
392  * \param p_cc the closed-caption to queue
393  * \param p_desc decoder_cc_desc_t description structure
394  */
395 static inline void decoder_QueueCc( decoder_t *dec, block_t *p_cc,
396  const decoder_cc_desc_t *p_desc )
397 {
398  vlc_assert( dec->fmt_in.i_cat == VIDEO_ES && dec->cbs != NULL );
399 
400  if( dec->cbs->video.queue_cc == NULL )
401  block_Release( p_cc );
402  else
403  dec->cbs->video.queue_cc( dec, p_cc, p_desc );
404 }
405 
406 /**
407  * This function queues a single audio block to the audio output.
408  *
409  * \note
410  * The caller doesn't own the audio block anymore after this call (even in case
411  * of error).
412  */
413 static inline void decoder_QueueAudio( decoder_t *dec, block_t *p_aout_buf )
414 {
415  vlc_assert( dec->fmt_in.i_cat == AUDIO_ES && dec->cbs != NULL );
416  vlc_assert( p_aout_buf->p_next == NULL );
417  vlc_assert( dec->cbs->audio.queue != NULL );
418  dec->cbs->audio.queue( dec, p_aout_buf );
419 }
420 
421 /**
422  * This function queues a single subtitle to the video output.
423  *
424  * \note
425  * The caller doesn't own the subtitle anymore after this call (even in case of
426  * error).
427  */
428 static inline void decoder_QueueSub( decoder_t *dec, subpicture_t *p_spu )
429 {
430  vlc_assert( dec->fmt_in.i_cat == SPU_ES && dec->cbs != NULL );
431  vlc_assert( p_spu->p_next == NULL );
432  vlc_assert( dec->cbs->spu.queue != NULL );
433  dec->cbs->spu.queue( dec, p_spu );
434 }
435 
436 /**
437  * This function notifies the audio output pipeline of a new audio output
438  * format (fmt_out.audio). If there is currently no audio output or if the
439  * audio output format has changed, a new audio output will be set up.
440  * @return 0 if the audio output is working, -1 if not. */
441 VLC_USED
442 static inline int decoder_UpdateAudioFormat( decoder_t *dec )
443 {
444  vlc_assert( dec->fmt_in.i_cat == AUDIO_ES && dec->cbs != NULL );
445 
446  if( dec->fmt_in.i_cat == AUDIO_ES && dec->cbs->audio.format_update != NULL )
447  return dec->cbs->audio.format_update( dec );
448  else
449  return -1;
450 }
451 
452 /**
453  * This function will return a new audio buffer usable by a decoder as an
454  * output buffer. It must be released with block_Release() or returned it to
455  * the caller as a decoder_QueueAudio parameter.
456  */
457 VLC_API block_t * decoder_NewAudioBuffer( decoder_t *, int i_nb_samples ) VLC_USED;
458 
459 /**
460  * This function will return a new subpicture usable by a decoder as an output
461  * buffer. You have to release it using subpicture_Delete() or by returning
462  * it to the caller as a decoder_QueueSub parameter.
463  */
464 VLC_USED
465 static inline subpicture_t *decoder_NewSubpicture( decoder_t *dec,
466  const subpicture_updater_t *p_dyn )
467 {
468  vlc_assert( dec->fmt_in.i_cat == SPU_ES && dec->cbs != NULL );
469 
470  subpicture_t *p_subpicture = dec->cbs->spu.buffer_new( dec, p_dyn );
471  if( !p_subpicture )
472  msg_Warn( dec, "can't get output subpicture" );
473  return p_subpicture;
474 }
475 
476 /**
477  * This function gives all input attachments at once.
478  *
479  * You MUST release the returned values
480  */
481 static inline int decoder_GetInputAttachments( decoder_t *dec,
482  input_attachment_t ***ppp_attachment,
483  int *pi_attachment )
484 {
485  vlc_assert( dec->cbs != NULL );
486 
487  if( !dec->cbs->get_attachments )
488  return VLC_EGENERIC;
489 
490  return dec->cbs->get_attachments( dec, ppp_attachment, pi_attachment );
491 }
492 
493 /**
494  * This function converts a decoder timestamp into a display date comparable
495  * to vlc_tick_now().
496  * You MUST use it *only* for gathering statistics about speed.
497  */
498 VLC_USED
499 static inline vlc_tick_t decoder_GetDisplayDate( decoder_t *dec,
500  vlc_tick_t system_now,
501  vlc_tick_t i_ts )
502 {
503  vlc_assert( dec->fmt_in.i_cat == VIDEO_ES && dec->cbs != NULL );
504 
505  if( !dec->cbs->video.get_display_date )
506  return VLC_TICK_INVALID;
507 
508  return dec->cbs->video.get_display_date( dec, system_now, i_ts );
509 }
510 
511 /**
512  * This function returns the current input rate.
513  * You MUST use it *only* for gathering statistics about speed.
514  */
515 VLC_USED
516 static inline float decoder_GetDisplayRate( decoder_t *dec )
517 {
518  vlc_assert( dec->fmt_in.i_cat == VIDEO_ES && dec->cbs != NULL );
519 
520  if( !dec->cbs->video.get_display_rate )
521  return 1.f;
522 
523  return dec->cbs->video.get_display_rate( dec );
524 }
525 
526 /** @} */
527 
528 /**
529  * \defgroup decoder_device Decoder hardware device
530  * \ingroup input
531  * @{
532  */
533 
534 /** Decoder device type */
536 {
544 };
545 
547 {
548  void (*close)(struct vlc_decoder_device *);
549 };
550 
551 /**
552  * Decoder context struct
553  */
554 typedef struct vlc_decoder_device
555 {
556  struct vlc_object_t obj;
558  const struct vlc_decoder_device_operations *ops;
560  /** Private context that could be used by the "decoder device" module
561  * implementation */
562  void *sys;
564  /** Must be set from the "decoder device" module open entry point */
565  enum vlc_decoder_device_type type;
567  /**
568  * Could be set from the "decoder device" module open entry point and will
569  * be used by hardware decoder modules.
570  *
571  * The type of pointer will depend of the type:
572  * VAAPI: VADisplay
573  * VDPAU: vdp_t *
574  * DXVA2: d3d9_decoder_device_t*
575  * D3D11VA: d3d11_decoder_device_t*
576  * AWindow: android AWindowHandler*
577  * NVDEC: decoder_device_nvdec_t*
578  * MMAL: MMAL_PORT_T*
579  */
580  void *opaque;
582 
583 /**
584  * "decoder device" module open entry point
585  *
586  * @param device the "decoder device" structure to initialize
587  * @param window pointer to a window to help device initialization (can be NULL)
588  **/
589 typedef int (*vlc_decoder_device_Open)(vlc_decoder_device *device,
590  vout_window_t *window);
591 
592 #define set_callback_dec_device(activate, priority) \
593  { \
594  vlc_decoder_device_Open open__ = activate; \
595  (void) open__; \
596  set_callback(activate) \
597  } \
598  set_capability( "decoder device", priority )
599 
600 
601 /**
602  * Create a decoder device from a window
603  *
604  * This function will be hidden in the future. It is now used by opengl vout
605  * module as a transition.
606  */
609 
610 /**
611  * Hold a decoder device
612  */
615 
616 /**
617  * Release a decoder device
618  */
619 VLC_API void
621 
622 /** @} */
623 #endif /* _VLC_CODEC_H */
Definition: vlc_input.h:160
Subpictures functions.
void decoder_Clean(decoder_t *p_dec)
Unload a decoder module and reset the input/output formats.
Definition: decoder_helpers.c:52
This file defines picture structures and functions in vlc.
struct decoder_owner_callbacks::@175::@179 spu
Definition: vlc_es.h:604
Video picture.
Definition: vlc_picture.h:126
void(* abort_pictures)(decoder_t *, bool b_abort)
Definition: vlc_codec.h:59
void decoder_Destroy(decoder_t *p_dec)
Destroy a decoder and reset the structure.
Definition: decoder_helpers.c:70
static subpicture_t * decoder_NewSubpicture(decoder_t *dec, const subpicture_updater_t *p_dyn)
This function will return a new subpicture usable by a decoder as an output buffer.
Definition: vlc_codec.h:466
struct decoder_owner_callbacks::@175::@177 video
Definition: vlc_codec.h:544
enum es_format_category_e i_cat
ES category.
Definition: vlc_es.h:619
Video subtitle.
Definition: vlc_subpicture.h:166
const struct decoder_owner_callbacks * cbs
Definition: vlc_codec.h:202
void(* queue)(decoder_t *, picture_t *)
Definition: vlc_codec.h:61
Definition: vlc_codec.h:538
Internal module descriptor.
Definition: modules.h:75
Definition: vlc_es.h:605
Definition: vlc_codec.h:207
Definition: vlc_codec.h:542
static float decoder_GetDisplayRate(decoder_t *dec)
This function returns the current input rate.
Definition: vlc_codec.h:517
vlc_tick_t(* get_display_date)(decoder_t *, vlc_tick_t, vlc_tick_t)
Definition: vlc_codec.h:68
#define msg_Warn(p_this,...)
Definition: vlc_messages.h:104
vlc_decoder_device * vlc_decoder_device_Hold(vlc_decoder_device *device)
Hold a decoder device.
Definition: decoder_helpers.c:207
block_t * p_next
Definition: vlc_block.h:119
picture_t * decoder_NewPicture(decoder_t *dec)
Allocates an output picture buffer.
Definition: decoder_helpers.c:154
Data block definition and functions.
Definition: decoder_helpers.c:231
static void decoder_QueueVideo(decoder_t *dec, picture_t *p_pic)
This function queues a single picture to the video output.
Definition: vlc_codec.h:381
Definition: vlc_codec.h:47
int64_t vlc_tick_t
High precision date or time interval.
Definition: vlc_tick.h:45
static int decoder_GetInputAttachments(decoder_t *dec, input_attachment_t ***ppp_attachment, int *pi_attachment)
This function gives all input attachments at once.
Definition: vlc_codec.h:482
Definition: vlc_configuration.h:331
Definition: vlc_codec.h:543
struct decoder_owner_callbacks::@175::@178 audio
Definition: vlc_codec.h:539
subpicture_t * p_next
an increasing unique number
Definition: vlc_subpicture.h:177
block_t * decoder_NewAudioBuffer(decoder_t *, int i_nb_samples)
This function will return a new audio buffer usable by a decoder as an output buffer.
Definition: decoder.c:799
Definition: vlc_codec.h:547
#define vlc_assert(pred)
Run-time assertion.
Definition: vlc_common.h:267
vlc_decoder_device * vlc_decoder_device_Create(vout_window_t *window)
Create a decoder device from a window.
Definition: decoder_helpers.c:185
void(* queue_cc)(decoder_t *, block_t *, const decoder_cc_desc_t *)
Definition: vlc_codec.h:63
float(* get_display_rate)(decoder_t *)
Definition: vlc_codec.h:71
Definition: vlc_es.h:603
void block_Release(block_t *block)
Releases a block.
Definition: block.c:135
Definition: vlc_es.h:617
static int decoder_UpdateAudioFormat(decoder_t *dec)
This function notifies the audio output pipeline of a new audio output format (fmt_out.audio).
Definition: vlc_codec.h:443
struct picture_t * p_next
Next picture in a FIFO a pictures.
Definition: vlc_picture.h:160
#define unlikely(p)
Predicted false condition.
Definition: vlc_common.h:223
static vlc_decoder_device * decoder_GetDecoderDevice(decoder_t *dec)
Creates/Updates the output decoder device.
Definition: vlc_codec.h:277
static void decoder_QueueSub(decoder_t *dec, subpicture_t *p_spu)
This function queues a single subtitle to the video output.
Definition: vlc_codec.h:429
struct vlc_decoder_device vlc_decoder_device
Decoder context struct.
Decoder context struct.
Definition: vlc_codec.h:555
Definition: vlc_codec.h:540
void decoder_AbortPictures(decoder_t *dec, bool b_abort)
Abort any calls of decoder_NewPicture.
Definition: decoder_helpers.c:162
static vlc_tick_t decoder_GetDisplayDate(decoder_t *dec, vlc_tick_t system_now, vlc_tick_t i_ts)
This function converts a decoder timestamp into a display date comparable to vlc_tick_now().
Definition: vlc_codec.h:500
#define VLC_API
Definition: fourcc_gen.c:31
int(* format_update)(decoder_t *, vlc_video_context *)
Definition: vlc_codec.h:54
Definition: vlc_codec.h:103
int(* vlc_decoder_device_Open)(vlc_decoder_device *device, vout_window_t *window)
"decoder device" module open entry point
Definition: vlc_codec.h:590
es_format_t fmt_in
Definition: vlc_codec.h:112
#define VLC_EGENERIC
Unspecified error.
Definition: vlc_common.h:472
Definition: meta.c:39
Definition: vlc_subpicture.h:135
int(* get_attachments)(decoder_t *p_dec, input_attachment_t ***ppp_attachment, int *pi_attachment)
Definition: vlc_codec.h:93
static void decoder_QueueAudio(decoder_t *dec, block_t *p_aout_buf)
This function queues a single audio block to the audio output.
Definition: vlc_codec.h:414
Definition: vlc_block.h:117
int decoder_UpdateVideoFormat(decoder_t *dec)
Updates the video output format.
Definition: decoder_helpers.c:79
void decoder_Init(decoder_t *dec, const es_format_t *)
Initialize a decoder structure before creating the decoder.
void vlc_decoder_device_Release(vlc_decoder_device *device)
Release a decoder device.
Definition: decoder_helpers.c:216
Window object.
Definition: vlc_vout_window.h:336
This file defines the elementary streams format types.
VLC object common members.
Definition: vlc_objects.h:43
vlc_decoder_device_type
Decoder device type.
Definition: vlc_codec.h:536
Definition: vlc_codec.h:541
#define VLC_USED
Definition: fourcc_gen.c:32
Definition: vlc_codec.h:225
int decoder_UpdateVideoOutput(decoder_t *dec, vlc_video_context *vctx_out)
Creates/Updates the rest of the video output pipeline.
Definition: decoder_helpers.c:84
Window modules interface.
#define VLC_TICK_INVALID
Definition: vlc_config.h:44
static void decoder_QueueCc(decoder_t *dec, block_t *p_cc, const decoder_cc_desc_t *p_desc)
This function queues the Closed Captions.
Definition: vlc_codec.h:396