libass/ass_bitmap.c

   1 // -*- c-basic-offset: 8; indent-tabs-mode: t -*-
   2 // vim:ts=8:sw=8:noet:ai:
   3 /*
   4  * Copyright (C) 2006 Evgeniy Stepanov <eugeni.stepanov@gmail.com>
   5  *
   6  * This file is part of libass.
   7  *
   8  * libass is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation; either version 2 of the License, or
  11  * (at your option) any later version.
  12  *
  13  * libass is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License along
  19  * with libass; if not, write to the Free Software Foundation, Inc.,
  20  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  21  */
  22
  23 #include <stdlib.h>
  24 #include <string.h>
  25 #include <math.h>
  26 #include <assert.h>
  27 #include <ft2build.h>
  28 #include FT_GLYPH_H
  29
  30 #include "mputils.h"
  31 #include "ass_bitmap.h"
  32
  33 struct ass_synth_priv_s {
  34         int tmp_w, tmp_h;
  35         unsigned short* tmp;
  36
  37         int g_r;
  38         int g_w;
  39
  40         unsigned *g;
  41         unsigned *gt2;
  42
  43         double radius;
  44 };
  45
  46 static const unsigned int maxcolor = 255;
  47 static const unsigned base = 256;
  48
  49 static int generate_tables(ass_synth_priv_t* priv, double radius)
  50 {
  51         double A = log(1.0/base)/(radius*radius*2);
  52         int mx, i;
  53         double volume_diff, volume_factor = 0;
  54         unsigned volume;
  55
  56         if (priv->radius == radius)
  57                 return 0;
  58         else
  59                 priv->radius = radius;
  60
  61         priv->g_r = ceil(radius);
  62         priv->g_w = 2*priv->g_r+1;
  63
  64         if (priv->g_r) {
  65                 priv->g = realloc(priv->g, priv->g_w * sizeof(unsigned));
  66                 priv->gt2 = realloc(priv->gt2, 256 * priv->g_w * sizeof(unsigned));
  67                 if (priv->g==NULL || priv->gt2==NULL) {
  68                         return -1;
  69                 }
  70         }
  71
  72         if (priv->g_r) {
  73                 // gaussian curve with volume = 256
  74                 for (volume_diff=10000000; volume_diff>0.0000001; volume_diff*=0.5){
  75                         volume_factor+= volume_diff;
  76                         volume=0;
  77                         for (i = 0; i<priv->g_w; ++i) {
  78                                 priv->g[i] = (unsigned)(exp(A * (i-priv->g_r)*(i-priv->g_r)) * volume_factor + .5);
  79                                 volume+= priv->g[i];
  80                         }
  81                         if(volume>256) volume_factor-= volume_diff;
  82                 }
  83                 volume=0;
  84                 for (i = 0; i<priv->g_w; ++i) {
  85                         priv->g[i] = (unsigned)(exp(A * (i-priv->g_r)*(i-priv->g_r)) * volume_factor + .5);
  86                         volume+= priv->g[i];
  87                 }
  88
  89                 // gauss table:
  90                 for(mx=0;mx<priv->g_w;mx++){
  91                         for(i=0;i<256;i++){
  92                                 priv->gt2[mx+i*priv->g_w] = i*priv->g[mx];
  93                         }
  94                 }
  95         }
  96
  97         return 0;
  98 }
  99
 100 static void resize_tmp(ass_synth_priv_t* priv, int w, int h)
 101 {
 102         if (priv->tmp_w >= w && priv->tmp_h >= h)
 103                 return;
 104         if (priv->tmp_w == 0)
 105                 priv->tmp_w = 64;
 106         if (priv->tmp_h == 0)
 107                 priv->tmp_h = 64;
 108         while (priv->tmp_w < w) priv->tmp_w *= 2;
 109         while (priv->tmp_h < h) priv->tmp_h *= 2;
 110         if (priv->tmp)
 111                 free(priv->tmp);
 112         priv->tmp = malloc((priv->tmp_w + 1) * priv->tmp_h * sizeof(short));
 113 }
 114
 115 ass_synth_priv_t* ass_synth_init(double radius)
 116 {
 117         ass_synth_priv_t* priv = calloc(1, sizeof(ass_synth_priv_t));
 118         generate_tables(priv, radius);
 119         return priv;
 120 }
 121
 122 void ass_synth_done(ass_synth_priv_t* priv)
 123 {
 124         if (priv->tmp)
 125                 free(priv->tmp);
 126         if (priv->g)
 127                 free(priv->g);
 128         if (priv->gt2)
 129                 free(priv->gt2);
 130         free(priv);
 131 }
 132
 133 static bitmap_t* alloc_bitmap(int w, int h)
 134 {
 135         bitmap_t* bm;
 136         bm = calloc(1, sizeof(bitmap_t));
 137         bm->buffer = malloc(w*h);
 138         bm->w = w;
 139         bm->h = h;
 140         bm->left = bm->top = 0;
 141         return bm;
 142 }
 143
 144 void ass_free_bitmap(bitmap_t* bm)
 145 {
 146         if (bm) {
 147                 if (bm->buffer) free(bm->buffer);
 148                 free(bm);
 149         }
 150 }
 151
 152 static bitmap_t* copy_bitmap(const bitmap_t* src)
 153 {
 154         bitmap_t* dst = alloc_bitmap(src->w, src->h);
 155         dst->left = src->left;
 156         dst->top = src->top;
 157         memcpy(dst->buffer, src->buffer, src->w * src->h);
 158         return dst;
 159 }
 160
 161 static int check_glyph_area(FT_Glyph glyph)
 162 {
 163         FT_BBox bbox;
 164         long long dx, dy;
 165         FT_Glyph_Get_CBox(glyph, FT_GLYPH_BBOX_TRUNCATE, &bbox);
 166         dx = bbox.xMax - bbox.xMin;
 167         dy = bbox.yMax - bbox.yMin;
 168         if (dx * dy > 8000000) {
 169                 mp_msg(MSGT_ASS, MSGL_WARN, MSGTR_LIBASS_GlyphBBoxTooLarge, (int)dx, (int)dy);
 170                 return 1;
 171         } else
 172                 return 0;
 173 }
 174
 175 static bitmap_t* glyph_to_bitmap_internal(FT_Glyph glyph, int bord)
 176 {
 177         FT_BitmapGlyph bg;
 178         FT_Bitmap* bit;
 179         bitmap_t* bm;
 180         int w, h;
 181         unsigned char* src;
 182         unsigned char* dst;
 183         int i;
 184         int error;
 185
 186         if (check_glyph_area(glyph))
 187                 return 0;
 188         error = FT_Glyph_To_Bitmap(&glyph, FT_RENDER_MODE_NORMAL, 0, 0);
 189         if (error) {
 190                 mp_msg(MSGT_ASS, MSGL_WARN, MSGTR_LIBASS_FT_Glyph_To_BitmapError, error);
 191                 return 0;
 192         }
 193
 194         bg = (FT_BitmapGlyph)glyph;
 195         bit = &(bg->bitmap);
 196         if (bit->pixel_mode != FT_PIXEL_MODE_GRAY) {
 197                 mp_msg(MSGT_ASS, MSGL_WARN, MSGTR_LIBASS_UnsupportedPixelMode, (int)(bit->pixel_mode));
 198                 FT_Done_Glyph(glyph);
 199                 return 0;
 200         }
 201
 202         w = bit->width;
 203         h = bit->rows;
 204         bm = alloc_bitmap(w + 2*bord, h + 2*bord);
 205         memset(bm->buffer, 0, bm->w * bm->h);
 206         bm->left = bg->left - bord;
 207         bm->top = - bg->top - bord;
 208
 209         src = bit->buffer;
 210         dst = bm->buffer + bord + bm->w * bord;
 211         for (i = 0; i < h; ++i) {
 212                 memcpy(dst, src, w);
 213                 src += bit->pitch;
 214                 dst += bm->w;
 215         }
 216
 217         FT_Done_Glyph(glyph);
 218         return bm;
 219 }
 220
 221 /**
 222  * \brief fix outline bitmap and generate shadow bitmap
 223  * Two things are done here:
 224  * 1. Glyph bitmap is subtracted from outline bitmap. This way looks much better in some cases.
 225  * 2. Shadow bitmap is created as a sum of glyph and outline bitmaps.
 226  */
 227 static bitmap_t* fix_outline_and_shadow(bitmap_t* bm_g, bitmap_t* bm_o)
 228 {
 229         int x, y;
 230         const int l = bm_o->left > bm_g->left ? bm_o->left : bm_g->left;
 231         const int t = bm_o->top > bm_g->top ? bm_o->top : bm_g->top;
 232         const int r = bm_o->left + bm_o->w < bm_g->left + bm_g->w ? bm_o->left + bm_o->w : bm_g->left + bm_g->w;
 233         const int b = bm_o->top + bm_o->h < bm_g->top + bm_g->h ? bm_o->top + bm_o->h : bm_g->top + bm_g->h;
 234
 235         bitmap_t* bm_s = copy_bitmap(bm_o);
 236
 237         unsigned char* g = bm_g->buffer + (t - bm_g->top) * bm_g->w + (l - bm_g->left);
 238         unsigned char* o = bm_o->buffer + (t - bm_o->top) * bm_o->w + (l - bm_o->left);
 239         unsigned char* s = bm_s->buffer + (t - bm_s->top) * bm_s->w + (l - bm_s->left);
 240
 241         for (y = 0; y < b - t; ++y) {
 242                 for (x = 0; x < r - l; ++x) {
 243                         unsigned char c_g, c_o;
 244                         c_g = g[x];
 245                         c_o = o[x];
 246                         o[x] = (c_o > c_g) ? c_o - (c_g/2) : 0;
 247                         s[x] = (c_o < 0xFF - c_g) ? c_o + c_g : 0xFF;
 248                 }
 249                 g += bm_g->w;
 250                 o += bm_o->w;
 251                 s += bm_s->w;
 252         }
 253
 254         assert(bm_s);
 255         return bm_s;
 256 }
 257
 258 /**
 259  * \brief Blur with [[1,2,1]. [2,4,2], [1,2,1]] kernel
 260  * This blur is the same as the one employed by vsfilter.
 261  */
 262 static void be_blur(unsigned char *buf, int w, int h) {
 263         unsigned int x, y;
 264         unsigned int old_sum, new_sum;
 265
 266         for (y=0; y<h; y++) {
 267                 old_sum = 2 * buf[y*w];
 268                 for (x=0; x<w-1; x++) {
 269                         new_sum = buf[y*w+x] + buf[y*w+x+1];
 270                         buf[y*w+x] = (old_sum + new_sum) >> 2;
 271                         old_sum = new_sum;
 272                 }
 273         }
 274
 275         for (x=0; x<w; x++) {
 276                 old_sum = 2 * buf[x];
 277                 for (y=0; y<h-1; y++) {
 278                         new_sum = buf[y*w+x] + buf[(y+1)*w+x];
 279                         buf[y*w+x] = (old_sum + new_sum) >> 2;
 280                         old_sum = new_sum;
 281                 }
 282         }
 283 }
 284
 285 int glyph_to_bitmap(ass_synth_priv_t* priv_blur,
 286                 FT_Glyph glyph, FT_Glyph outline_glyph, bitmap_t** bm_g,
 287                 bitmap_t** bm_o, bitmap_t** bm_s, int be, double blur_radius)
 288 {
 289         int bord = be ? (be/4+1) : 0;
 290         blur_radius *= 2;
 291         bord = (blur_radius > 0.0) ? blur_radius : bord;
 292
 293         assert(bm_g && bm_o && bm_s);
 294
 295         *bm_g = *bm_o = *bm_s = 0;
 296
 297         if (glyph)
 298                 *bm_g = glyph_to_bitmap_internal(glyph, bord);
 299         if (!*bm_g)
 300                 return 1;
 301
 302         if (outline_glyph) {
 303                 *bm_o = glyph_to_bitmap_internal(outline_glyph, bord);
 304                 if (!*bm_o) {
 305                         ass_free_bitmap(*bm_g);
 306                         return 1;
 307                 }
 308         }
 309         if (*bm_o)
 310                 resize_tmp(priv_blur, (*bm_o)->w, (*bm_o)->h);
 311         resize_tmp(priv_blur, (*bm_g)->w, (*bm_g)->h);
 312
 313         if (be) {
 314                 while (be--) {
 315                         if (*bm_o)
 316                                 be_blur((*bm_o)->buffer, (*bm_o)->w, (*bm_o)->h);
 317                         else
 318                                 be_blur((*bm_g)->buffer, (*bm_g)->w, (*bm_g)->h);
 319                 }
 320         } else {
 321                 if (blur_radius > 0.0) {
 322                         generate_tables(priv_blur, blur_radius);
 323                         if (*bm_o)
 324                                 blur((*bm_o)->buffer, priv_blur->tmp, (*bm_o)->w, (*bm_o)->h, (*bm_o)->w, (int*)priv_blur->gt2, priv_blur->g_r, priv_blur->g_w);
 325                         else
 326                                 blur((*bm_g)->buffer, priv_blur->tmp, (*bm_g)->w, (*bm_g)->h, (*bm_g)->w, (int*)priv_blur->gt2, priv_blur->g_r, priv_blur->g_w);
 327                 }
 328         }
 329         if (*bm_o)
 330                 *bm_s = fix_outline_and_shadow(*bm_g, *bm_o);
 331         else
 332                 *bm_s = copy_bitmap(*bm_g);
 333
 334         assert(bm_s);
 335         return 0;
 336 }
 337