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=%ld\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