avdec.h

Go to the documentation of this file.

/*****************************************************************
 * gmerlin-avdecoder - a general purpose multimedia decoding library
 *
 * Copyright (c) 2001 - 2011 Members of the Gmerlin project
 * gmerlin-general@lists.sourceforge.net
 * http://gmerlin.sourceforge.net
 *
 * 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 */

#include <gavl/gavl.h>
#include <gavl/compression.h>
#include <gavl/metadata.h>

#include "bgavdefs.h" // This is ugly, but works

#ifdef __cplusplus
extern "C" {
#endif

typedef struct bgav_edl_s bgav_edl_t;

typedef struct bgav_s bgav_t;

BGAV_PUBLIC
bgav_t * bgav_create();

typedef gavl_metadata_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();

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);

BGAV_PUBLIC
void bgav_options_set_network_buffer_size(bgav_options_t * opt, int size);

/* 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_dump_headers(bgav_options_t* opt,
                                   int enable);

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

  

typedef enum
  {
    BGAV_LOG_DEBUG   = (1<<0),
    BGAV_LOG_WARNING = (1<<1),
    BGAV_LOG_ERROR   = (1<<2),
    BGAV_LOG_INFO    = (1<<3)
  } bgav_log_level_t;

typedef void (*bgav_log_callback)(void*data, bgav_log_level_t level,
                                  const char * log_domain,
                                  const char * message);

BGAV_PUBLIC void
bgav_options_set_log_callback(bgav_options_t* opt,
                              bgav_log_callback callback,
                              void * data);

BGAV_PUBLIC void
bgav_options_set_log_level(bgav_options_t* opt,
                           int level);
  
  

/* Set callbacks */

typedef void (*bgav_name_change_callback)(void*data, const char * name);

BGAV_PUBLIC void
bgav_options_set_name_change_callback(bgav_options_t* opt,
                                      bgav_name_change_callback callback,
                                      void * data);

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);


/* 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();

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

BGAV_PUBLIC
bgav_device_info_t * bgav_find_devices_dvd();

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

BGAV_PUBLIC
bgav_device_info_t * bgav_find_devices_dvb();

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_fd(bgav_t * bgav, int fd,
                 int64_t total_size,
                 const char * mimetype);

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, uint64_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);

typedef struct
  {
  char * url;   

  int track;        
  int stream;       
  int timescale;    
    
  int64_t src_time; 
  
  /* Time and duration within the destination in destination
     timescale */
  int64_t dst_time;  
  int64_t dst_duration; 

  /*  */
  int32_t speed_num; 
  int32_t speed_den; 
  
  } bgav_edl_segment_t;

typedef struct
  {
  bgav_edl_segment_t * segments; 
  int num_segments;              
  int timescale;                 
  } bgav_edl_stream_t;

typedef struct
  {
  char * name;                       
  bgav_metadata_t * metadata;        
  
  int num_audio_streams;             
  bgav_edl_stream_t * audio_streams; 

  int num_video_streams;             
  bgav_edl_stream_t * video_streams; 

  int num_subtitle_text_streams;     
  bgav_edl_stream_t * subtitle_text_streams; 

  int num_subtitle_overlay_streams;  
  bgav_edl_stream_t * subtitle_overlay_streams; 
  
  } bgav_edl_track_t;

struct bgav_edl_s
  {
  int num_tracks;             
  bgav_edl_track_t * tracks;  
  char * url;                 
  };

BGAV_PUBLIC
bgav_edl_t * bgav_get_edl(bgav_t * bgav);

BGAV_PUBLIC
void bgav_edl_dump(const bgav_edl_t * e);

/***************************************************
 * 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.
 ***************************************************/

BGAV_PUBLIC
int bgav_is_redirector(bgav_t * bgav);

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);

/***************************************************
 * 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
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
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 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 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_video_metadata(bgav_t * bgav, int stream);

  
typedef enum
  {
    BGAV_STREAM_MUTE    = 0,  
    BGAV_STREAM_DECODE  = 1, 
    BGAV_STREAM_PARSE   = 2, 
    BGAV_STREAM_READRAW = 3 
  }
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_read_audio_packet(bgav_t * bgav, int stream, gavl_packet_t * p);

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

  

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);

/***************************************************
 * 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
const gavl_audio_format_t * bgav_get_audio_format(bgav_t * bgav, int stream);

BGAV_PUBLIC
const gavl_video_format_t * bgav_get_video_format(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
void bgav_skip_video(bgav_t * bgav, int stream,
                     int64_t * time, int scale,
                     int exact);

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

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
void bgav_seek_scaled(bgav_t * bgav, int64_t * time, int scale);

#define BGAV_TIMESTAMP_UNDEFINED GAVL_TIME_UNDEFINED // Don't change this

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
void bgav_seek_audio(bgav_t * bgav, int stream, int64_t sample);

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

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);


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


/***************************************************
 * Debugging functions
 ***************************************************/

BGAV_PUBLIC
void bgav_dump(bgav_t * bgav);

/* Dump infos about the installed codecs */

BGAV_PUBLIC
void bgav_codecs_dump();

/* Dump known media formats */

BGAV_PUBLIC
void bgav_formats_dump();

BGAV_PUBLIC
void bgav_inputs_dump();

BGAV_PUBLIC
void bgav_redirectors_dump();

BGAV_PUBLIC
void bgav_subreaders_dump();


#ifdef __cplusplus
}
#endif