fixes for checkin 2 times ago
[goodguy/cinelerra.git] / cinelerra-5.1 / cinelerra / filebase.h
1
2 /*
3  * CINELERRA
4  * Copyright (C) 2008 Adam Williams <broadcast at earthling dot net>
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software
18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
19  *
20  */
21
22 #ifndef FILEBASE_H
23 #define FILEBASE_H
24
25 #include "asset.inc"
26 #include "assets.inc"
27 #include "bccmodels.h"
28 #include "edit.inc"
29 #include "edl.inc"
30 #include "ffmpeg.inc"
31 #include "guicast.h"
32 #include "file.inc"
33 #include "filelist.inc"
34 #include "indexfile.inc"
35 #include "mainprogress.inc"
36 #include "overlayframe.inc"
37 #include "strategies.inc"
38 #include "vframe.inc"
39
40 #include <sys/types.h>
41
42 // Number of samples saved before the current read position
43 #define HISTORY_MAX 0x10000
44
45 // inherited by every file interpreter
46 class FileBase
47 {
48 public:
49         FileBase(Asset *asset, File *file);
50         virtual ~FileBase();
51
52
53         friend class File;
54         friend class FFMPEG;
55         friend class FileList;
56         friend class FrameWriter;
57
58         void get_mode(char *mode, int rd, int wr);
59         void reset_parameters();
60
61         virtual int get_index(IndexFile *index_file, MainProgressBar *progress_bar) { return -1; }
62         virtual int check_header() { return 0; }  // Test file to see if it is of this type.
63         virtual int reset_parameters_derived() { return 0; }
64         virtual int read_header() { return 1; }   // WAV files for getting header
65         virtual int get_best_colormodel(int driver, int vstream);
66
67         virtual int open_file(int rd, int wr) { return 1; }
68         virtual int close_file();
69         virtual int close_file_derived() { return 0; }
70         int set_dither();
71         virtual int seek_end() { return 0; }
72         virtual int seek_start() { return 0; }
73         virtual int64_t get_video_position() { return 0; }
74         virtual int64_t get_audio_position() { return 0; }
75         virtual int set_video_position(int64_t x) { return 0; }
76         virtual int set_audio_position(int64_t x) { return 0; }
77         virtual int set_subtitle(int value) { return -1; }
78         virtual int select_video_stream(Asset *asset, int vstream) { return -1; }
79         virtual int select_audio_stream(Asset *asset, int astream) { return -1; }
80         virtual int set_program(int no) { return -1; }
81         virtual int get_cell_time(int no, double &time) { time = -1.; return 1; }
82         virtual int get_system_time(int64_t &tm) { tm = -1; return 1; }
83         virtual int get_audio_for_video(int vstream, int astream, int64_t &channel_mask) {
84                  channel_mask = 0;  return -1;
85         }
86         virtual int get_video_pid(int track) { return -1; }
87         virtual int get_video_info(int track, int &pid, double &framerate,
88                 int &width, int &height, char *title=0) { return -1; }
89
90         virtual int get_thumbnail(int stream, int64_t &position,
91                 unsigned char *&thumbnail, int &ww, int &hh) { return -1; }
92         virtual int set_skimming(int track, int skim, skim_fn fn, void *vp) { return -1; }
93         virtual int skim_video(int track, void *vp, skim_fn fn) { return -1; }
94
95 // Subclass should call this to add the base class allocation.
96 // Only used in read mode.
97         virtual int64_t base_memory_usage();
98
99         virtual int write_samples(double **buffer,
100                 int64_t len) { return 0; }
101         virtual int write_frames(VFrame ***frames, int len) { return 0; }
102         virtual int read_compressed_frame(VFrame *buffer) { return 0; }
103         virtual int write_compressed_frame(VFrame *buffers) { return 0; }
104         virtual int64_t compressed_frame_size() { return 0; }
105 // Doubles are used to allow resampling
106         virtual int read_samples(double *buffer, int64_t len) { return 0; }
107         virtual int read_frame(VFrame *frame) { return 1; }
108 // get dvb record stream file descriptor
109         virtual int record_fd() { return -1; }
110
111         virtual int prefer_samples_float() { return 0; }
112         virtual int read_samples_float(float *buffer, int64_t len) { return 0; }
113
114 // Return either the argument or another colormodel which read_frame should
115 // use.
116         virtual int colormodel_supported(int colormodel) { return BC_RGB888; }
117 // This file can copy compressed frames directly from the asset
118         virtual int can_copy_from(Asset *asset, int64_t position) { return 0; }
119         virtual int can_scale_input() { return 0; }
120         virtual int get_render_strategy(ArrayList<int>* render_strategies) { return VRENDER_VPIXEL; }
121
122 // Manages an audio history buffer
123         void update_pcm_history(int64_t len);
124 // Returns history_start + history_size
125         int64_t get_history_sample();
126 // contiguous float
127         void append_history(float **new_data, int len);
128 // Interleaved short
129         void append_history(short *new_data, int len);
130         void read_history(double *dst,
131                 int64_t start_sample,
132                 int channel,
133                 int64_t len);
134         void allocate_history(int len);
135
136 // For static functions to access it
137         Asset *asset;
138         int rd, wr;
139
140 protected:
141 // Return 1 if the render_strategy is present on the list.
142         static int search_render_strategies(ArrayList<int>* render_strategies, int render_strategy);
143
144 // convert samples into file format
145         int64_t samples_to_raw(char *out_buffer,
146                                                         float **in_buffer, // was **buffer
147                                                         int64_t input_len,
148                                                         int bits,
149                                                         int channels,
150                                                         int byte_order,
151                                                         int signed_);
152
153 // overwrites the buffer from PCM data depending on feather.
154         int raw_to_samples(float *out_buffer, char *in_buffer,
155                 int64_t samples, int bits, int channels, int channel, int feather,
156                 float lfeather_len, float lfeather_gain, float lfeather_slope);
157
158 // Overwrite the buffer from float data using feather.
159         int overlay_float_buffer(float *out_buffer, float *in_buffer,
160                 int64_t samples,
161                 float lfeather_len, float lfeather_gain, float lfeather_slope);
162
163 // convert a frame to and from file format
164
165         int64_t frame_to_raw(unsigned char *out_buffer,
166                                         VFrame *in_frame,
167                                         int w,
168                                         int h,
169                                         int use_alpha,
170                                         int use_float,
171                                         int color_model);
172
173 // allocate a buffer for translating int to float
174         int get_audio_buffer(char **buffer, int64_t len, int64_t bits, int64_t channels); // audio
175
176 // Allocate a buffer for feathering floats
177         int get_float_buffer(float **buffer, int64_t len);
178
179 // allocate a buffer for translating video to VFrame
180         int get_video_buffer(unsigned char **buffer, int depth); // video
181         int get_row_pointers(unsigned char *buffer, unsigned char ***pointers, int depth);
182         static int match4(const char *in, const char *out);   // match 4 bytes for a fourcc type
183
184         float *float_buffer;          // for floating point feathering
185         unsigned char **row_pointers_in, **row_pointers_out;
186         int64_t prev_buffer_position;  // for audio determines if reading raw data is necessary
187         int64_t prev_frame_position;   // for video determines if reading raw video data is necessary
188         int64_t prev_bytes; // determines if new raw buffer is needed and used for getting memory usage
189         int64_t prev_len;
190         int prev_track;
191         int prev_layer;
192         int dither;
193         int internal_byte_order;
194         File *file;
195
196 // ================================= Audio compression
197         double **pcm_history;
198         int64_t history_allocated;
199         int64_t history_size;
200         int64_t history_start;
201         int history_channels;
202 // Range to decode to fill history buffer.  Maintained by FileBase.
203         int64_t decode_start;
204         int64_t decode_len;
205 // End of last decoded sample.  Maintained by user for seeking.
206         int64_t decode_end;
207
208 private:
209 // ULAW
210         float ulawtofloat(char ulaw);
211         char floattoulaw(float value);
212         int generate_ulaw_tables();
213         int delete_ulaw_tables();
214         float *ulawtofloat_table, *ulawtofloat_ptr;
215         unsigned char *floattoulaw_table, *floattoulaw_ptr;
216 };
217
218 #endif