plugin.h

/*****************************************************************
 * gmerlin - a general purpose multimedia framework and applications
 *
 * Copyright (c) 2001 - 2008 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/>.
 * *****************************************************************/

#ifndef __BG_PLUGIN_H_
#define __BG_PLUGIN_H_

#include <gavl/gavl.h>
#include <gmerlin/parameter.h>
#include <gmerlin/streaminfo.h>
#include <gmerlin/accelerator.h>
#include <gmerlin/edl.h>

typedef int (*bg_read_audio_func_t)(void * priv, gavl_audio_frame_t* frame, int stream,
                                  int num_samples);

typedef int (*bg_read_video_func_t)(void * priv, gavl_video_frame_t* frame, int stream);

#define BG_PLUGIN_REMOVABLE    (1<<0)  
#define BG_PLUGIN_FILE         (1<<1)  
#define BG_PLUGIN_RECORDER     (1<<2)  

#define BG_PLUGIN_URL          (1<<3)  
#define BG_PLUGIN_PLAYBACK     (1<<4)  

#define BG_PLUGIN_BYPASS       (1<<5)  

#define BG_PLUGIN_KEEP_RUNNING (1<<6) 

#define BG_PLUGIN_INPUT_HAS_SYNC (1<<7) 

#define BG_PLUGIN_STDIN         (1<<8)  

#define BG_PLUGIN_TUNER         (1<<9)  
#define BG_PLUGIN_FILTER_1     (1<<10)  

#define BG_PLUGIN_EMBED_WINDOW (1<<11)  

#define BG_PLUGIN_VISUALIZE_FRAME (1<<12)  

#define BG_PLUGIN_VISUALIZE_GL (1<<13)  

#define BG_PLUGIN_PP  (1<<14)  
#define BG_PLUGIN_CALLBACKS     (1<<15)  

#define BG_PLUGIN_UNSUPPORTED  (1<<24)  


#define BG_PLUGIN_ALL 0xFFFFFFFF 


#define BG_PLUGIN_API_VERSION 18

/* Include this into all plugin modules exactly once
   to let the plugin loader obtain the API version */

#define BG_GET_PLUGIN_API_VERSION \
  int get_plugin_api_version() __attribute__ ((visibility("default"))); \
  int get_plugin_api_version() { return BG_PLUGIN_API_VERSION; }

#define BG_PLUGIN_PRIORITY_MIN 1
#define BG_PLUGIN_PRIORITY_MAX 10

typedef enum
  {
    BG_STREAM_ACTION_OFF = 0, 
    BG_STREAM_ACTION_DECODE,  
    
    /*
     */
    
    BG_STREAM_ACTION_BYPASS, 
    
    /*
     *  Future support for compressed frames
     *  must go here
     */

    /* BG_STREAM_ACTION_READRAW */
    
  } bg_stream_action_t;

/***************************************************
 * Plugin API
 *
 * Plugin dlls contain a symbol "the_plugin",
 * which points to one of the structures below.
 * The member functions are described below.
 *
 ***************************************************/

/*
 * Plugin types
 */

typedef enum
  {
    BG_PLUGIN_NONE                       = 0,      
    BG_PLUGIN_INPUT                      = (1<<0), 
    BG_PLUGIN_OUTPUT_AUDIO               = (1<<1), 
    BG_PLUGIN_OUTPUT_VIDEO               = (1<<2), 
    BG_PLUGIN_RECORDER_AUDIO             = (1<<3), 
    BG_PLUGIN_RECORDER_VIDEO             = (1<<4), 
    BG_PLUGIN_ENCODER_AUDIO              = (1<<5), 
    BG_PLUGIN_ENCODER_VIDEO              = (1<<6), 
    BG_PLUGIN_ENCODER_SUBTITLE_TEXT      = (1<<7), 
    BG_PLUGIN_ENCODER_SUBTITLE_OVERLAY   = (1<<8), 
    BG_PLUGIN_ENCODER                    = (1<<9), 
    BG_PLUGIN_ENCODER_PP                 = (1<<10),
    BG_PLUGIN_IMAGE_READER               = (1<<11),
    BG_PLUGIN_IMAGE_WRITER               = (1<<12), 
    BG_PLUGIN_FILTER_AUDIO               = (1<<13), 
    BG_PLUGIN_FILTER_VIDEO               = (1<<14), 
    BG_PLUGIN_VISUALIZATION              = (1<<15), 
    BG_PLUGIN_AV_RECORDER                = (1<<16),  
  } bg_plugin_type_t;

typedef struct
  {
  char * device; 
  char * name;   
  } bg_device_info_t;

bg_device_info_t * bg_device_info_append(bg_device_info_t * arr,
                                         const char * device,
                                         const char * name);

void bg_device_info_destroy(bg_device_info_t * arr);

/* Common part */

typedef struct bg_plugin_common_s bg_plugin_common_t;

struct bg_plugin_common_s
  {
  char * gettext_domain; 
  char * gettext_directory; 
  
  char             * name;       
  char             * long_name;  
  bg_plugin_type_t type;  
  int              flags;  
  
  char             * description; 
  
  /*
   *  If there might be more than one plugin for the same
   *  job, there is a priority (0..10) which is used for the
   *  decision
   */
  
  int              priority; 
  
  void * (*create)();
      
  void (*destroy)(void* priv);

  const bg_parameter_info_t * (*get_parameters)(void * priv);

  bg_set_parameter_func_t set_parameter;

  bg_get_parameter_func_t get_parameter;
  
  int (*check_device)(const char * device, char ** name);
  

  bg_device_info_t * (*find_devices)();
    
  };

/*
 *  Plugin callbacks: Functions called by the
 *  plugin to reflect user input or other changes
 *  Applications might pass NULL callbacks,
 *  so plugins MUST check for valid callbacks structure
 *  before calling any of these functions
 */

/* Input plugin */

typedef struct bg_input_callbacks_s bg_input_callbacks_t;

struct bg_input_callbacks_s
  {
   void (*track_changed)(void * data, int track);

  void (*time_changed)(void * data, gavl_time_t time);
  
  void (*duration_changed)(void * data, gavl_time_t duration);

  void (*name_changed)(void * data, const char * name);

  void (*metadata_changed)(void * data, const bg_metadata_t * m);

  void (*buffer_notify)(void * data, float percentage);

  int (*user_pass)(void * data, const char * resource,
                   char ** username, char ** password);

  void (*aspect_changed)(void * data, int stream,
                         int pixel_width, int pixel_height);
  
  
  void * data; 
  
  };

/*************************************************
 * MEDIA INPUT
 *************************************************/

typedef struct bg_input_plugin_s bg_input_plugin_t;


struct bg_input_plugin_s
  {
  bg_plugin_common_t common; 

  const char * (*get_protocols)(void * priv);
  const char * (*get_mimetypes)(void * priv);

  const char * (*get_extensions)(void * priv);
  
  void (*set_callbacks)(void * priv, bg_input_callbacks_t * callbacks);
  
  int (*open)(void * priv, const char * arg);

  int (*open_fd)(void * priv, int fd, int64_t total_bytes,
                 const char * mimetype);

  int (*open_callbacks)(void * priv,
                        int (*read_callback)(void * priv, uint8_t * data, int len),
                        int64_t (*seek_callback)(void * priv, uint64_t pos, int whence),
                        void * cb_priv, const char * filename, const char * mimetype,
                        int64_t total_bytes);
  
  const bg_edl_t * (*get_edl)(void * priv);
    
  const char * (*get_disc_name)(void * priv);

  int (*eject_disc)(const char * device);
  
  int (*get_num_tracks)(void * priv);
  
  bg_track_info_t * (*get_track_info)(void * priv, int track);

  int (*set_track)(void * priv, int track);
    
  /*
   *  These functions set the audio- video- and subpicture streams
   *  as well as programs (== DVD Angles). All these start with 0
   *
   *  Arguments for actions are defined in the enum bg_stream_action_t
   *  above. Plugins must return FALSE on failure (e.g. no such stream)
   *
   *  Functions must be defined only, if the corresponding stream
   *  type is supported by the plugin and can be switched.
   *  Single stream plugins can leave these NULL
   *  Gmerlin will never try to call these functions on nonexistent streams
   */

  int (*set_audio_stream)(void * priv, int stream, bg_stream_action_t action);

  int (*set_video_stream)(void * priv, int stream, bg_stream_action_t action);
  
  int (*set_subtitle_stream)(void * priv, int stream, bg_stream_action_t action);
  
  int (*start)(void * priv);

  bg_read_audio_func_t read_audio;

  int (*has_still)(void * priv, int stream);
  
  bg_read_video_func_t read_video;
  
  int (*has_subtitle)(void * priv, int stream);
    
  int (*read_subtitle_overlay)(void * priv,
                               gavl_overlay_t*ovl, int stream);

  int (*read_subtitle_text)(void * priv,
                            char ** text, int * text_alloc,
                            int64_t * start_time,
                            int64_t * duration, int stream);
  
  /* The following 3 functions are only meaningful for plugins, which
     have the BG_PLUGIN_BYPASS flag set. */

  int (*bypass)(void * priv);
  
  void (*bypass_set_pause)(void * priv, int pause);

  void (*bypass_set_volume)(void * priv, float volume);
    
  void (*seek)(void * priv, int64_t * time, int scale);
  
  void (*stop)(void * priv);
  
  void (*close)(void * priv);
  
  };

typedef struct bg_oa_plugin_s bg_oa_plugin_t;

struct bg_oa_plugin_s
  {
  bg_plugin_common_t common; 

  int (*open)(void * priv, gavl_audio_format_t* format);

  int (*start)(void * priv);
    
  void (*write_audio)(void * priv, gavl_audio_frame_t* frame);

  int (*get_delay)(void * priv);
  
  void (*stop)(void * priv);
    
  void (*close)(void * priv);
  };

/*******************************************
 * AUDIO RECORDER
 *******************************************/

typedef struct bg_recorder_plugin_s bg_recorder_plugin_t;

struct bg_recorder_plugin_s
  {
  bg_plugin_common_t common; 

  int (*open)(void * priv, gavl_audio_format_t * audio_format, gavl_video_format_t * video_format);
  
  bg_read_audio_func_t read_audio;

  bg_read_video_func_t read_video;
  
  void (*close)(void * priv);
  };

/*******************************************
 * VIDEO OUTPUT
 *******************************************/

/* Callbacks */

typedef struct bg_ov_callbacks_s bg_ov_callbacks_t;

struct bg_ov_callbacks_s
  {
  const bg_accelerator_map_t * accel_map;
  
  int (*accel_callback)(void * data, int id);
  
  int (*key_callback)(void * data, int key, int mask);

  int (*key_release_callback)(void * data, int key, int mask);
  
  int (*button_callback)(void * data, int x, int y, int button, int mask);

  int (*button_release_callback)(void * data, int x, int y, int button, int mask);
  
  int (*motion_callback)(void * data, int x, int y, int mask);
  
  void (*show_window)(void * data, int show);

  void (*brightness_callback)(void * data, float val);

  void (*saturation_callback)(void * data, float val);

  void (*contrast_callback)(void * data, float val);

  void (*hue_callback)(void * data, float val);
  
  void * data;
  };

/* Plugin structure */

typedef struct bg_ov_plugin_s bg_ov_plugin_t;

struct bg_ov_plugin_s
  {
  bg_plugin_common_t common; 

  void (*set_window)(void * priv, const char * window_id);
  
  const char * (*get_window)(void * priv);
  
  void (*set_window_title)(void * priv, const char * title);
  

  void (*set_callbacks)(void * priv, bg_ov_callbacks_t * callbacks);
  
  int  (*open)(void * priv, gavl_video_format_t * format, int keep_aspect);
  
  gavl_video_frame_t * (*create_frame)(void * priv);
  
  int (*add_overlay_stream)(void * priv, gavl_video_format_t * format);

  gavl_overlay_t * (*create_overlay)(void * priv, int id);
  
  void (*set_overlay)(void * priv, int stream, gavl_overlay_t * ovl);
  
  void (*put_video)(void * priv, gavl_video_frame_t*frame);

  void (*put_still)(void * priv, gavl_video_frame_t*frame);

  void (*handle_events)(void * priv);

  void (*update_aspect)(void * priv, int pixel_width, int pixel_height);
    
  void (*destroy_frame)(void * priv, gavl_video_frame_t * frame);

  void (*destroy_overlay)(void * priv, int id, gavl_overlay_t * ovl);

  void (*close)(void * priv);

  void (*show_window)(void * priv, int show);
  };

/*******************************************
 * ENCODER
 *******************************************/

typedef struct bg_encoder_plugin_s bg_encoder_plugin_t;


struct bg_encoder_plugin_s
  {
  bg_plugin_common_t common; 
  
  int max_audio_streams;  
  int max_video_streams;  
  int max_subtitle_text_streams;
  int max_subtitle_overlay_streams;

  const char * (*get_extension)(void * priv);
  
  int (*open)(void * data, const char * filename,
              bg_metadata_t * metadata, bg_chapter_list_t * chapter_list);

  const char * (*get_filename)(void*);

  /* Return per stream parameters */

  const bg_parameter_info_t * (*get_audio_parameters)(void * priv);

  const bg_parameter_info_t * (*get_video_parameters)(void * priv);

  const bg_parameter_info_t * (*get_subtitle_text_parameters)(void * priv);

  const bg_parameter_info_t * (*get_subtitle_overlay_parameters)(void * priv);
  
  /* Add streams. The formats can be changed, be sure to get the
   * final formats with get_[audio|video]_format after starting the plugin
   * Return value is the index of the added stream.
   */

  int (*add_audio_stream)(void * priv, const char * language,
                          gavl_audio_format_t * format);

  int (*add_video_stream)(void * priv, gavl_video_format_t * format);

  int (*add_subtitle_text_stream)(void * priv, const char * language, int * timescale);
  
  int (*add_subtitle_overlay_stream)(void * priv, const char * language,
                                     gavl_video_format_t * format);
  
  /* Set parameters for the streams */

  void (*set_audio_parameter)(void * priv, int stream, const char * name,
                              const bg_parameter_value_t * v);

  void (*set_video_parameter)(void * priv, int stream, const char * name,
                              const bg_parameter_value_t * v);

  void (*set_subtitle_text_parameter)(void * priv, int stream,
                                      const char * name,
                                      const bg_parameter_value_t * v);

  void (*set_subtitle_overlay_parameter)(void * priv, int stream,
                                         const char * name,
                                         const bg_parameter_value_t * v);
  
  int (*set_video_pass)(void * priv, int stream, int pass, int total_passes,
                        const char * stats_file);
  
  int (*start)(void * priv);
  
  /*
   *  After setting the parameters, get the formats, you need to deliver the frames in
   */

  void (*get_audio_format)(void * priv, int stream, gavl_audio_format_t*ret);

  void (*get_video_format)(void * priv, int stream, gavl_video_format_t*ret);

  void (*get_subtitle_overlay_format)(void * priv, int stream,
                                      gavl_video_format_t*ret);

  /*
   *  Encode audio/video
   */

  int (*write_audio_frame)(void * data,gavl_audio_frame_t * frame, int stream);

  int (*write_video_frame)(void * data,gavl_video_frame_t * frame, int stream);

  int (*write_subtitle_text)(void * data,const char * text,
                             int64_t start,
                             int64_t duration, int stream);
  
  int (*write_subtitle_overlay)(void * data, gavl_overlay_t * ovl, int stream);
  
  int (*close)(void * data, int do_delete);
  };


/*******************************************
 * ENCODER Postprocessor
 *******************************************/

typedef struct
  {
  void (*action_callback)(void * data, char * action);

  void (*progress_callback)(void * data, float perc);

  void * data; 

  } bg_e_pp_callbacks_t;

typedef struct bg_encoder_pp_plugin_s bg_encoder_pp_plugin_t;

struct bg_encoder_pp_plugin_s
  {
  bg_plugin_common_t common; 
  
  int max_audio_streams;  
  int max_video_streams;  

  char * supported_extensions; 
  
  void (*set_callbacks)(void * priv,bg_e_pp_callbacks_t * callbacks);
  
  int (*init)(void * priv);

  void (*add_track)(void * priv, const char * filename,
                    bg_metadata_t * metadata, int pp_only);
  
  void (*run)(void * priv, const char * directory, int cleanup);

  void (*stop)(void * priv);
  };


typedef struct bg_image_reader_plugin_s bg_image_reader_plugin_t;

struct bg_image_reader_plugin_s
  {
  bg_plugin_common_t common; 
  const char * extensions; 
  
  int (*read_header)(void * priv, const char * filename,
                     gavl_video_format_t * format);

  int (*read_image)(void * priv, gavl_video_frame_t * frame);
  };

typedef struct bg_image_writer_plugin_s bg_image_writer_plugin_t;

struct bg_image_writer_plugin_s
  {
  bg_plugin_common_t common; 
  const char * extensions; 

  const char * (*get_extension)(void * priv);
  
  int (*write_header)(void * priv, const char * filename,
                      gavl_video_format_t * format);
  
  int (*write_image)(void * priv, gavl_video_frame_t * frame);
  } ;

/* Filters */

typedef struct bg_fa_plugin_s bg_fa_plugin_t;

struct bg_fa_plugin_s
  {
  bg_plugin_common_t common; 

  void (*connect_input_port)(void * priv, bg_read_audio_func_t func,
                             void * data,
                             int stream, int port);

  void (*set_input_format)(void * priv, gavl_audio_format_t * format, int port);


  void (*reset)(void * priv);

  void (*get_output_format)(void * priv, gavl_audio_format_t * format);

  int (*need_restart)(void * priv);

  bg_read_audio_func_t read_audio;
    
  };

typedef struct bg_fv_plugin_s bg_fv_plugin_t;

struct bg_fv_plugin_s
  {
  bg_plugin_common_t common; 

  gavl_video_options_t * (*get_options)(void * priv);
  
  void (*connect_input_port)(void * priv,
                             bg_read_video_func_t func,
                             void * data, int stream, int port);

  void (*set_input_format)(void * priv, gavl_video_format_t * format, int port);
  
  void (*reset)(void * priv);

  void (*get_output_format)(void * priv, gavl_video_format_t * format);
  
  int (*need_restart)(void * priv);

  bg_read_video_func_t read_video;
    
  };


typedef struct bg_visualization_plugin_s bg_visualization_plugin_t;


struct bg_visualization_plugin_s
  {
  bg_plugin_common_t common; 

  bg_ov_callbacks_t * (*get_callbacks)(void * priv);

  int (*open_ov)(void * priv, gavl_audio_format_t * audio_format,
                 gavl_video_format_t * video_format);
  
  int (*open_win)(void * priv, gavl_audio_format_t * audio_format,
                  const char * window_id);

  void (*update)(void * priv, gavl_audio_frame_t * frame);

  void (*draw_frame)(void * priv, gavl_video_frame_t * frame);
  
  void (*show_frame)(void * priv);

  void (*close)(void * priv);
  
  };



#endif // __BG_PLUGIN_H_