svn merge ^/trunk/blender -r49107:49118
authorCampbell Barton <ideasman42@gmail.com>
Sun, 22 Jul 2012 16:10:06 +0000 (16:10 +0000)
committerCampbell Barton <ideasman42@gmail.com>
Sun, 22 Jul 2012 16:10:06 +0000 (16:10 +0000)
1  2 
source/blender/blenkernel/intern/mask.c
source/blender/makesrna/intern/rna_scene.c

index e63dfdf4445372f244a114902e6c4ff53a7a2999,6fe838666c5f2285e5f1c3b8133805922a4ef8de..e39bb7a02e1656150ce8577c956da042f7d0deb1
  
  #include "raskter.h"
  
 +#ifdef USE_MANGO_MASK_CACHE_HACK
 +
 +#include "BLI_threads.h"
 +
 +typedef struct MaskRasterCache {
 +      float *buffer;
 +      int width, height;
 +      short do_aspect_correct;
 +      short do_mask_aa;
 +      short do_feather;
 +
 +      ListBase layers;
 +} MaskRasterCache;
 +#endif
 +
  static MaskSplinePoint *mask_spline_point_next(MaskSpline *spline, MaskSplinePoint *points_array, MaskSplinePoint *point)
  {
        if (point == &points_array[spline->tot_point - 1]) {
@@@ -125,7 -110,7 +125,7 @@@ static BezTriple *mask_spline_point_pre
                if (spline->flag & MASK_SPLINE_CYCLIC) {
                        return &(points_array[0].bezt);
                }
-               else  {
+               else {
                        return NULL;
                }
        }
@@@ -1468,7 -1453,6 +1468,7 @@@ void BKE_mask_layer_free(MaskLayer *mas
        MEM_freeN(masklay);
  }
  
 +
  void BKE_mask_layer_free_list(ListBase *masklayers)
  {
        MaskLayer *masklay = masklayers->first;
  
                masklay = masklay_next;
        }
 +
  }
  
 +#ifdef USE_MANGO_MASK_CACHE_HACK
 +void BKE_mask_raster_cache_free(Mask *mask)
 +{
 +      MaskRasterCache *cache = mask->raster_cache;
 +
 +      if (cache) {
 +              MaskLayer *layer;
 +
 +              layer = cache->layers.first;
 +              while (layer) {
 +                      MaskLayer *layer_next = layer->next;
 +
 +                      BKE_mask_layer_free(layer);
 +                      layer = layer_next;
 +              }
 +
 +              MEM_freeN(cache->buffer);
 +              MEM_freeN(cache);
 +
 +              mask->raster_cache = NULL;
 +      }
 +}
 +#endif
 +
  void BKE_mask_free(Mask *mask)
  {
        BKE_mask_layer_free_list(&mask->masklayers);
 +
 +#ifdef USE_MANGO_MASK_CACHE_HACK
 +      if (mask->raster_cache) {
 +              BKE_mask_raster_cache_free(mask);
 +
 +              mask->raster_cache = NULL;
 +      }
 +#endif
  }
  
  void BKE_mask_unlink(Main *bmain, Mask *mask)
@@@ -2531,157 -2482,16 +2531,157 @@@ int BKE_mask_get_duration(Mask *mask
        return MAX2(1, mask->efra - mask->sfra);
  }
  
 +#ifdef USE_MANGO_MASK_CACHE_HACK
 +static int mask_point_compare(MaskSplinePoint *point_a, MaskSplinePoint *point_b)
 +{
 +      if (point_a->tot_uw != point_b->tot_uw) {
 +              return FALSE;
 +      }
 +
 +      if (memcmp(&point_a->bezt, &point_b->bezt, sizeof(BezTriple))) {
 +              return FALSE;
 +      }
 +
 +      if (memcmp(&point_a->uw, &point_b->uw, 2 * point_a->tot_uw * sizeof(float))) {
 +              return FALSE;
 +      }
 +
 +      return TRUE;
 +}
 +
 +static int mask_points_compare(MaskSplinePoint *points_a, MaskSplinePoint *points_b, int tot_point)
 +{
 +      MaskSplinePoint *point_a = points_a;
 +      MaskSplinePoint *point_b = points_b;
 +      int a = tot_point;
 +
 +      /* deform points can be NULL */
 +      if (point_a == NULL || point_b == NULL) {
 +              return ((point_a == NULL) && (point_b == NULL));
 +      }
 +
 +      while (a--) {
 +              if (!mask_point_compare(point_a, point_b)) {
 +                      return FALSE;
 +              }
 +
 +              point_a++;
 +              point_b++;
 +      }
 +
 +      return TRUE;
 +}
 +
 +static int mask_spline_compare(MaskSpline *spline_a, MaskSpline *spline_b)
 +{
 +      if (spline_a->flag != spline_b->flag ||
 +          spline_a->tot_point != spline_b->tot_point ||
 +          spline_a->weight_interp != spline_b->weight_interp)
 +      {
 +              return FALSE;
 +      }
 +
 +      if (!mask_points_compare(spline_a->points, spline_b->points, spline_a->tot_point)) {
 +              return FALSE;
 +      }
 +
 +      return mask_points_compare(spline_a->points_deform, spline_b->points_deform, spline_a->tot_point);
 +}
 +
 +static int mask_splines_compare(ListBase *base_a, ListBase *base_b)
 +{
 +      MaskSpline *spline_a, *spline_b;
 +
 +      for (spline_a = base_a->first, spline_b = base_b->first;
 +           spline_a && spline_b;
 +           spline_a = spline_a->next, spline_b = spline_b->next)
 +      {
 +              if (!mask_spline_compare(spline_a, spline_b)) {
 +                      return FALSE;
 +              }
 +      }
 +
 +      if (spline_a || spline_b)
 +              return FALSE;
 +
 +      return TRUE;
 +}
 +
 +static int mask_layer_compare(MaskLayer *layer_a, MaskLayer *layer_b)
 +{
 +      if (layer_a->alpha != layer_b->alpha ||
 +          layer_a->blend != layer_b->blend ||
 +          layer_a->blend_flag != layer_b->blend_flag ||
 +          layer_a->flag != layer_b->flag ||
 +          layer_a->restrictflag != layer_b->restrictflag)
 +      {
 +              return FALSE;
 +      }
 +
 +      if (strcmp(layer_a->name, layer_b->name))
 +              return FALSE;
 +
 +      return mask_splines_compare(&layer_a->splines, &layer_b->splines);
 +}
 +
 +static int mask_layers_compare(ListBase *base_a, ListBase *base_b)
 +{
 +      MaskLayer *layer_a, *layer_b;
 +
 +      for (layer_a = base_a->first, layer_b = base_b->first;
 +           layer_a && layer_b;
 +           layer_a = layer_a->next, layer_b = layer_b->next)
 +      {
 +              if (!mask_layer_compare(layer_a, layer_b)) {
 +                      return FALSE;
 +              }
 +      }
 +
 +      if (layer_a || layer_b)
 +              return FALSE;
 +
 +      return TRUE;
 +}
 +#endif
 +
  /* rasterization */
 -void BKE_mask_rasterize_layers(ListBase *masklayers, int width, int height, float *buffer,
 +
 +/* XXX: mask is only passed here to access rasterization cache
 + *      this MUST be removed as soon as tile-based rasterization would be here
 + */
 +void BKE_mask_rasterize_layers(Mask *mask, ListBase *masklayers, int width, int height, float *buffer,
                                 const short do_aspect_correct, const short do_mask_aa,
                                 const short do_feather)
  {
 +      MaskRasterCache *cache = mask->raster_cache;
        MaskLayer *masklay;
  
        /* temp blending buffer */
        const int buffer_size = width * height;
 -      float *buffer_tmp = MEM_mallocN(sizeof(float) * buffer_size, __func__);
 +      float *buffer_tmp;
 +
 +#ifdef USE_MANGO_MASK_CACHE_HACK
 +      BLI_lock_thread(LOCK_CUSTOM1);
 +
 +      if (cache &&
 +          cache->width == width &&
 +          cache->height == height &&
 +          cache->do_aspect_correct == do_aspect_correct &&
 +          cache->do_mask_aa == do_mask_aa &&
 +          cache->do_feather == do_feather &&
 +          mask_layers_compare(&cache->layers, &mask->masklayers))
 +      {
 +              memcpy(buffer, cache->buffer, sizeof(float) * buffer_size);
 +
 +              BLI_unlock_thread(LOCK_CUSTOM1);
 +
 +              return;
 +      }
 +
 +      BLI_unlock_thread(LOCK_CUSTOM1);
 +#endif
 +
 +      buffer_tmp = MEM_mallocN(sizeof(float) * buffer_size, __func__);
  
        for (masklay = masklayers->first; masklay; masklay = masklay->next) {
                MaskSpline *spline;
                        }
                }
  
-               if(do_mask_aa){
+               if (do_mask_aa) {
                        //PLX_antialias_buffer(buffer,width,height);
                }
                /* clamp at the end */
                clamp_vn_vn(buffer, buffer_size);
        }
        MEM_freeN(buffer_tmp);
 +
 +#ifdef USE_MANGO_MASK_CACHE_HACK
 +      BLI_lock_thread(LOCK_CUSTOM1);
 +
 +      BKE_mask_raster_cache_free(mask);
 +
 +      cache = MEM_callocN(sizeof(MaskRasterCache), "mask raster cache");
 +
 +      cache->buffer = MEM_mallocN(sizeof(float) * buffer_size, "mask raster cache buffer");
 +
 +      BKE_mask_layer_copy_list(&cache->layers, masklayers);
 +
 +      memcpy(cache->buffer, buffer, sizeof(float) * buffer_size);
 +
 +      cache->width = width;
 +      cache->height = height;
 +      cache->do_aspect_correct = do_aspect_correct;
 +      cache->do_mask_aa = do_mask_aa;
 +      cache->do_feather = do_feather;
 +
 +      mask->raster_cache = cache;
 +
 +      BLI_unlock_thread(LOCK_CUSTOM1);
 +#endif
  }
  
  #ifdef __PLX_RASKTER_MT__
- void BKE_mask_init_layers(Mask *mask, struct layer_init_data *mlayer_data, int width, int height, const short do_aspect_correct){
+ void BKE_mask_init_layers(Mask *mask, struct layer_init_data *mlayer_data, int width, int height, const short do_aspect_correct)
+ {
        MaskLayer *masklay;
        int numLayers=0;
        int currLayer=0;
@@@ -2908,5 -2695,5 +2909,5 @@@ void BKE_mask_rasterize(Mask *mask, in
                          const short do_aspect_correct, const short do_mask_aa,
                          const short do_feather)
  {
 -      BKE_mask_rasterize_layers(&mask->masklayers, width, height, buffer, do_aspect_correct, do_mask_aa, do_feather);
 +      BKE_mask_rasterize_layers(mask, &mask->masklayers, width, height, buffer, do_aspect_correct, do_mask_aa, do_feather);
  }
index f4f04ee0d42f6960492ae109c6332a5eba5a406e,b66f682073410600440a11b4a11a4900fd7dce56..bcd76c7f2cd87bc509706fc8958046319f4e0347
@@@ -2961,17 -2961,6 +2961,17 @@@ static void rna_def_scene_image_format_
        RNA_def_property_range(prop, 0.0f, 10.0f);
        RNA_def_property_ui_text(prop, "G", "Log conversion gamma");
        RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, NULL);
 +
 +      /* color management */
 +      prop = RNA_def_property(srna, "view_settings", PROP_POINTER, PROP_NONE);
 +      RNA_def_property_pointer_sdna(prop, NULL, "view_settings");
 +      RNA_def_property_struct_type(prop, "ColorManagedViewSettings");
 +      RNA_def_property_ui_text(prop, "View Settings", "Color management settings applied on image before saving");
 +
 +      prop = RNA_def_property(srna, "display_settings", PROP_POINTER, PROP_NONE);
 +      RNA_def_property_pointer_sdna(prop, NULL, "display_settings");
 +      RNA_def_property_struct_type(prop, "ColorManagedDisplaySettings");
 +      RNA_def_property_ui_text(prop, "Display Settings", "Settings of device saved image would be displayed on");
  }
  
  static void rna_def_scene_ffmpeg_settings(BlenderRNA *brna)
        prop = RNA_def_property(srna, "video_bitrate", PROP_INT, PROP_NONE);
        RNA_def_property_int_sdna(prop, NULL, "video_bitrate");
        RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
-       RNA_def_property_range(prop, 1, 14000);
+       RNA_def_property_range(prop, 1, 64000);
        RNA_def_property_ui_text(prop, "Bitrate", "Video bitrate (kb/s)");
        RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, NULL);