libmpeg3/video/mpeg3cache.c

   1 #include "mpeg3private.h"
   2 #include <stdlib.h>
   3 #include <string.h>
   4
   5
   6
   7
   8 // This is basically qtcache.c with quicktime_ replaced by mpeg3_
   9
  10
  11 mpeg3_cache_t* mpeg3_new_cache()
  12 {
  13         mpeg3_cache_t *result = calloc(1, sizeof(mpeg3_cache_t));
  14         return result;
  15 }
  16
  17 void mpeg3_delete_cache(mpeg3_cache_t *ptr)
  18 {
  19         if(ptr->frames)
  20         {
  21                 int i;
  22                 for(i = 0; i < ptr->allocation; i++)
  23                 {
  24                         mpeg3_cacheframe_t *frame = &ptr->frames[i];
  25                         if(frame->y) free(frame->y);
  26                         if(frame->u) free(frame->u);
  27                         if(frame->v) free(frame->v);
  28                 }
  29                 free(ptr->frames);
  30                 free(ptr);
  31         }
  32 }
  33
  34 void mpeg3_reset_cache(mpeg3_cache_t *ptr)
  35 {
  36         ptr->total = 0;
  37 }
  38
  39 void mpeg3_cache_put_frame(mpeg3_cache_t *ptr,
  40         int64_t frame_number,
  41         unsigned char *y,
  42         unsigned char *u,
  43         unsigned char *v,
  44         int y_size,
  45         int u_size,
  46         int v_size)
  47 {
  48         mpeg3_cacheframe_t *frame = 0;
  49         int i;
  50
  51 //printf("mpeg3_put_frame 1\n");
  52 // Get existing frame
  53         for(i = 0; i < ptr->total; i++)
  54         {
  55                 if(ptr->frames[i].frame_number == frame_number)
  56                 {
  57                         frame = &ptr->frames[i];
  58                         break;
  59                 }
  60         }
  61
  62
  63         if(!frame)
  64         {
  65                 if(ptr->total >= ptr->allocation)
  66                 {
  67                         int new_allocation = ptr->allocation * 2;
  68 //printf("mpeg3_put_frame 10 %d\n", new_allocation);
  69                         if(!new_allocation) new_allocation = 32;
  70                         ptr->frames = realloc(ptr->frames,
  71                                 sizeof(mpeg3_cacheframe_t) * new_allocation);
  72                         bzero(ptr->frames + ptr->total,
  73                                 sizeof(mpeg3_cacheframe_t) * (new_allocation - ptr->allocation));
  74 //printf("mpeg3_put_frame 20 %d %d %d\n", new_allocation, ptr->allocation, ptr->total);
  75                         ptr->allocation = new_allocation;
  76                 }
  77
  78                 frame = &ptr->frames[ptr->total];
  79 //printf("mpeg3_put_frame 30 %d %p %p %p\n", ptr->total, frame->y, frame->u, frame->v);
  80                 ptr->total++;
  81
  82 // Memcpy is a lot slower than just dropping the seeking frames.
  83                 if(y)
  84                 {
  85                         frame->y = realloc(frame->y, y_size);
  86                         frame->y_size = y_size;
  87                         memcpy(frame->y, y, y_size);
  88                 }
  89
  90                 if(u)
  91                 {
  92                         frame->u = realloc(frame->u, u_size);
  93                         frame->u_size = u_size;
  94                         memcpy(frame->u, u, u_size);
  95                 }
  96
  97                 if(v)
  98                 {
  99                         frame->v = realloc(frame->v, v_size);
 100                         frame->v_size = v_size;
 101                         memcpy(frame->v, v, v_size);
 102                 }
 103                 frame->frame_number = frame_number;
 104         }
 105 //printf("mpeg3_put_frame 100\n");
 106 }
 107
 108 int mpeg3_cache_get_frame(mpeg3_cache_t *ptr,
 109         int64_t frame_number,
 110         unsigned char **y,
 111         unsigned char **u,
 112         unsigned char **v)
 113 {
 114         int i;
 115
 116         for(i = 0; i < ptr->total; i++)
 117         {
 118                 mpeg3_cacheframe_t *frame = &ptr->frames[i];
 119                 if(frame->frame_number == frame_number)
 120                 {
 121
 122                         *y = frame->y;
 123                         *u = frame->u;
 124                         *v = frame->v;
 125                         return 1;
 126                         break;
 127                 }
 128         }
 129
 130         return 0;
 131 }
 132
 133
 134 int mpeg3_cache_has_frame(mpeg3_cache_t *ptr,
 135         int64_t frame_number)
 136 {
 137         int i;
 138
 139         for(i = 0; i < ptr->total; i++)
 140         {
 141                 mpeg3_cacheframe_t *frame = &ptr->frames[i];
 142                 if(frame->frame_number == frame_number)
 143                         return 1;
 144         }
 145
 146         return 0;
 147 }
 148
 149 int64_t mpeg3_cache_usage(mpeg3_cache_t *ptr)
 150 {
 151         int64_t result = 0;
 152         int i;
 153         for(i = 0; i < ptr->allocation; i++)
 154         {
 155                 mpeg3_cacheframe_t *frame = &ptr->frames[i];
 156                 result += frame->y_size + frame->u_size + frame->v_size;
 157         }
 158         return result;
 159 }
 160
 161
 162