6c1da43802181ea56125d3d296a050ade1e3c18d
[goodguy/cinelerra.git] / cinelerra-5.1 / cinelerra / filelist.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 FILELIST_H
23 #define FILELIST_H
24
25 #include "file.inc"
26 #include "filebase.h"
27 #include "filelist.inc"
28 #include "loadbalance.h"
29 #include "mutex.inc"
30 #include "vframe.inc"
31
32 // Any file which is a list of frames.
33 // FileList handles both frame files and indexes of frame files.
34
35
36
37
38
39
40 class FileList : public FileBase
41 {
42 public:
43         FileList(Asset *asset,
44                 File *file,
45                 const char *list_prefix,
46                 const char *file_extension,
47                 int frame_type,
48                 int list_type);
49         virtual ~FileList();
50
51 // basic commands for every file interpreter
52         int open_file(int rd, int wr);
53         int close_file();
54
55         char* calculate_path(int number, char *string);
56         char* create_path(int number_override);
57         void add_return_value(int amount);
58
59         int read_list_header();
60         virtual int read_frame_header(char *path) { return 1; };
61         int can_scale_input() { return 1; }
62         int read_frame(VFrame *frame);
63
64 // subclass returns whether the asset format is a list or single file
65         virtual int read_frame(VFrame *frame, VFrame *data) { return 0; };
66         virtual int read_frame(VFrame *frame, char *path) { return 0; };
67         virtual int write_frame(VFrame *frame, VFrame *data, FrameWriterUnit *unit) { return 0; };
68 // Return 1 if read frame should use the path instead of the compressed data
69         virtual int use_path();
70
71         int write_list_header();
72         int write_frames(VFrame ***frames, int len);
73         VFrame* read_frame(int use_alpha, int use_float);
74         virtual int64_t get_memory_usage();
75 // Get the total writer units for calculating memory usage
76         int get_units();
77 // Get a writer unit for retrieving temporary usage.
78         FrameWriterUnit* get_unit(int number);
79
80         virtual FrameWriterUnit* new_writer_unit(FrameWriter *writer);
81
82 // Temp storage for compressed data
83         VFrame *data;
84 // Storage for single frame
85         VFrame *temp;
86
87 private:
88         int read_raw(VFrame *frame,
89                 float in_x1, float in_y1, float in_x2, float in_y2,
90                 float out_x1, float out_y1, float out_x2, float out_y2,
91                 int alpha, int use_alpha, int use_float, int interpolate);
92         int reset_parameters_derived();
93         ArrayList<char*> path_list;     // List of files
94         const char *list_prefix;
95         const char *file_extension;
96         int frame_type;
97         int list_type;
98         Mutex *table_lock;
99         FrameWriter *writer;
100         int return_value;
101         int first_number;
102         int number_start;
103         int number_digits;
104 };
105
106
107
108
109 class FrameWriterPackage : public LoadPackage
110 {
111 public:
112         FrameWriterPackage();
113         ~FrameWriterPackage();
114
115
116         VFrame *input;
117
118         char *path;
119 };
120
121
122
123
124 class FrameWriterUnit : public LoadClient
125 {
126 public:
127         FrameWriterUnit(FrameWriter *server);
128         virtual ~FrameWriterUnit();
129
130         void process_package(LoadPackage *package);
131
132         FrameWriter *server;
133         VFrame *output;
134 };
135
136
137
138
139
140 class FrameWriter : public LoadServer
141 {
142 public:
143         FrameWriter(FileList *file, int cpus);
144         ~FrameWriter();
145
146         void write_frames(VFrame ***frames, int len);
147         void init_packages();
148         LoadClient* new_client();
149         LoadPackage* new_package();
150
151         FileList *file;
152         VFrame ***frames;
153         int len;
154 };
155
156
157
158
159
160
161
162
163 #endif