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 // no context data since keyframe updates may vary input
 127                         frame->copy_from(result->data);
 128                 }
 129                 result->age = get_age();
 130         }
 131
 132
 133
 134
 135         lock->unlock();
 136         if(result) return 1;
 137         return 0;
 138 }
 139
 140
 141 VFrame* FrameCache::get_frame_ptr(int64_t position,
 142         int layer,
 143         double frame_rate,
 144         int color_model,
 145         int w,
 146         int h,
 147         int source_id)
 148 {
 149         lock->lock("FrameCache::get_frame_ptr");
 150         FrameCacheItem *result = 0;
 151         if(frame_exists(position,
 152                 layer,
 153                 frame_rate,
 154                 color_model,
 155                 w,
 156                 h,
 157                 &result,
 158                 source_id))
 159         {
 160                 result->age = get_age();
 161                 return result->data;
 162         }
 163
 164
 165         lock->unlock();
 166         return 0;
 167 }
 168
 169 // Puts frame in cache if enough space exists and the frame doesn't already
 170 // exist.
 171 void FrameCache::put_frame(VFrame *frame, int64_t position,
 172         int layer, double frame_rate, int use_copy, Indexable *indexable)
 173 {
 174         lock->lock("FrameCache::put_frame");
 175         FrameCacheItem *item = 0;
 176         int source_id = -1;
 177         if(indexable) source_id = indexable->id;
 178
 179 //printf("FrameCache::put_frame %d position=%jd\n", __LINE__, position);
 180
 181         if(frame_exists(frame, position, layer, frame_rate, &item, source_id)) {
 182                 item->age = get_age();
 183                 lock->unlock();
 184                 return;
 185         }
 186
 187
 188         item = new FrameCacheItem;
 189
 190         item->data = use_copy ? new VFrame(*frame) : frame;
 191
 192 // Copy metadata
 193         item->position = position;
 194         item->layer = layer;
 195         item->frame_rate = frame_rate;
 196         item->source_id = source_id;
 197         if(indexable)
 198                 item->path = cstrdup(indexable->path);
 199
 200         item->age = position < 0 ? INT_MAX : get_age();
 201
 202 //printf("FrameCache::put_frame %d position=%jd\n", __LINE__, position);
 203         put_item(item);
 204         lock->unlock();
 205 }
 206
 207
 208
 209
 210 int FrameCache::frame_exists(VFrame *format, int64_t position,
 211         int layer, double frame_rate, FrameCacheItem **item_return, int source_id)
 212 {
 213         FrameCacheItem *item = (FrameCacheItem*)get_item(position);
 214 // printf("FrameCache::frame_exists %d item=%p item->position=%jd position=%jd\n",
 215 // __LINE__,
 216 // item,
 217 // item ? item->position : 0,
 218 // position);
 219
 220         while(item && item->position == position)
 221         {
 222 // printf("FrameCache::frame_exists %d %f,%f %d,%d %d,%d format match=%d item->data=%p\n",
 223 // __LINE__,
 224 // item->frame_rate,
 225 // frame_rate,
 226 // item->layer,
 227 // layer,
 228 // item->source_id,
 229 // source_id,
 230 // format->equivalent(item->data, 1),
 231 // item->data);
 232 // format->dump_params();
 233
 234 // This originally tested the frame stacks because a change in the
 235 // interpolate plugin could cause CR2 to interpolate or not interpolate.
 236 // This was disabled.
 237                 if(EQUIV(item->frame_rate, frame_rate) &&
 238                         layer == item->layer &&
 239                         format->equivalent(item->data, 0) &&
 240                         (source_id == -1 || item->source_id == -1 || source_id == item->source_id))
 241                 {
 242                         *item_return = item;
 243                         return 1;
 244                 }
 245                 else
 246                         item = (FrameCacheItem*)item->next;
 247         }
 248         return 0;
 249 }
 250
 251 int FrameCache::frame_exists(int64_t position,
 252         int layer,
 253         double frame_rate,
 254         int color_model,
 255         int w,
 256         int h,
 257         FrameCacheItem **item_return,
 258         int source_id)
 259 {
 260         FrameCacheItem *item = (FrameCacheItem*)get_item(position);
 261         while(item && item->position == position)
 262         {
 263 // printf("FrameCache::frame_exists %d %f,%f %d,%d %d,%d %d,%d\n",
 264 // __LINE__,
 265 // item->frame_rate,
 266 // frame_rate,
 267 // item->layer,
 268 // layer,
 269 // item->data->get_color_model(),
 270 // color_model,
 271 // item->data->get_w(),
 272 // w,
 273 // item->data->get_h(),
 274 // h);
 275
 276                 if(EQUIV(item->frame_rate, frame_rate) &&
 277                         layer == item->layer &&
 278                         color_model == item->data->get_color_model() &&
 279                         w == item->data->get_w() &&
 280                         h == item->data->get_h() &&
 281                         (source_id == -1 || item->source_id == -1 || source_id == item->source_id))
 282                 {
 283                         *item_return = item;
 284                         return 1;
 285                 }
 286                 else
 287                         item = (FrameCacheItem*)item->next;
 288         }
 289         return 0;
 290 }
 291
 292
 293 void FrameCache::dump()
 294 {
 295 //      lock->lock("FrameCache::dump");
 296         printf("FrameCache::dump 1 %d\n", total());
 297         FrameCacheItem *item = (FrameCacheItem *)first;
 298         while( item ) {
 299                 printf("  position=%jd frame_rate=%f age=%d size=%ld\n",
 300                         item->position, item->frame_rate, item->age,
 301                         item->data->get_data_size());
 302                 item = (FrameCacheItem*)item->next;
 303         }
 304 //      lock->unlock();
 305 }
 306
 307
 308
 309