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 "ffmpeg.inc"
  30 #include "guicast.h"
  31 #include "file.inc"
  32 #include "filelist.inc"
  33 #include "overlayframe.inc"
  34 #include "strategies.inc"
  35 #include "vframe.inc"
  36
  37 #include <sys/types.h>
  38
  39 // Number of samples saved before the current read position
  40 #define HISTORY_MAX 0x10000
  41
  42 // inherited by every file interpreter
  43 class FileBase
  44 {
  45 public:
  46         FileBase(Asset *asset, File *file);
  47         virtual ~FileBase();
  48
  49
  50         friend class File;
  51         friend class FFMPEG;
  52         friend class FileList;
  53         friend class FrameWriter;
  54
  55
  56
  57
  58         void get_mode(char *mode, int rd, int wr);
  59         void reset_parameters();
  60
  61
  62
  63         virtual void get_parameters(BC_WindowBase *parent_window,
  64                         Asset *asset,
  65                         BC_WindowBase **format_window,
  66                         int audio_options,
  67                         int video_options,
  68                         int lock_compressor) {};
  69
  70
  71
  72         virtual int get_index(char *index_path) { return 1; }
  73         virtual int check_header() { return 0; }  // Test file to see if it is of this type.
  74         virtual int reset_parameters_derived() { return 0; }
  75         virtual int read_header() { return 1; }   // WAV files for getting header
  76         virtual int open_file(int rd, int wr) { return 1; }
  77         virtual int close_file();
  78         virtual int close_file_derived() { return 0; }
  79         int set_dither();
  80         virtual int seek_end() { return 0; }
  81         virtual int seek_start() { return 0; }
  82         virtual int64_t get_video_position() { return 0; }
  83         virtual int64_t get_audio_position() { return 0; }
  84         virtual int set_video_position(int64_t x) { return 0; }
  85         virtual int set_audio_position(int64_t x) { return 0; }
  86         virtual int set_subtitle(int value) { return -1; }
  87         virtual int select_video_stream(Asset *asset, int vstream) { return -1; }
  88         virtual int select_audio_stream(Asset *asset, int astream) { return -1; }
  89         virtual int set_program(int no) { return -1; }
  90         virtual int get_cell_time(int no, double &time) { time = -1.; return 1; }
  91         virtual int get_system_time(int64_t &tm) { tm = -1; return 1; }
  92         virtual int get_audio_for_video(int vstream, int astream, int64_t &channel_mask) {
  93                  channel_mask = 0;  return -1;
  94         }
  95         virtual int get_video_pid(int track) { return -1; }
  96         virtual int get_video_info(int track, int &pid, double &framerate,
  97                 int &width, int &height, char *title=0) { return -1; }
  98
  99         virtual int get_thumbnail(int stream, int64_t &position,
 100                 unsigned char *&thumbnail, int &ww, int &hh) { return -1; }
 101         virtual int set_skimming(int track, int skim, skim_fn fn, void *vp) { return -1; }
 102         virtual int skim_video(int track, void *vp, skim_fn fn) { return -1; }
 103
 104 // Subclass should call this to add the base class allocation.
 105 // Only used in read mode.
 106         virtual int64_t base_memory_usage();
 107
 108         virtual int write_samples(double **buffer,
 109                 int64_t len) { return 0; }
 110         virtual int write_frames(VFrame ***frames, int len) { return 0; }
 111         virtual int read_compressed_frame(VFrame *buffer) { return 0; }
 112         virtual int write_compressed_frame(VFrame *buffers) { return 0; }
 113         virtual int64_t compressed_frame_size() { return 0; }
 114 // Doubles are used to allow resampling
 115         virtual int read_samples(double *buffer, int64_t len) { return 0; }
 116         virtual int read_frame(VFrame *frame) { return 1; }
 117 // get dvb record stream file descriptor
 118         virtual int record_fd() { return -1; }
 119
 120         virtual int prefer_samples_float() { return 0; }
 121         virtual int read_samples_float(float *buffer, int64_t len) { return 0; }
 122
 123 // Return either the argument or another colormodel which read_frame should
 124 // use.
 125         virtual int colormodel_supported(int colormodel) { return BC_RGB888; }
 126 // This file can copy compressed frames directly from the asset
 127         virtual int can_copy_from(Asset *asset, int64_t position) { return 0; }
 128         virtual int get_render_strategy(ArrayList<int>* render_strategies) { return VRENDER_VPIXEL; }
 129
 130 // Manages an audio history buffer
 131         void update_pcm_history(int64_t len);
 132 // Returns history_start + history_size
 133         int64_t get_history_sample();
 134 // contiguous float
 135         void append_history(float **new_data, int len);
 136 // Interleaved short
 137         void append_history(short *new_data, int len);
 138         void read_history(double *dst,
 139                 int64_t start_sample,
 140                 int channel,
 141                 int64_t len);
 142         void allocate_history(int len);
 143
 144 // For static functions to access it
 145         Asset *asset;
 146         int rd, wr;
 147
 148 protected:
 149 // Return 1 if the render_strategy is present on the list.
 150         static int search_render_strategies(ArrayList<int>* render_strategies, int render_strategy);
 151
 152 // convert samples into file format
 153         int64_t samples_to_raw(char *out_buffer,
 154                                                         float **in_buffer, // was **buffer
 155                                                         int64_t input_len,
 156                                                         int bits,
 157                                                         int channels,
 158                                                         int byte_order,
 159                                                         int signed_);
 160
 161 // overwrites the buffer from PCM data depending on feather.
 162         int raw_to_samples(float *out_buffer, char *in_buffer,
 163                 int64_t samples, int bits, int channels, int channel, int feather,
 164                 float lfeather_len, float lfeather_gain, float lfeather_slope);
 165
 166 // Overwrite the buffer from float data using feather.
 167         int overlay_float_buffer(float *out_buffer, float *in_buffer,
 168                 int64_t samples,
 169                 float lfeather_len, float lfeather_gain, float lfeather_slope);
 170
 171 // convert a frame to and from file format
 172
 173         int64_t frame_to_raw(unsigned char *out_buffer,
 174                                         VFrame *in_frame,
 175                                         int w,
 176                                         int h,
 177                                         int use_alpha,
 178                                         int use_float,
 179                                         int color_model);
 180
 181 // allocate a buffer for translating int to float
 182         int get_audio_buffer(char **buffer, int64_t len, int64_t bits, int64_t channels); // audio
 183
 184 // Allocate a buffer for feathering floats
 185         int get_float_buffer(float **buffer, int64_t len);
 186
 187 // allocate a buffer for translating video to VFrame
 188         int get_video_buffer(unsigned char **buffer, int depth); // video
 189         int get_row_pointers(unsigned char *buffer, unsigned char ***pointers, int depth);
 190         static int match4(const char *in, const char *out);   // match 4 bytes for a fourcc type
 191
 192         float *float_buffer;          // for floating point feathering
 193         unsigned char **row_pointers_in, **row_pointers_out;
 194         int64_t prev_buffer_position;  // for audio determines if reading raw data is necessary
 195         int64_t prev_frame_position;   // for video determines if reading raw video data is necessary
 196         int64_t prev_bytes; // determines if new raw buffer is needed and used for getting memory usage
 197         int64_t prev_len;
 198         int prev_track;
 199         int prev_layer;
 200         int dither;
 201         int internal_byte_order;
 202         File *file;
 203
 204 // ================================= Audio compression
 205         double **pcm_history;
 206         int64_t history_allocated;
 207         int64_t history_size;
 208         int64_t history_start;
 209         int history_channels;
 210 // Range to decode to fill history buffer.  Maintained by FileBase.
 211         int64_t decode_start;
 212         int64_t decode_len;
 213 // End of last decoded sample.  Maintained by user for seeking.
 214         int64_t decode_end;
 215
 216 private:
 217 // ULAW
 218         float ulawtofloat(char ulaw);
 219         char floattoulaw(float value);
 220         int generate_ulaw_tables();
 221         int delete_ulaw_tables();
 222         float *ulawtofloat_table, *ulawtofloat_ptr;
 223         unsigned char *floattoulaw_table, *floattoulaw_ptr;
 224
 225         OverlayFrame *overlayer;
 226 };
 227
 228 #endif