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 VFrame* FrameCache::get_frame_ptr(int64_t position, int layer, double frame_rate,
  83                 int color_model, int w, int h, int source_id)
  84 {
  85         lock->lock("FrameCache::get_frame_ptr");
  86         VFrame *vframe = get_vframe(position, w, h, color_model,
  87                         layer, frame_rate, source_id);
  88         if( vframe ) return vframe;  // not unlocked
  89         lock->unlock();
  90         return 0;
  91 }
  92
  93 VFrame *FrameCache::get_vframe(int64_t position, int w, int h,
  94                 int color_model, int layer, double frame_rate,
  95                 int source_id)
  96 {
  97         FrameCacheItem *item = 0;
  98         int ret = frame_exists(position, layer, frame_rate,
  99                         w, h, color_model, &item, source_id);
 100         if( ret && position >= 0 && item )
 101                 item->age = get_age();
 102         return ret && item ? item->data : 0;
 103 }
 104
 105 VFrame *FrameCache::get_frame(int64_t position, int w, int h,
 106                 int color_model, int layer, double frame_rate,
 107                 int source_id)
 108 {
 109         lock->lock("FrameCache::get_frame");
 110         VFrame *frame = get_vframe(position, w, h,
 111                         color_model, layer, frame_rate, source_id);
 112         lock->unlock();
 113         return frame;
 114 }
 115
 116 // Returns 1 if frame exists in cache and copies it to the frame argument.
 117 int FrameCache::get_frame(VFrame *frame, int64_t position,
 118                 int layer, double frame_rate, int source_id)
 119 {
 120         lock->lock("FrameCache::get_frame");
 121         VFrame *vframe = get_vframe(position,
 122                         frame->get_w(), frame->get_h(), frame->get_color_model(),
 123                         layer, frame_rate, source_id);
 124         if( vframe )
 125                 frame->copy_from(vframe);
 126         lock->unlock();
 127         return vframe ? 1 : 0;
 128 }
 129
 130
 131 void FrameCache::put_vframe(VFrame *frame, int64_t position,
 132                 int layer, double frame_rate, int source_id)
 133 {
 134         FrameCacheItem *item = new FrameCacheItem;
 135         item->data = frame;
 136         item->position = position;
 137         item->layer = layer;
 138         item->frame_rate = frame_rate;
 139         item->source_id = source_id;
 140         item->age = position < 0 ? INT_MAX : get_age();
 141         put_item(item);
 142 }
 143
 144 // Puts frame in cache if the frame doesn't already exist.
 145 void FrameCache::put_frame(VFrame *frame, int64_t position,
 146                 int layer, double frame_rate, int use_copy, Indexable *idxbl)
 147 {
 148         int source_id = idxbl ? idxbl->id : -1;
 149         lock->lock("FrameCache::put_frame");
 150         VFrame *vframe = get_vframe(position,
 151                         frame->get_w(), frame->get_h(), frame->get_color_model(),
 152                         layer, frame_rate, source_id);
 153         if( !vframe ) {
 154                 if( use_copy ) frame = new VFrame(*frame);
 155                 put_vframe(frame, position, layer, frame_rate, source_id);
 156         }
 157         lock->unlock();
 158 }
 159
 160 // get vframe for keys, overwrite frame if found
 161 int FrameCache::get_cache_frame(VFrame *frame, int64_t position,
 162                 int layer, double frame_rate)
 163 {
 164         lock->lock("FrameCache::get_cache_frame");
 165         VFrame *vframe = get_vframe(position,
 166                 frame->get_w(), frame->get_h(), frame->get_color_model(),
 167                 layer, frame_rate, -1);
 168         if( vframe )
 169                 frame->copy_from(vframe);
 170         lock->unlock();
 171         return vframe ? 1 : 0;
 172 }
 173
 174 // adds or replaces vframe, consumes frame if not use_copy
 175 void FrameCache::put_cache_frame(VFrame *frame, int64_t position,
 176                 int layer, double frame_rate, int use_copy)
 177 {
 178         lock->lock("FrameCache::put_cache_frame");
 179         FrameCacheItem *item = 0;
 180         int w = frame->get_w(), h = frame->get_h();
 181         int color_model = frame->get_color_model();
 182         int ret = frame_exists(position, layer, frame_rate,
 183                         w, h, color_model, &item, -1);
 184         if( use_copy ) {
 185 // do not use shm here, puts too much pressure on 32bit systems
 186                 VFrame *vframe = new VFrame(w, h, color_model, 0);
 187                 vframe->copy_from(frame);
 188                 frame = vframe;
 189         }
 190         if( ret ) {
 191                 delete item->data;
 192                 item->data = frame;
 193         }
 194         else
 195                 put_vframe(frame, position, layer, frame_rate, -1);
 196         lock->unlock();
 197 }
 198
 199
 200 int FrameCache::frame_exists(VFrame *format, int64_t position,
 201         int layer, double frame_rate, FrameCacheItem **item_return, int source_id)
 202 {
 203         FrameCacheItem *item = (FrameCacheItem*)get_item(position);
 204         for( ; item && item->position == position; item = (FrameCacheItem*)item->next ) {
 205                 if( !EQUIV(item->frame_rate, frame_rate) ) continue;
 206                 if( layer != item->layer ) continue;
 207                 if( !format->equivalent(item->data, 0) ) continue;
 208                 if( source_id == -1 || item->source_id == -1 ||
 209                     source_id == item->source_id ) {
 210                         *item_return = item;
 211                         return 1;
 212                 }
 213         }
 214         return 0;
 215 }
 216
 217 int FrameCache::frame_exists(int64_t position, int layer, double frame_rate,
 218                 int w, int h, int color_model, FrameCacheItem **item_return, int source_id)
 219 {
 220         FrameCacheItem *item = (FrameCacheItem*)get_item(position);
 221         for( ; item && item->position == position ; item = (FrameCacheItem*)item->next ) {
 222                 if( !EQUIV(item->frame_rate, frame_rate) ) continue;
 223                 if( layer != item->layer ) continue;
 224                 if( color_model != item->data->get_color_model() ) continue;
 225                 if( w != item->data->get_w() ) continue;
 226                 if( h != item->data->get_h() ) continue;
 227                 if( source_id == -1 || item->source_id == -1 ||
 228                     source_id == item->source_id ) {
 229                         *item_return = item;
 230                         return 1;
 231                 }
 232         }
 233         return 0;
 234 }
 235
 236
 237 void FrameCache::dump()
 238 {
 239 //      lock->lock("FrameCache::dump");
 240         printf("FrameCache::dump 1 %d\n", total());
 241         FrameCacheItem *item = (FrameCacheItem *)first;
 242         while( item ) {
 243                 printf("  position=%jd frame_rate=%f age=%d size=%ld\n",
 244                         item->position, item->frame_rate, item->age,
 245                         item->data->get_data_size());
 246                 item = (FrameCacheItem*)item->next;
 247         }
 248 //      lock->unlock();
 249 }
 250
 251
 252
 253