
/*
 * CINELERRA
 * Copyright (C) 2008 Adam Williams <broadcast at earthling dot net>
 * Copyright (C) 2003-2016 Cinelerra CV contributors
 *
 * 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, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 */

#ifndef PLUGINVCLIENT_H
#define PLUGINVCLIENT_H


#include "maxbuffers.h"
#include "pluginclient.h"
#include "vframe.inc"

// Maximum dimensions for a temporary frame a plugin should retain between
// process_buffer calls.  This allows memory conservation.
#define PLUGIN_MAX_W 2000
#define PLUGIN_MAX_H 1000



class PluginVClient : public PluginClient
{
public:
	PluginVClient(PluginServer *server);
	virtual ~PluginVClient();

	int get_render_ptrs();
	int init_realtime_parameters();
	int delete_nonrealtime_parameters();
	int is_video();
// Replaced by pull method
/*
 * 	void plugin_process_realtime(VFrame **input,
 * 		VFrame **output,
 * 		int64_t current_position,
 * 		int64_t total_len);
 */
// Multichannel buffer process for backwards compatibility
	virtual int process_realtime(VFrame **input,
		VFrame **output);
// Single channel buffer process for backwards compatibility and transitions
	virtual int process_realtime(VFrame *input,
		VFrame *output);

// Process buffer using pull method.  By default this loads the input into *frame
//     and calls process_realtime with input and output pointing to frame.
// start_position - requested position relative to frame rate. Relative
//     to start of EDL.  End of buffer if reverse.
// sample_rate - scale of start_position.
// These should return 1 if error or 0 if success.
	virtual int process_buffer(VFrame **frame,
		int64_t start_position,
		double frame_rate);
	virtual int process_buffer(VFrame *frame,
		int64_t start_position,
		double frame_rate);


	virtual int process_loop(VFrame **buffers) { return 1; };
	virtual int process_loop(VFrame *buffer) { return 1; };
	int plugin_process_loop(VFrame **buffers, int64_t &write_length);

	int plugin_start_loop(int64_t start,
		int64_t end,
		int64_t buffer_size,
		int total_buffers);
	int plugin_get_parameters();

// Called by non-realtime client to read frame for processing.
// buffer - output frame
// channel - channel of the plugin input for a multichannel plugin
// start_position - start of frame in forward.  end of frame in reverse.
//     Relative to start of EDL.
	int read_frame(VFrame *buffer,
		int channel,
		int64_t start_position);
	int read_frame(VFrame *buffer,
		int64_t start_position);

// Called by realtime plugin to read frame from previous entity
// framerate - framerate start_position is relative to.  Used by preceeding plugiun
//     to calculate output frame number.  Provided so the client can get data
//     at a higher fidelity than provided by the EDL.
// start_position - start of frame in forward.  end of frame in reverse.
//     Relative to start of EDL.
// frame_rate - frame rate position is scaled to
	int read_frame(VFrame *buffer,
		int channel,
		int64_t start_position,
		double frame_rate,
		int use_opengl /* = 0 */);


// User calls this to request an opengl routine to be run synchronously.
	int run_opengl();

// Called by Playback3D to run opengl commands synchronously.
// Overridden by the user with the commands to run synchronously.
	virtual int handle_opengl();

// Used by the opengl handlers to get the
// arguments to process_buffer.
// For realtime plugins, they're identical for input and output.
	VFrame* get_input(int channel = 0);
	VFrame* get_output(int channel = 0);

// For aggregation, this does case sensitive compares with the
// the stack in the frame object.
// Only possible for video because VFrame stores the effect stacks.
	int next_effect_is(const char *title);
	int prev_effect_is(const char *title);

// Called by user to allocate the temporary for the current process_buffer.
// It may be deleted after the process_buffer to conserve memory.
	VFrame* new_temp(int w, int h, int color_model);
// Called by PluginServer after process_buffer to delete the temp if it's too
// large.
	void age_temp();
	VFrame* get_temp();

// Frame rate relative to EDL
	double get_project_framerate();
// Frame rate requested
	double get_framerate();
// Get list of system fonts
	ArrayList<BC_FontEntry*> *get_fontlist();
// Find font entry
	BC_FontEntry *find_fontentry(const char *displayname, int style,
		int mask, int preferred_style);
// Find font path where glyph for the character_code exists
	int find_font_by_char(FT_ULong char_code, char *path_new, const FT_Face oldface);

	int64_t local_to_edl(int64_t position);
	int64_t edl_to_local(int64_t position);
	int64_t get_startproject();
	int64_t get_endproject();

// ======================== Non realtime buffer pointers =======================
// Channels of arrays of frames that the client uses.
	VFrame ***video_in, ***video_out;

// point to the start of the buffers
	ArrayList<VFrame***> input_ptr_master;
	ArrayList<VFrame***> output_ptr_master;
// Pointers to the regions for a single render.
// Arrays are channels of arrays of frames.
	VFrame ***input_ptr_render;
	VFrame ***output_ptr_render;

// ======================== Realtime buffer pointers ===========================
// These are provided by the plugin server for the opengl handler.
	VFrame **input;
	VFrame **output;


// Frame rate of EDL
	double project_frame_rate;
// Local parameters set by non realtime plugin about the file to be generated.
// Retrieved by server to set output file format.
// In realtime plugins, these are set before every process_buffer as the
// requested rates.
	double frame_rate;
	int project_color_model;
// Whether user wants floating point calculations.
	int use_float;
// Whether user wants alpha calculations.
	int use_alpha;
// Whether user wants pixel interpolation.
	int use_interpolation;
// Aspect ratio
	float aspect_w;
	float aspect_h;

// Temp
	VFrame *temp;
};



#endif
