afb149f0f885757cbba9bdfa00167e3e01b1aa27
[goodguy/history.git] / cinelerra-5.1 / cinelerra / framecache.C
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 #include "bcsignals.h"
23 #include "clip.h"
24 #include "cstrdup.h"
25 #include "edl.h"
26 #include "framecache.h"
27 #include "indexable.h"
28 #include "mutex.h"
29 #include "vframe.h"
30
31
32 #include <limits.h>
33 #include <math.h>
34 #include <string.h>
35 #include <unistd.h>
36
37
38
39 FrameCacheItem::FrameCacheItem()
40  : CacheItemBase()
41 {
42         data = 0;
43         position = 0;
44         frame_rate = (double)30000.0 / 1001;
45 }
46
47 FrameCacheItem::~FrameCacheItem()
48 {
49         delete data;
50 }
51
52 int FrameCacheItem::get_size()
53 {
54         if(data) return data->get_data_size() + (path ? strlen(path)+1 : 0);
55         return 0;
56 }
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72 FrameCache::FrameCache()
73  : CacheBase()
74 {
75 }
76
77 FrameCache::~FrameCache()
78 {
79 }
80
81
82 // Returns 1 if frame exists in cache and copies it to the frame argument.
83 int FrameCache::get_frame(VFrame *frame, 
84         int64_t position,
85         int layer,
86         double frame_rate,
87         int source_id)
88 {
89         lock->lock("FrameCache::get_frame");
90         FrameCacheItem *result = 0;
91
92         if(frame_exists(frame,
93                 position, 
94                 layer,
95                 frame_rate,
96                 &result,
97                 source_id))
98         {
99                 if(result->data) 
100                 {
101 // Frame may have come from the readahead thread.
102 // Those frames are in the codec color model.
103 // But to pass frame_exists, they must be identical.
104 //                      BC_CModels::transfer(frame->get_rows(), 
105 //                              result->data->get_rows(),
106 //                              result->data->get_y(),
107 //                              result->data->get_u(),
108 //                              result->data->get_v(),
109 //                              frame->get_y(),
110 //                              frame->get_u(),
111 //                              frame->get_v(),
112 //                              0, 
113 //                              0, 
114 //                              result->data->get_w(), 
115 //                              result->data->get_h(),
116 //                              0, 
117 //                              0, 
118 //                              frame->get_w(), 
119 //                              frame->get_h(),
120 //                              result->data->get_color_model(), 
121 //                              frame->get_color_model(),
122 //                              0,
123 //                              result->data->get_w(),
124 //                              frame->get_w());
125
126
127                         frame->copy_from(result->data);
128
129
130 // This would have copied the color matrix for interpolate, but
131 // required the same plugin stack as the reader.
132 //                      frame->copy_stacks(result->data);
133                         frame->copy_params(result->data);
134                 }
135                 result->age = get_age();
136         }
137
138
139
140
141         lock->unlock();
142         if(result) return 1;
143         return 0;
144 }
145
146
147 VFrame* FrameCache::get_frame_ptr(int64_t position,
148         int layer,
149         double frame_rate,
150         int color_model,
151         int w,
152         int h,
153         int source_id)
154 {
155         lock->lock("FrameCache::get_frame_ptr");
156         FrameCacheItem *result = 0;
157         if(frame_exists(position,
158                 layer,
159                 frame_rate,
160                 color_model,
161                 w,
162                 h,
163                 &result,
164                 source_id))
165         {
166                 result->age = get_age();
167                 return result->data;
168         }
169
170
171         lock->unlock();
172         return 0;
173 }
174
175 // Puts frame in cache if enough space exists and the frame doesn't already
176 // exist.
177 void FrameCache::put_frame(VFrame *frame, int64_t position,
178         int layer, double frame_rate, int use_copy, Indexable *indexable)
179 {
180         lock->lock("FrameCache::put_frame");
181         FrameCacheItem *item = 0;
182         int source_id = -1;
183         if(indexable) source_id = indexable->id;
184
185 //printf("FrameCache::put_frame %d position=%jd\n", __LINE__, position);
186
187         if(frame_exists(frame, position, layer, frame_rate, &item, source_id)) {
188                 item->age = get_age();
189                 lock->unlock();
190                 return;
191         }
192
193
194         item = new FrameCacheItem;
195
196         item->data = use_copy ? new VFrame(*frame) : frame;
197
198 // Copy metadata
199         item->position = position;
200         item->layer = layer;
201         item->frame_rate = frame_rate;
202         item->source_id = source_id;
203         if(indexable) 
204                 item->path = cstrdup(indexable->path);
205
206         item->age = position < 0 ? INT_MAX : get_age();
207
208 //printf("FrameCache::put_frame %d position=%jd\n", __LINE__, position);
209         put_item(item);
210         lock->unlock();
211 }
212
213
214
215
216 int FrameCache::frame_exists(VFrame *format, int64_t position, 
217         int layer, double frame_rate, FrameCacheItem **item_return, int source_id)
218 {
219         FrameCacheItem *item = (FrameCacheItem*)get_item(position);
220 // printf("FrameCache::frame_exists %d item=%p item->position=%jd position=%jd\n",
221 // __LINE__,
222 // item,
223 // item ? item->position : 0,
224 // position);
225
226         while(item && item->position == position)
227         {
228 // printf("FrameCache::frame_exists %d %f,%f %d,%d %d,%d format match=%d item->data=%p\n",
229 // __LINE__,
230 // item->frame_rate,
231 // frame_rate,
232 // item->layer,
233 // layer,
234 // item->source_id,
235 // source_id,
236 // format->equivalent(item->data, 1),
237 // item->data);
238 // format->dump_params();
239
240 // This originally tested the frame stacks because a change in the 
241 // interpolate plugin could cause CR2 to interpolate or not interpolate.
242 // This was disabled.
243                 if(EQUIV(item->frame_rate, frame_rate) &&
244                         layer == item->layer &&
245                         format->equivalent(item->data, 0) &&
246                         (source_id == -1 || item->source_id == -1 || source_id == item->source_id))
247                 {
248                         *item_return = item;
249                         return 1;
250                 }
251                 else
252                         item = (FrameCacheItem*)item->next;
253         }
254         return 0;
255 }
256
257 int FrameCache::frame_exists(int64_t position, 
258         int layer,
259         double frame_rate,
260         int color_model,
261         int w,
262         int h,
263         FrameCacheItem **item_return,
264         int source_id)
265 {
266         FrameCacheItem *item = (FrameCacheItem*)get_item(position);
267         while(item && item->position == position)
268         {
269 // printf("FrameCache::frame_exists %d %f,%f %d,%d %d,%d %d,%d\n",
270 // __LINE__,
271 // item->frame_rate,
272 // frame_rate,
273 // item->layer,
274 // layer,
275 // item->data->get_color_model(),
276 // color_model,
277 // item->data->get_w(),
278 // w,
279 // item->data->get_h(),
280 // h);
281
282                 if(EQUIV(item->frame_rate, frame_rate) &&
283                         layer == item->layer &&
284                         color_model == item->data->get_color_model() &&
285                         w == item->data->get_w() &&
286                         h == item->data->get_h() &&
287                         (source_id == -1 || item->source_id == -1 || source_id == item->source_id))
288                 {
289                         *item_return = item;
290                         return 1;
291                 }
292                 else
293                         item = (FrameCacheItem*)item->next;
294         }
295         return 0;
296 }
297
298
299 void FrameCache::dump()
300 {
301 //      lock->lock("FrameCache::dump");
302         printf("FrameCache::dump 1 %d\n", total());
303         FrameCacheItem *item = (FrameCacheItem *)first;
304         while( item ) {
305                 printf("  position=%jd frame_rate=%f age=%d size=%jd\n", 
306                         item->position, item->frame_rate, item->age,
307                         item->data->get_data_size());
308                 item = (FrameCacheItem*)item->next;
309         }
310 //      lock->unlock();
311 }
312
313
314
315