git.maemo.org Git - mafwsubrenderer/blob - gst-plugins-base-subtitles0.10/gst/videoscale/vs_fill_borders.c

   1 /*
   2  * Image Scaling Functions
   3  * Copyright (c) 2010 Sebastian Dröge <sebastian.droege@collabora.co.uk>
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  *
  15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  16  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  17  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  18  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
  19  * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  20  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  21  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  22  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  23  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
  24  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  25  * POSSIBILITY OF SUCH DAMAGE.
  26  */
  27
  28 #ifdef HAVE_CONFIG_H
  29 #include "config.h"
  30 #endif
  31
  32 #include <gst/gst.h>
  33 #include <string.h>
  34
  35 #include "vs_fill_borders.h"
  36 #include "gstvideoscaleorc.h"
  37
  38 #if G_BYTE_ORDER == G_LITTLE_ENDIAN
  39 #define READ_UINT32(ptr) GST_READ_UINT32_LE(ptr)
  40 #define READ_UINT16(ptr) GST_READ_UINT16_LE(ptr)
  41 #else
  42 #define READ_UINT32(ptr) GST_READ_UINT32_BE(ptr)
  43 #define READ_UINT16(ptr) GST_READ_UINT16_BE(ptr)
  44 #endif
  45
  46 void
  47 vs_fill_borders_RGBA (const VSImage * dest, const uint8_t * val)
  48 {
  49   int i;
  50   int top = dest->border_top, bottom = dest->border_bottom;
  51   int left = dest->border_left, right = dest->border_right;
  52   int width = dest->width;
  53   int height = dest->height;
  54   int real_width = dest->real_width;
  55   int stride = dest->stride;
  56   int tmp, tmp2;
  57   uint8_t *data;
  58   uint32_t v = READ_UINT32 (val);
  59
  60   data = dest->real_pixels;
  61   for (i = 0; i < top; i++) {
  62     orc_splat_u32 ((uint32_t *) data, v, real_width);
  63     data += stride;
  64   }
  65
  66   if (left || right) {
  67     tmp = height;
  68     tmp2 = (left + width) * 4;
  69     for (i = 0; i < tmp; i++) {
  70       orc_splat_u32 ((uint32_t *) data, v, left);
  71       orc_splat_u32 ((uint32_t *) (data + tmp2), v, right);
  72       data += stride;
  73     }
  74   } else {
  75     data += stride * height;
  76   }
  77
  78   for (i = 0; i < bottom; i++) {
  79     orc_splat_u32 ((uint32_t *) data, v, real_width);
  80     data += stride;
  81   }
  82 }
  83
  84 static void
  85 _memset_u24 (uint8_t * data, uint8_t val1, uint8_t val2, uint8_t val3,
  86     unsigned int n)
  87 {
  88   unsigned int i;
  89
  90   for (i = 0; i < n; i++) {
  91     data[0] = val1;
  92     data[1] = val2;
  93     data[2] = val3;
  94     data += 3;
  95   }
  96 }
  97
  98 void
  99 vs_fill_borders_RGB (const VSImage * dest, const uint8_t * val)
 100 {
 101   int i;
 102   int top = dest->border_top, bottom = dest->border_bottom;
 103   int left = dest->border_left, right = dest->border_right;
 104   int width = dest->width;
 105   int height = dest->height;
 106   int real_width = dest->real_width;
 107   int stride = dest->stride;
 108   int tmp, tmp2;
 109   uint8_t *data;
 110
 111   data = dest->real_pixels;
 112   for (i = 0; i < top; i++) {
 113     _memset_u24 (data, val[0], val[1], val[2], real_width);
 114     data += stride;
 115   }
 116
 117   if (left || right) {
 118     tmp = height;
 119     tmp2 = (left + width) * 3;
 120     for (i = 0; i < tmp; i++) {
 121       _memset_u24 (data, val[0], val[1], val[2], left);
 122       _memset_u24 (data + tmp2, val[0], val[1], val[2], right);
 123       data += stride;
 124     }
 125   } else {
 126     data += stride * height;
 127   }
 128
 129   for (i = 0; i < bottom; i++) {
 130     _memset_u24 (data, val[0], val[1], val[2], real_width);
 131     data += stride;
 132   }
 133 }
 134
 135 void
 136 vs_fill_borders_YUYV (const VSImage * dest, const uint8_t * val)
 137 {
 138   int i, j;
 139   int top = dest->border_top, bottom = dest->border_bottom;
 140   int left = dest->border_left, right = dest->border_right;
 141   int width = dest->width;
 142   int height = dest->height;
 143   int real_width = dest->real_width;
 144   int stride = dest->stride;
 145   int tmp, tmp2;
 146   uint8_t *data;
 147
 148   data = dest->real_pixels;
 149   for (i = 0; i < top; i++) {
 150     for (j = 0; j < real_width; j++) {
 151       data[2 * j] = val[0];
 152       data[2 * j + 1] = (j % 2 == 0) ? val[1] : val[3];
 153     }
 154     data += stride;
 155   }
 156
 157   if (left || right) {
 158     tmp = height;
 159     tmp2 = (left + width) * 2;
 160     for (i = 0; i < tmp; i++) {
 161       for (j = 0; j < left; j++) {
 162         data[2 * j] = val[0];
 163         data[2 * j + 1] = (j % 2 == 0) ? val[1] : val[3];
 164       }
 165       for (j = 0; j < right; j++) {
 166         data[tmp2 + 2 * j] = val[0];
 167         data[tmp2 + 2 * j + 1] = (j % 2 == 0) ? val[1] : val[3];
 168       }
 169       data += stride;
 170     }
 171   } else {
 172     data += stride * height;
 173   }
 174
 175   for (i = 0; i < bottom; i++) {
 176     for (j = 0; j < real_width; j++) {
 177       data[2 * j] = val[0];
 178       data[2 * j + 1] = (j % 2 == 0) ? val[1] : val[3];
 179     }
 180     data += stride;
 181   }
 182 }
 183
 184 void
 185 vs_fill_borders_UYVY (const VSImage * dest, const uint8_t * val)
 186 {
 187   int i, j;
 188   int top = dest->border_top, bottom = dest->border_bottom;
 189   int left = dest->border_left, right = dest->border_right;
 190   int width = dest->width;
 191   int height = dest->height;
 192   int real_width = dest->real_width;
 193   int stride = dest->stride;
 194   int tmp, tmp2;
 195   uint8_t *data;
 196
 197   data = dest->real_pixels;
 198   for (i = 0; i < top; i++) {
 199     for (j = 0; j < real_width; j++) {
 200       data[2 * j] = (j % 2 == 0) ? val[0] : val[2];
 201       data[2 * j + 1] = val[1];
 202     }
 203     data += stride;
 204   }
 205
 206   if (left || right) {
 207     tmp = height;
 208     tmp2 = (left + width) * 2;
 209     for (i = 0; i < tmp; i++) {
 210       for (j = 0; j < left; j++) {
 211         data[2 * j] = (j % 2 == 0) ? val[0] : val[2];
 212         data[2 * j + 1] = val[1];
 213       }
 214       for (j = 0; j < right; j++) {
 215         data[tmp2 + 2 * j] = (j % 2 == 0) ? val[0] : val[2];
 216         data[tmp2 + 2 * j + 1] = val[1];
 217       }
 218       data += stride;
 219     }
 220   } else {
 221     data += stride * height;
 222   }
 223
 224   for (i = 0; i < bottom; i++) {
 225     for (j = 0; j < real_width; j++) {
 226       data[2 * j] = (j % 2 == 0) ? val[0] : val[2];
 227       data[2 * j + 1] = val[1];
 228     }
 229     data += stride;
 230   }
 231 }
 232
 233 void
 234 vs_fill_borders_Y (const VSImage * dest, const uint8_t * val)
 235 {
 236   int i;
 237   int top = dest->border_top, bottom = dest->border_bottom;
 238   int left = dest->border_left, right = dest->border_right;
 239   int width = dest->width;
 240   int height = dest->height;
 241   int real_width = dest->real_width;
 242   int stride = dest->stride;
 243   int tmp, tmp2;
 244   uint8_t *data;
 245
 246   data = dest->real_pixels;
 247   for (i = 0; i < top; i++) {
 248     memset (data, *val, real_width);
 249     data += stride;
 250   }
 251
 252   if (left || right) {
 253     tmp = height;
 254     tmp2 = left + width;
 255     for (i = 0; i < tmp; i++) {
 256       memset (data, *val, left);
 257       memset (data + tmp2, *val, right);
 258       data += stride;
 259     }
 260   } else {
 261     data += stride * height;
 262   }
 263
 264   for (i = 0; i < bottom; i++) {
 265     memset (data, *val, real_width);
 266     data += stride;
 267   }
 268 }
 269
 270 void
 271 vs_fill_borders_Y16 (const VSImage * dest, const uint16_t val)
 272 {
 273   int i;
 274   int top = dest->border_top, bottom = dest->border_bottom;
 275   int left = dest->border_left, right = dest->border_right;
 276   int width = dest->width;
 277   int height = dest->height;
 278   int real_width = dest->real_width;
 279   int stride = dest->stride;
 280   int tmp, tmp2;
 281   uint8_t *data;
 282
 283   data = dest->real_pixels;
 284   for (i = 0; i < top; i++) {
 285     orc_splat_u16 ((uint16_t *) data, val, real_width);
 286     data += stride;
 287   }
 288
 289   if (left || right) {
 290     tmp = height;
 291     tmp2 = (left + width) * 2;
 292     for (i = 0; i < tmp; i++) {
 293       orc_splat_u16 ((uint16_t *) data, val, left);
 294       orc_splat_u16 ((uint16_t *) (data + tmp2), val, right);
 295       data += stride;
 296     }
 297   } else {
 298     data += stride * height;
 299   }
 300
 301   for (i = 0; i < bottom; i++) {
 302     orc_splat_u16 ((uint16_t *) data, val, real_width);
 303     data += stride;
 304   }
 305 }
 306
 307 void
 308 vs_fill_borders_RGB565 (const VSImage * dest, const uint8_t * val)
 309 {
 310   int i;
 311   int top = dest->border_top, bottom = dest->border_bottom;
 312   int left = dest->border_left, right = dest->border_right;
 313   int width = dest->width;
 314   int height = dest->height;
 315   int real_width = dest->real_width;
 316   int stride = dest->stride;
 317   int tmp, tmp2;
 318   uint8_t *data;
 319   uint16_t v = READ_UINT16 (val);
 320
 321   data = dest->real_pixels;
 322   for (i = 0; i < top; i++) {
 323     orc_splat_u16 ((uint16_t *) data, v, real_width);
 324     data += stride;
 325   }
 326
 327   if (left || right) {
 328     tmp = height;
 329     tmp2 = (left + width) * 2;
 330     for (i = 0; i < tmp; i++) {
 331       orc_splat_u16 ((uint16_t *) data, v, left);
 332       orc_splat_u16 ((uint16_t *) (data + tmp2), v, right);
 333       data += stride;
 334     }
 335   } else {
 336     data += stride * height;
 337   }
 338
 339   for (i = 0; i < bottom; i++) {
 340     orc_splat_u16 ((uint16_t *) data, v, real_width);
 341     data += stride;
 342   }
 343 }
 344
 345 void
 346 vs_fill_borders_RGB555 (const VSImage * dest, const uint8_t * val)
 347 {
 348   int i;
 349   int top = dest->border_top, bottom = dest->border_bottom;
 350   int left = dest->border_left, right = dest->border_right;
 351   int width = dest->width;
 352   int height = dest->height;
 353   int real_width = dest->real_width;
 354   int stride = dest->stride;
 355   int tmp, tmp2;
 356   uint8_t *data;
 357   uint16_t v = READ_UINT16 (val);
 358
 359   data = dest->real_pixels;
 360   for (i = 0; i < top; i++) {
 361     orc_splat_u16 ((uint16_t *) data, v, real_width);
 362     data += stride;
 363   }
 364
 365   if (left || right) {
 366     tmp = height;
 367     tmp2 = (left + width) * 2;
 368     for (i = 0; i < tmp; i++) {
 369       orc_splat_u16 ((uint16_t *) data, v, left);
 370       orc_splat_u16 ((uint16_t *) (data + tmp2), v, right);
 371       data += stride;
 372     }
 373   } else {
 374     data += stride * height;
 375   }
 376
 377   for (i = 0; i < bottom; i++) {
 378     orc_splat_u16 ((uint16_t *) data, v, real_width);
 379     data += stride;
 380   }
 381 }
 382
 383 void
 384 vs_fill_borders_AYUV64 (const VSImage * dest, const uint8_t * val)
 385 {
 386   int i;
 387   int top = dest->border_top, bottom = dest->border_bottom;
 388   int left = dest->border_left, right = dest->border_right;
 389   int width = dest->width;
 390   int height = dest->height;
 391   int real_width = dest->real_width;
 392   int stride = dest->stride;
 393   int tmp, tmp2;
 394   uint8_t *data;
 395   uint64_t v;
 396
 397   v = (val[0] << 8) | (val[1] << 24) | (((guint64) val[2]) << 40) | (((guint64)
 398           val[3]) << 56);
 399
 400   data = dest->real_pixels;
 401   for (i = 0; i < top; i++) {
 402     orc_splat_u64 ((uint64_t *) data, v, real_width);
 403     data += stride;
 404   }
 405
 406   if (left || right) {
 407     tmp = height;
 408     tmp2 = (left + width) * 8;
 409     for (i = 0; i < tmp; i++) {
 410       orc_splat_u64 ((uint64_t *) data, v, left);
 411       orc_splat_u64 ((uint64_t *) (data + tmp2), v, right);
 412       data += stride;
 413     }
 414   } else {
 415     data += stride * height;
 416   }
 417
 418   for (i = 0; i < bottom; i++) {
 419     orc_splat_u64 ((uint64_t *) data, v, real_width);
 420     data += stride;
 421   }
 422 }