avdec.h

Go to the documentation of this file.

/*****************************************************************
 * gmerlin-avdecoder - a general purpose multimedia decoding library
 *
 * Copyright (c) 2001 - 2024 Members of the Gmerlin project
 * http://github.com/bplaum
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 * *****************************************************************/
 
 
 
/* Public entry points */
 
#ifndef BGAV_AVDEC_H_INCLUDED
#define BGAV_AVDEC_H_INCLUDED

 
#include <gavl/gavl.h>
#include <gavl/compression.h>
#include <gavl/metadata.h>
#include <gavl/chapterlist.h>
#include <gavl/connectors.h>
#include <gavl/edl.h>
#include <gavl/msg.h>
 
#include "bgavdefs.h" // This is ugly, but works
 
#ifdef __cplusplus
extern "C" {
#endif
 


 
typedef struct bgav_s bgav_t;

 
BGAV_PUBLIC
bgav_t * bgav_create(void);




 
typedef gavl_dictionary_t bgav_metadata_t;

 
BGAV_PUBLIC
const char * bgav_metadata_get_author(const bgav_metadata_t*metadata);

 
BGAV_PUBLIC
const char * bgav_metadata_get_title(const bgav_metadata_t * metadata);

 
BGAV_PUBLIC
const char * bgav_metadata_get_comment(const bgav_metadata_t * metadata);

 
BGAV_PUBLIC
const char * bgav_metadata_get_copyright(const bgav_metadata_t * metadata);

 
BGAV_PUBLIC
const char * bgav_metadata_get_album(const bgav_metadata_t * metadata);

 
BGAV_PUBLIC
const char * bgav_metadata_get_artist(const bgav_metadata_t * metadata);

 
BGAV_PUBLIC
const char * bgav_metadata_get_albumartist(const bgav_metadata_t * metadata);

 
BGAV_PUBLIC
const char * bgav_metadata_get_genre(const bgav_metadata_t * metadata);

 
BGAV_PUBLIC
const char * bgav_metadata_get_date(const bgav_metadata_t * metadata);

 
BGAV_PUBLIC
int bgav_metadata_get_track(const bgav_metadata_t * metadata);
 
/***************************************************
 * Housekeeping Functions
 ***************************************************/
 
/***************************************************
 * Set parameters
 ***************************************************/
 

 
typedef struct bgav_options_s bgav_options_t;

 
BGAV_PUBLIC
bgav_options_t * bgav_get_options(bgav_t * bgav);

 
BGAV_PUBLIC
bgav_options_t * bgav_options_create(void);

 
BGAV_PUBLIC
void bgav_options_destroy(bgav_options_t * opt);

 
BGAV_PUBLIC
void bgav_options_copy(bgav_options_t * dst, const bgav_options_t * src);

 
BGAV_PUBLIC
void bgav_options_set_connect_timeout(bgav_options_t * opt, int timeout);

 
BGAV_PUBLIC
void bgav_options_set_read_timeout(bgav_options_t * opt, int timeout);

 
 
BGAV_PUBLIC
void bgav_options_set_rtp_port_base(bgav_options_t * opt, int p);

 
BGAV_PUBLIC
void bgav_options_set_rtp_try_tcp(bgav_options_t * opt, int enable);

 
BGAV_PUBLIC
void bgav_options_set_network_bandwidth(bgav_options_t * opt, int bandwidth);
 
 
/* HTTP Options */

 
BGAV_PUBLIC
void bgav_options_set_http_use_proxy(bgav_options_t* opt, int enable);

 
BGAV_PUBLIC
void bgav_options_set_http_proxy_host(bgav_options_t* opt, const char * host);

 
BGAV_PUBLIC
void bgav_options_set_http_proxy_port(bgav_options_t* opt, int port);

 
BGAV_PUBLIC
void bgav_options_set_http_proxy_auth(bgav_options_t* opt, int enable);

 
BGAV_PUBLIC
void bgav_options_set_http_proxy_user(bgav_options_t* opt, const char * user);

 
BGAV_PUBLIC
void bgav_options_set_http_proxy_pass(bgav_options_t* opt, const char * pass);

 
BGAV_PUBLIC
void bgav_options_set_http_shoutcast_metadata(bgav_options_t* opt, int enable);
 
/* Set FTP options */

 
BGAV_PUBLIC
void bgav_options_set_ftp_anonymous(bgav_options_t* opt, int enable);

 
BGAV_PUBLIC
void bgav_options_set_ftp_anonymous_password(bgav_options_t* opt, const char* pass);

 
BGAV_PUBLIC
void bgav_options_set_default_subtitle_encoding(bgav_options_t* opt,
                                                const char* encoding);

 
BGAV_PUBLIC
void bgav_options_set_audio_dynrange(bgav_options_t* opt,
                                     int audio_dynrange);
 

 
BGAV_PUBLIC
void bgav_options_set_sample_accurate(bgav_options_t*opt, int enable);

 
BGAV_PUBLIC
void bgav_options_set_cache_time(bgav_options_t*opt, int t);

 
BGAV_PUBLIC
void bgav_options_set_cache_size(bgav_options_t*opt, int s);

 
BGAV_PUBLIC
void bgav_options_set_seek_subtitles(bgav_options_t* opt,
                                    int seek_subtitles);

 
BGAV_PUBLIC
void bgav_options_set_pp_level(bgav_options_t* opt,
                               int pp_level);

 
BGAV_PUBLIC
void bgav_options_set_postprocessing_level(bgav_options_t* opt,
                                           float pp_level);

 
BGAV_PUBLIC
void bgav_options_set_threads(bgav_options_t * opt, int threads);
 
  
 
BGAV_PUBLIC
void bgav_options_set_dvb_channels_file(bgav_options_t* opt,
                                        const char * file);

 
BGAV_PUBLIC
void bgav_options_set_prefer_ffmpeg_demuxers(bgav_options_t* opt,
                                             int prefer);

 
BGAV_PUBLIC
void bgav_options_set_dv_datetime(bgav_options_t* opt,
                                  int datetime);

 
BGAV_PUBLIC
void bgav_options_set_shrink(bgav_options_t* opt,
                             int factor);

 
BGAV_PUBLIC
void bgav_options_set_vdpau(bgav_options_t* opt,
                            int vdpau);

 
BGAV_PUBLIC
void bgav_options_set_vaapi(bgav_options_t* opt,
                            int vaapi);

 
BGAV_PUBLIC
void bgav_options_set_dump_headers(bgav_options_t* opt,
                                   int enable);

 
BGAV_PUBLIC
void bgav_options_set_dump_indices(bgav_options_t* opt,
                                   int enable);
 
  
 
BGAV_PUBLIC
void bgav_options_set_dump_packets(bgav_options_t* opt,
                                   int enable);
 
BGAV_PUBLIC
void bgav_options_set_video_hw_context(bgav_options_t * opt, gavl_hw_context_t * hwctx);
 
  
 
 
/* Set callbacks */

 
 
typedef void (*bgav_metadata_change_callback)(void*data, const bgav_metadata_t * metadata);

 
BGAV_PUBLIC void
bgav_options_set_metadata_change_callback(bgav_options_t* opt,
                                          bgav_metadata_change_callback callback,
                                          void * data);

 
typedef void (*bgav_buffer_callback)(void*data, float percentage);

  
BGAV_PUBLIC void
bgav_options_set_buffer_callback(bgav_options_t* opt,
                                 bgav_buffer_callback callback,
                                 void * data);

 
typedef int (*bgav_user_pass_callback)(void*data, const char * resource,
                                       char ** username, char ** password);
  
 
BGAV_PUBLIC void
bgav_options_set_user_pass_callback(bgav_options_t* opt,
                                    bgav_user_pass_callback callback,
                                    void * data);

 
typedef void (*bgav_aspect_callback)(void*data, int stream,
                                     int pixel_width, int pixel_height);
 

 
BGAV_PUBLIC void
bgav_options_set_aspect_callback(bgav_options_t* opt,
                                 bgav_aspect_callback callback,
                                 void * data);

 
typedef void (*bgav_index_callback)(void*data, float percentage);

 
BGAV_PUBLIC void
bgav_options_set_index_callback(bgav_options_t* opt,
                                bgav_index_callback callback,
                                void * data);
 
BGAV_PUBLIC void
bgav_set_msg_callback_by_id(bgav_t* b,
                            int id,
                            gavl_handle_msg_func callback,
                            void * data);
 
  
  
/* Device description */


 
typedef struct
  {
  char * device; 
  char * name;   
  } bgav_device_info_t;
 
/* Scan for devices */

 
BGAV_PUBLIC
bgav_device_info_t * bgav_find_devices_vcd(void);

 
BGAV_PUBLIC
int bgav_check_device_vcd(const char * device, char ** name);

 
BGAV_PUBLIC
bgav_device_info_t * bgav_find_devices_dvd(void);

 
BGAV_PUBLIC
int bgav_check_device_dvd(const char * device, char ** name);

 
BGAV_PUBLIC
bgav_device_info_t * bgav_find_devices_dvb(void);

 
BGAV_PUBLIC
int bgav_check_device_dvb(const char * device, char ** name);

 
 
BGAV_PUBLIC
void bgav_device_info_destroy(bgav_device_info_t * arr);

 
BGAV_PUBLIC
int bgav_eject_disc(const char * device);

 
BGAV_PUBLIC
const char * bgav_get_disc_name(bgav_t * bgav);
 
/******************************************************
 * Open
 ******************************************************/
 
/* Open a file or URL, return 1 on success */

 
BGAV_PUBLIC
int bgav_open(bgav_t * bgav, const char * location);

 
BGAV_PUBLIC
int bgav_open_vcd(bgav_t * bgav, const char * location);

 
BGAV_PUBLIC
int bgav_open_dvd(bgav_t * bgav, const char * location);

 
BGAV_PUBLIC
int bgav_open_dvb(bgav_t * bgav, const char * location);

 
BGAV_PUBLIC
int bgav_open_callbacks(bgav_t * bgav,
                        int (*read_callback)(void * priv, uint8_t * data, int len),
                        int64_t (*seek_callback)(void * priv, int64_t pos, int whence),
                        void * priv,
                        const char * filename, const char * mimetype, int64_t total_bytes);
 
  
 
 
 
/* Close and destroy everything */

 
BGAV_PUBLIC
void bgav_close(bgav_t * bgav);

 
BGAV_PUBLIC
const gavl_dictionary_t * bgav_get_edl(bgav_t * bgav);
 
/***************************************************
 * Check for redirecting: You MUST check if you opened
 * a redirector, because reading data from redirectors
 * crashes
 * After you read the URLs, close the bgav_t object
 * and open a new one with one of the URLs.
 ***************************************************/


 
#if 0  
 

 
BGAV_PUBLIC
int bgav_redirector_get_num_urls(bgav_t * bgav);

 
BGAV_PUBLIC
const char * bgav_redirector_get_url(bgav_t * bgav, int index);

 
BGAV_PUBLIC
const char * bgav_redirector_get_name(bgav_t * bgav, int index);

 
BGAV_PUBLIC
const gavl_dictionary_t * bgav_redirector_get_metadata(bgav_t * b, int index);
 
#endif
  
/***************************************************
 * Get information about the file
 ***************************************************/


 
BGAV_PUBLIC
int bgav_num_tracks(bgav_t * bgav);

 
BGAV_PUBLIC
const char * bgav_get_description(bgav_t * bgav);

 
BGAV_PUBLIC
gavl_time_t bgav_get_duration(bgav_t * bgav, int track);
 
/* Query stream numbers */

 
BGAV_PUBLIC
int bgav_num_audio_streams(bgav_t * bgav, int track);

 
BGAV_PUBLIC
int bgav_num_video_streams(bgav_t * bgav, int track);

 
BGAV_PUBLIC
int bgav_num_subtitle_streams(bgav_t * bgav, int track);

 
BGAV_PUBLIC
int bgav_num_text_streams(bgav_t * bgav, int track);

 
BGAV_PUBLIC
int bgav_num_overlay_streams(bgav_t * bgav, int track);

 
BGAV_PUBLIC
const char * bgav_get_track_name(bgav_t * bgav, int track);

 
BGAV_PUBLIC
const bgav_metadata_t * bgav_get_metadata(bgav_t * bgav,int track);

 
BGAV_PUBLIC
gavl_dictionary_t * bgav_get_media_info(bgav_t * bgav);
 
  
 
 
BGAV_PUBLIC
int bgav_select_track(bgav_t * bgav, int track);

 
BGAV_PUBLIC
int bgav_get_num_chapters(bgav_t * bgav, int track, int * timescale);

 
BGAV_PUBLIC const char *
bgav_get_chapter_name(bgav_t * bgav, int track, int chapter);

 
BGAV_PUBLIC
int64_t bgav_get_chapter_time(bgav_t * bgav, int track, int chapter);

 
BGAV_PUBLIC
const gavl_chapter_list_t * bgav_get_chapter_list(bgav_t * bgav, int track);
 
  

 
BGAV_PUBLIC
const char * bgav_get_audio_language(bgav_t * bgav, int stream);

 
BGAV_PUBLIC
int bgav_get_audio_bitrate(bgav_t * bgav, int stream);

 
BGAV_PUBLIC
const bgav_metadata_t *
bgav_get_audio_metadata(bgav_t * bgav, int stream);

 
BGAV_PUBLIC
const bgav_metadata_t * bgav_get_audio_metadata_t(bgav_t * b, int t, int s);
  
 
BGAV_PUBLIC
const char * bgav_get_subtitle_language(bgav_t * bgav, int stream);

 
BGAV_PUBLIC
const bgav_metadata_t *
bgav_get_subtitle_metadata(bgav_t * bgav, int stream);

 
BGAV_PUBLIC
const bgav_metadata_t *
bgav_get_text_metadata(bgav_t * b, int stream);

 
BGAV_PUBLIC
const bgav_metadata_t *
bgav_get_text_metadata_t(bgav_t * b, int track, int stream);
  
 
BGAV_PUBLIC
const bgav_metadata_t *
bgav_get_overlay_metadata(bgav_t * b, int stream);

  
BGAV_PUBLIC
const bgav_metadata_t *
bgav_get_overlay_metadata_t(bgav_t * b, int track, int stream);
  
  
 
BGAV_PUBLIC
const bgav_metadata_t *
bgav_get_video_metadata(bgav_t * bgav, int stream);

 
BGAV_PUBLIC
const bgav_metadata_t *
bgav_get_video_metadata_t(bgav_t * b, int t, int s);
  
  
 
typedef enum
  {
    BGAV_STREAM_MUTE    = 0,  
    BGAV_STREAM_DECODE  = 1, 
    BGAV_STREAM_PARSE   = 2, 
    BGAV_STREAM_READRAW = 3, 
    BGAV_STREAM_INIT    = 4 
  }
bgav_stream_action_t;

 
  
 
BGAV_PUBLIC
int bgav_get_audio_compression_info(bgav_t * bgav, int stream,
                                    gavl_compression_info_t * info);

 
BGAV_PUBLIC
int bgav_get_video_compression_info(bgav_t * bgav, int stream,
                                    gavl_compression_info_t * info);

 
BGAV_PUBLIC
int bgav_get_overlay_compression_info(bgav_t * bgav, int stream,
                                      gavl_compression_info_t * info);
 
  
  
BGAV_PUBLIC
int bgav_read_audio_packet(bgav_t * bgav, int stream, gavl_packet_t * p);

 
BGAV_PUBLIC
gavl_packet_source_t *
bgav_get_audio_packet_source(bgav_t * bgav, int stream);
 
  
 
BGAV_PUBLIC
int bgav_read_video_packet(bgav_t * bgav, int stream, gavl_packet_t * p);

 
BGAV_PUBLIC
gavl_packet_source_t *
bgav_get_video_packet_source(bgav_t * bgav, int stream);

 
BGAV_PUBLIC
gavl_packet_source_t *
bgav_get_text_packet_source(bgav_t * bgav, int stream);

 
BGAV_PUBLIC
gavl_packet_source_t *
bgav_get_overlay_packet_source(bgav_t * bgav, int stream);
 
  
 
BGAV_PUBLIC
int bgav_set_audio_stream(bgav_t * bgav, int stream, bgav_stream_action_t action);

 
BGAV_PUBLIC
int bgav_set_video_stream(bgav_t * bgav, int stream, bgav_stream_action_t action);

 
BGAV_PUBLIC
int bgav_set_subtitle_stream(bgav_t * bgav, int stream,
                             bgav_stream_action_t action);

 
BGAV_PUBLIC
int bgav_set_text_stream(bgav_t * bgav, int stream,
                         bgav_stream_action_t action);

 
BGAV_PUBLIC
int bgav_set_overlay_stream(bgav_t * bgav, int stream,
                            bgav_stream_action_t action);
 
/***************************************************
 * Stream handling functions
 ***************************************************/
 
/*
 *  You MUST these, if you want to decode anything.
 *  After bgav_open(), all streams are switched off by
 *  default
 */
 


 
BGAV_PUBLIC
int bgav_start(bgav_t * bgav);
 
BGAV_PUBLIC
int bgav_pause(bgav_t * bgav);
 
BGAV_PUBLIC
int bgav_resume(bgav_t * bgav);
 
  

 
BGAV_PUBLIC
const gavl_audio_format_t * bgav_get_audio_format(bgav_t * bgav, int stream);

 
 
 BGAV_PUBLIC
 const gavl_audio_format_t * bgav_get_audio_format_t(bgav_t *  bgav, int track, int stream);
  
 
BGAV_PUBLIC
const gavl_video_format_t * bgav_get_video_format(bgav_t * bgav, int stream);

 
BGAV_PUBLIC
const gavl_video_format_t * bgav_get_video_format_t(bgav_t * bgav, int t, int stream);
  
 
BGAV_PUBLIC
const gavl_video_format_t * bgav_get_overlay_format(bgav_t * bgav, int stream);

 
BGAV_PUBLIC
int bgav_get_text_timescale(bgav_t * bgav, int stream);
 
  
  
BGAV_PUBLIC
gavl_frame_table_t * bgav_get_frame_table(bgav_t * bgav, int stream);
 
  
 
 
  
BGAV_PUBLIC const gavl_video_format_t *
bgav_get_subtitle_format(bgav_t * bgav, int stream);

 
BGAV_PUBLIC
int bgav_subtitle_is_text(bgav_t * bgav, int stream);

 
BGAV_PUBLIC
const char * bgav_get_audio_description(bgav_t * bgav, int stream);

 
BGAV_PUBLIC
const char * bgav_get_audio_info(bgav_t * bgav, int stream);
 

 
BGAV_PUBLIC
const char * bgav_get_video_description(bgav_t * bgav, int stream);

 
BGAV_PUBLIC
const char * bgav_get_subtitle_description(bgav_t * bgav, int stream);
 

 
BGAV_PUBLIC
const char * bgav_get_subtitle_info(bgav_t * bgav, int stream);

 
BGAV_PUBLIC
int bgav_can_pause(bgav_t * bgav);
 
/***************************************************
 * Decoding functions
 ***************************************************/


  
BGAV_PUBLIC
int bgav_video_has_still(bgav_t * bgav, int stream);
  
 
BGAV_PUBLIC
int bgav_read_video(bgav_t * bgav, gavl_video_frame_t * frame, int stream);

 
BGAV_PUBLIC
int bgav_skip_video(bgav_t * bgav, int stream,
                     int64_t * time, int scale,
                     int exact);
 
/*
 * Set a skip mode (see GAVL_MSG_SRC_SKIP_* in gavl/msg.h)
 */
  
BGAV_PUBLIC
void bgav_set_video_skip_mode(bgav_t * bgav, int stream,
                              int mode);

  
BGAV_PUBLIC
gavl_video_source_t * bgav_get_video_source(bgav_t * bgav, int stream);

  
BGAV_PUBLIC
gavl_video_source_t * bgav_get_overlay_source(bgav_t * bgav, int stream);
 
  
 
BGAV_PUBLIC
int bgav_read_audio(bgav_t * bgav, gavl_audio_frame_t * frame, int stream,
                    int num_samples);

  
BGAV_PUBLIC
gavl_audio_source_t * bgav_get_audio_source(bgav_t * bgav, int stream);
 
  

 
BGAV_PUBLIC
int bgav_has_subtitle(bgav_t * bgav, int stream);

 
BGAV_PUBLIC
int bgav_read_subtitle_overlay(bgav_t * bgav, gavl_overlay_t * ovl, int stream);

 
BGAV_PUBLIC
int bgav_read_subtitle_text(bgav_t * bgav, char ** ret, int *ret_alloc,
                            int64_t * start_time, int64_t * duration,
                            int stream);
 
/***************************************************
 * Seek to a timestamp. This also resyncs all streams
 ***************************************************/


 

 
BGAV_PUBLIC
int bgav_can_seek(bgav_t * bgav);
 
  
 
BGAV_PUBLIC
void bgav_seek(bgav_t * bgav, gavl_time_t * time);
 

 
BGAV_PUBLIC
int bgav_seek_scaled(bgav_t * bgav, int64_t * time, int scale);


 
BGAV_PUBLIC
int bgav_can_seek_sample(bgav_t * bgav);
 

 
BGAV_PUBLIC
int64_t bgav_audio_duration(bgav_t * bgav, int stream);

 
BGAV_PUBLIC
int64_t bgav_audio_start_time(bgav_t * bgav, int stream);

 
BGAV_PUBLIC
int64_t bgav_video_duration(bgav_t * bgav, int stream);

 
BGAV_PUBLIC
int64_t bgav_video_start_time(bgav_t * bgav, int stream);
 

 
BGAV_PUBLIC
int64_t bgav_subtitle_duration(bgav_t * bgav, int stream);

 
BGAV_PUBLIC
int64_t bgav_text_duration(bgav_t * bgav, int stream);

 
BGAV_PUBLIC
int64_t bgav_overlay_duration(bgav_t * bgav, int stream);
 
BGAV_PUBLIC
int64_t bgav_get_num_video_frames(bgav_t * bgav, int stream);
  
 
BGAV_PUBLIC
int bgav_seek_to_video_frame(bgav_t * bgav, int stream, int frame);

 
BGAV_PUBLIC
int64_t bgav_video_keyframe_before(bgav_t * bgav, int stream, int64_t time);

 
BGAV_PUBLIC
int64_t bgav_video_keyframe_after(bgav_t * bgav, int stream, int64_t time);
  

  
typedef struct bgav_stream_decoder_s bgav_stream_decoder_t;

  
BGAV_PUBLIC
bgav_stream_decoder_t * bgav_stream_decoder_create(void);

 
BGAV_PUBLIC bgav_options_t *
bgav_stream_decoder_get_options(bgav_stream_decoder_t * dec);

  
BGAV_PUBLIC gavl_audio_source_t *
bgav_stream_decoder_connect_audio(bgav_stream_decoder_t * dec,
                                  gavl_packet_source_t * src,
                                  gavl_dictionary_t * s);
  
 
BGAV_PUBLIC gavl_video_source_t *
bgav_stream_decoder_connect_video(bgav_stream_decoder_t * dec,
                                  gavl_packet_source_t * src,
                                  gavl_dictionary_t * s);

 
BGAV_PUBLIC gavl_video_source_t *
bgav_stream_decoder_connect_overlay(bgav_stream_decoder_t * dec,
                                    gavl_packet_source_t * src,
                                    gavl_dictionary_t * s);

 
BGAV_PUBLIC int64_t
bgav_stream_decoder_skip(bgav_stream_decoder_t * dec, int64_t t, int scale);

 
BGAV_PUBLIC void
bgav_stream_decoder_reset(bgav_stream_decoder_t * dec);

 
BGAV_PUBLIC void
bgav_stream_decoder_destroy(bgav_stream_decoder_t * dec);

 
  
BGAV_PUBLIC gavl_codec_id_t *
bgav_supported_audio_compressions(void);

 
BGAV_PUBLIC
gavl_codec_id_t * bgav_supported_video_compressions(void);
 
BGAV_PUBLIC
uint32_t * bgav_supported_audio_fourccs(void);
 
BGAV_PUBLIC
uint32_t * bgav_supported_video_fourccs(void);
 
  
BGAV_PUBLIC
int bgav_set_stream_action_all(bgav_t * bgav, int idx, bgav_stream_action_t action);
  
  
 
/***************************************************
 * Debugging functions
 ***************************************************/


 
BGAV_PUBLIC
void bgav_dump(bgav_t * bgav);
 
/* Dump infos about the installed codecs */

 
BGAV_PUBLIC
void bgav_codecs_dump(void);
 
/* Dump known media formats */

 
BGAV_PUBLIC
void bgav_formats_dump(void);

 
BGAV_PUBLIC
void bgav_inputs_dump(void);

 
BGAV_PUBLIC
void bgav_redirectors_dump(void);

 
BGAV_PUBLIC
void bgav_subreaders_dump(void);
 
 
#ifdef __cplusplus
}
#endif
 
 
#endif // BGAV_AVDEC_H_INCLUDED