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