Annotation of embedaddon/php/ext/gd/libgd/webpimg.c, revision 1.1
1.1 ! misho 1: /*===========================================================================*
! 2: - Copyright 2010 Google Inc.
! 3: -
! 4: - This code is licensed under the same terms as WebM:
! 5: - Software License Agreement: http://www.webmproject.org/license/software/
! 6: - Additional IP Rights Grant: http://www.webmproject.org/license/additional/
! 7: *===========================================================================*/
! 8:
! 9: /*
! 10: * Encoding/Decoding of WebP still image compression format.
! 11: *
! 12: * 1. WebPDecode: Takes an array of bytes (string) corresponding to the WebP
! 13: * encoded image and generates output in the YUV format with
! 14: * the color components U, V subsampled to 1/2 resolution along
! 15: * each dimension.
! 16: *
! 17: * 2. YUV420toRGBA: Converts from YUV (with color subsampling) such as produced
! 18: * by the WebPDecode routine into 32 bits per pixel RGBA data
! 19: * array. This data array can be directly used by the Leptonica
! 20: * Pix in-memory image format.
! 21: *
! 22: * 3. WebPEncode: Takes a Y, U, V data buffers (with color components U and V
! 23: * subsampled to 1/2 resolution) and generates the WebP string
! 24: *
! 25: * 4. RGBAToYUV420: Generates Y, U, V data (with color subsampling) from 32 bits
! 26: * per pixel RGBA data buffer. The resulting YUV data can be
! 27: * directly fed into the WebPEncode routine.
! 28: *
! 29: * 5. AdjustColorspace:
! 30: *
! 31: * 6. AdjustColorspaceBack:
! 32: */
! 33: #include "gd.h"
! 34: #ifdef HAVE_LIBVPX
! 35: #include "webpimg.h"
! 36:
! 37: #include <math.h>
! 38: #include <stdio.h>
! 39: #include <stdlib.h>
! 40: #include <string.h>
! 41: #include <sys/stat.h>
! 42:
! 43: #include "vpx/vpx_decoder.h"
! 44: #include "vpx/vp8dx.h"
! 45: #include "vpx/vpx_encoder.h"
! 46: #include "vpx/vp8cx.h"
! 47: #include "gd.h"
! 48:
! 49: /*---------------------------------------------------------------------*
! 50: * color conversions *
! 51: *---------------------------------------------------------------------*/
! 52:
! 53: #ifndef inline
! 54: # define inline __inline
! 55: #endif
! 56: static inline int clip(float v, int a, int b) {
! 57: return (v > b) ? b : (v < 0) ? 0 : (int)(v);
! 58: }
! 59: enum {
! 60: COLOR_RED = 0,
! 61: COLOR_GREEN = 1,
! 62: COLOR_BLUE = 2,
! 63: ALPHA_CHANNEL = 3
! 64: };
! 65:
! 66: /* endian neutral extractions of RGBA from a 32 bit pixel */
! 67: static const uint32 RED_SHIFT =
! 68: 8 * (sizeof(uint32) - 1 - COLOR_RED); /* 24 */
! 69: static const uint32 GREEN_SHIFT =
! 70: 8 * (sizeof(uint32) - 1 - COLOR_GREEN); /* 16 */
! 71: static const uint32 BLUE_SHIFT =
! 72: 8 * (sizeof(uint32) - 1 - COLOR_BLUE); /* 8 */
! 73: static const uint32 ALPHA_SHIFT =
! 74: 8 * (sizeof(uint32) - 1 - ALPHA_CHANNEL); /* 0 */
! 75:
! 76: static inline int GetRed(const uint32* rgba) {
! 77: return gdTrueColorGetRed(*rgba);
! 78: }
! 79:
! 80: static inline int GetGreen(const uint32* rgba) {
! 81: return gdTrueColorGetGreen(*rgba);
! 82: }
! 83:
! 84: static inline int GetBlue(const uint32* rgba) {
! 85: return gdTrueColorGetBlue(*rgba);
! 86: }
! 87:
! 88: enum { YUV_FRAC = 16 };
! 89:
! 90: static inline int clip_uv(int v) {
! 91: v = (v + (257 << (YUV_FRAC + 2 - 1))) >> (YUV_FRAC + 2);
! 92: return ((v & ~0xff) == 0) ? v : v < 0 ? 0u : 255u;
! 93: }
! 94:
! 95:
! 96: /* YUV <-----> RGB conversions */
! 97: /* The exact naming is Y'CbCr, following the ITU-R BT.601 standard.
! 98: * More information at: http://en.wikipedia.org/wiki/YCbCr
! 99: */
! 100: static inline int GetLumaY(int r, int g, int b) {
! 101: const int kRound = (1 << (YUV_FRAC - 1)) + (16 << YUV_FRAC);
! 102: // Y = 0.2569 * R + 0.5044 * G + 0.0979 * B + 16
! 103: const int luma = 16839 * r + 33059 * g + 6420 * b;
! 104: return (luma + kRound) >> YUV_FRAC;
! 105: }
! 106:
! 107: static inline int GetLumaYfromPtr(uint32* rgba) {
! 108: const int r = GetRed(rgba);
! 109: const int g = GetGreen(rgba);
! 110: const int b = GetBlue(rgba);
! 111: return GetLumaY(r, g, b);
! 112: }
! 113:
! 114: static inline int GetChromaU(int r, int g, int b) {
! 115: // U = -0.1483 * R - 0.2911 * G + 0.4394 * B + 128
! 116: return clip_uv(-9719 * r - 19081 * g + 28800 * b);
! 117: }
! 118:
! 119: static inline int GetChromaV(int r, int g, int b) {
! 120: // V = 0.4394 * R - 0.3679 * G - 0.0715 * B + 128
! 121: return clip_uv(+28800 * r - 24116 * g - 4684 * b);
! 122: }
! 123:
! 124: /* Converts YUV to RGB and writes into a 32 bit pixel in endian
! 125: * neutral fashion
! 126: */
! 127: enum { RGB_FRAC = 16, RGB_HALF = (1 << RGB_FRAC) / 2,
! 128: RGB_RANGE_MIN = -227, RGB_RANGE_MAX = 256 + 226 };
! 129:
! 130: static int init_done = 0;
! 131: static int16_t kVToR[256], kUToB[256];
! 132: static int32_t kVToG[256], kUToG[256];
! 133: static uint8_t kClip[RGB_RANGE_MAX - RGB_RANGE_MIN];
! 134:
! 135: static void InitTables() {
! 136: int i;
! 137: for (i = 0; i < 256; ++i) {
! 138: kVToR[i] = (89858 * (i - 128) + RGB_HALF) >> RGB_FRAC;
! 139: kUToG[i] = -22014 * (i - 128) + RGB_HALF;
! 140: kVToG[i] = -45773 * (i - 128);
! 141: kUToB[i] = (113618 * (i - 128) + RGB_HALF) >> RGB_FRAC;
! 142: }
! 143: for (i = RGB_RANGE_MIN; i < RGB_RANGE_MAX; ++i) {
! 144: const int j = ((i - 16) * 76283 + RGB_HALF) >> RGB_FRAC;
! 145: kClip[i - RGB_RANGE_MIN] = (j < 0) ? 0 : (j > 255) ? 255 : j;
! 146: }
! 147:
! 148: init_done = 1;
! 149: }
! 150:
! 151: static void ToRGB(int y, int u, int v, uint32* const dst) {
! 152: const int r_off = kVToR[v];
! 153: const int g_off = (kVToG[v] + kUToG[u]) >> RGB_FRAC;
! 154: const int b_off = kUToB[u];
! 155: const int r = kClip[y + r_off - RGB_RANGE_MIN];
! 156: const int g = kClip[y + g_off - RGB_RANGE_MIN];
! 157: const int b = kClip[y + b_off - RGB_RANGE_MIN];
! 158: *dst = (r << RED_SHIFT) | (g << GREEN_SHIFT) | (b << BLUE_SHIFT);
! 159: }
! 160:
! 161: static inline uint32 get_le32(const uint8* const data) {
! 162: return data[0] | (data[1] << 8) | (data[2] << 16) | (data[3] << 24);
! 163: }
! 164:
! 165: /* Returns the difference (in dB) between two images represented in YUV format
! 166: *
! 167: * Input:
! 168: * Y1/U1/V1: The Y/U/V data of the first image
! 169: * Y2/U2/V2: The Y/U/V data of the second image
! 170: *
! 171: * Returns the PSNR (http://en.wikipedia.org/wiki/Peak_signal-to-noise_ratio)
! 172: * value computed bewteen the two images
! 173: */
! 174: double GetPSNRYuv(const uint8* Y1,
! 175: const uint8* U1,
! 176: const uint8* V1,
! 177: const uint8* Y2,
! 178: const uint8* U2,
! 179: const uint8* V2,
! 180: int y_width,
! 181: int y_height) {
! 182: int x, y, row_idx;
! 183: const int uv_width = ((y_width + 1) >> 1);
! 184: const int uv_height = ((y_height + 1) >> 1);
! 185: double sse = 0., count = 0.;
! 186: for (y = 0; y < y_height; ++y) {
! 187: count += y_width;
! 188: row_idx = y * y_width;
! 189: for (x = 0; x < y_width; ++x) {
! 190: double diff = Y1[row_idx + x] - Y2[row_idx + x];
! 191: sse += diff * diff;
! 192: }
! 193: }
! 194: for (y = 0; y < uv_height; ++y) {
! 195: count += 2 * uv_width;
! 196: row_idx = y * uv_width;
! 197: for (x = 0; x < uv_width; ++x) {
! 198: const double diff_U = U1[row_idx + x] - U2[row_idx + x];
! 199: const double diff_V = V1[row_idx + x] - V2[row_idx + x];
! 200: sse += diff_U * diff_U + diff_V * diff_V;
! 201: }
! 202: }
! 203: return -4.3429448 * log(sse / (255. * 255. * count));
! 204: }
! 205:
! 206: /* Returns the difference (in dB) between two images. One represented
! 207: * using Y,U,V vectors and the other is webp image data.
! 208: * Input:
! 209: * Y1/U1/V1: The Y/U/V data of the first image
! 210: * imgdata: data buffer containing webp image
! 211: * imgdata_size: size of the imgdata buffer
! 212: *
! 213: * Returns the PSNR value computed bewteen the two images
! 214: */
! 215: double WebPGetPSNR(const uint8* Y1,
! 216: const uint8* U1,
! 217: const uint8* V1,
! 218: uint8* imgdata,
! 219: int imgdata_size) {
! 220: uint8* Y2 = NULL;
! 221: uint8* U2 = NULL;
! 222: uint8* V2 = NULL;
! 223: int w = 0, h = 0;
! 224: double psnr = 0;
! 225:
! 226: WebPDecode(imgdata,
! 227: imgdata_size,
! 228: &Y2,
! 229: &U2,
! 230: &V2,
! 231: &w,
! 232: &h);
! 233:
! 234: psnr = GetPSNRYuv(Y1, U1, V1, Y2, U2, V2, w, h);
! 235: free(Y2);
! 236:
! 237: return psnr;
! 238: }
! 239:
! 240: /*---------------------------------------------------------------------*
! 241: * Reading WebP *
! 242: *---------------------------------------------------------------------*/
! 243:
! 244: /* RIFF layout is:
! 245: * 0ffset tag
! 246: * 0...3 "RIFF" 4-byte tag
! 247: * 4...7 size of image data (including metadata) starting at offset 8
! 248: * 8...11 "WEBP" our form-type signature
! 249: * 12..15 "VP8 " 4-byte tags, describing the raw video format used
! 250: * 16..19 size of the raw WebP image data, starting at offset 20
! 251: * 20.... the WebP bytes
! 252: * There can be extra chunks after the "VP8 " chunk (ICMT, ICOP, ...)
! 253: * All 32-bits sizes are in little-endian order.
! 254: * Note: chunk data must be padded to multiple of 2 in size
! 255: */
! 256:
! 257: int SkipRiffHeader(const uint8** data_ptr, int *data_size_ptr) {
! 258: /* 20 bytes RIFF header 10 bytes VP8 header */
! 259: const int kHeaderSize = (20 + 10);
! 260: uint32 chunk_size = 0xffffffffu;
! 261:
! 262: if (*data_size_ptr >= kHeaderSize && !memcmp(*data_ptr, "RIFF", 4)) {
! 263: if (memcmp(*data_ptr + 8, "WEBP", 4)) {
! 264: return 0; /* wrong image file signature */
! 265: } else {
! 266: const uint32 riff_size = get_le32(*data_ptr + 4);
! 267: if (memcmp(*data_ptr + 12, "VP8 ", 4)) {
! 268: return 0; /* invalid compression format */
! 269: }
! 270: chunk_size = get_le32(*data_ptr + 16);
! 271: if ((chunk_size > riff_size + 8) || (chunk_size & 1)) {
! 272: return 0; /* inconsistent size information. */
! 273: }
! 274: /* We have a RIFF container. Skip it. */
! 275: *data_ptr += 20;
! 276: *data_size_ptr -= 20;
! 277: }
! 278: }
! 279: return chunk_size;
! 280: }
! 281:
! 282: /* Generate RGBA row from an YUV row (with width upsampling of chrome data)
! 283: * Input:
! 284: * 1, 2, 3. y_src, u_src, v_src - Pointers to input Y, U, V row data
! 285: * respectively. We reuse these variables, they iterate over all pixels in
! 286: * the row.
! 287: * 4. y_width: width of the Y image plane (aka image width)
! 288: * Output:
! 289: * 5. rgb_sat: pointer to the output rgb row. We reuse this variable, it
! 290: * iterates over all pixels in the row.
! 291: */
! 292: static void YUV420toRGBLine(uint8* y_src,
! 293: uint8* u_src,
! 294: uint8* v_src,
! 295: int y_width,
! 296: uint32* rgb_dst) {
! 297: int x;
! 298: for (x = 0; x < (y_width >> 1); ++x) {
! 299: const int U = u_src[0];
! 300: const int V = v_src[0];
! 301: ToRGB(y_src[0], U, V, rgb_dst);
! 302: ToRGB(y_src[1], U, V, rgb_dst + 1);
! 303: ++u_src;
! 304: ++v_src;
! 305: y_src += 2;
! 306: rgb_dst += 2;
! 307: }
! 308: if (y_width & 1) { /* Rightmost pixel */
! 309: ToRGB(y_src[0], (*u_src), (*v_src), rgb_dst);
! 310: }
! 311: }
! 312:
! 313: /* Converts from YUV (with color subsampling) such as produced by the WebPDecode
! 314: * routine into 32 bits per pixel RGBA data array. This data array can be
! 315: * directly used by the Leptonica Pix in-memory image format.
! 316: * Input:
! 317: * 1, 2, 3. Y, U, V: the input data buffers
! 318: * 4. pixwpl: the desired words per line corresponding to the supplied
! 319: * output pixdata.
! 320: * 5. width, height: the dimensions of the image whose data resides in Y,
! 321: * U, V.
! 322: * Output:
! 323: * 6. pixdata: the output data buffer. Caller should allocate
! 324: * height * pixwpl bytes of memory before calling this routine.
! 325: */
! 326: void YUV420toRGBA(uint8* Y,
! 327: uint8* U,
! 328: uint8* V,
! 329: int words_per_line,
! 330: int width,
! 331: int height,
! 332: uint32* pixdata) {
! 333: int y_width = width;
! 334: int y_stride = y_width;
! 335: int uv_width = ((y_width + 1) >> 1);
! 336: int uv_stride = uv_width;
! 337: int y;
! 338:
! 339: if (!init_done)
! 340: InitTables();
! 341:
! 342: /* note that the U, V upsampling in height is happening here as the U, V
! 343: * buffers sent to successive odd-even pair of lines is same.
! 344: */
! 345: for (y = 0; y < height; ++y) {
! 346: YUV420toRGBLine(Y + y * y_stride,
! 347: U + (y >> 1) * uv_stride,
! 348: V + (y >> 1) * uv_stride,
! 349: width,
! 350: pixdata + y * words_per_line);
! 351: }
! 352: }
! 353:
! 354: void gd_YUV420toRGBA(uint8* Y,
! 355: uint8* U,
! 356: uint8* V,
! 357: gdImagePtr im) {
! 358: int width = im->sx;
! 359: int height = im->sy;
! 360: int y_width = width;
! 361: int y_stride = y_width;
! 362: int uv_width = ((y_width + 1) >> 1);
! 363: int uv_stride = uv_width;
! 364: int y;
! 365:
! 366: /* output im must be truecolor */
! 367: if (!im->trueColor) {
! 368: return;
! 369: }
! 370:
! 371: if (!init_done)
! 372: InitTables();
! 373:
! 374: /* note that the U, V upsampling in height is happening here as the U, V
! 375: * buffers sent to successive odd-even pair of lines is same.
! 376: */
! 377: for (y = 0; y < height; ++y) {
! 378: YUV420toRGBLine(Y + y * y_stride,
! 379: U + (y >> 1) * uv_stride,
! 380: V + (y >> 1) * uv_stride,
! 381: width,
! 382: im->tpixels[y]);
! 383: }
! 384: }
! 385:
! 386: static WebPResult VPXDecode(const uint8* data,
! 387: int data_size,
! 388: uint8** p_Y,
! 389: uint8** p_U,
! 390: uint8** p_V,
! 391: int* p_width,
! 392: int* p_height) {
! 393: vpx_codec_ctx_t dec;
! 394: vp8_postproc_cfg_t ppcfg;
! 395: WebPResult result = webp_failure;
! 396:
! 397: if (!data || data_size <= 10 || !p_Y || !p_U || !p_V
! 398: || *p_Y != NULL || *p_U != NULL || *p_V != NULL) {
! 399: return webp_failure;
! 400: }
! 401:
! 402: if (vpx_codec_dec_init(&dec,
! 403: &vpx_codec_vp8_dx_algo, NULL, 0) != VPX_CODEC_OK) {
! 404: return webp_failure;
! 405: }
! 406:
! 407: ppcfg.post_proc_flag = VP8_NOFILTERING;
! 408: vpx_codec_control(&dec, VP8_SET_POSTPROC, &ppcfg);
! 409:
! 410:
! 411: if (vpx_codec_decode(&dec, data, data_size, NULL, 0) == VPX_CODEC_OK) {
! 412: vpx_codec_iter_t iter = NULL;
! 413: vpx_image_t* const img = vpx_codec_get_frame(&dec, &iter);
! 414: if (img) {
! 415: int y_width = img->d_w;
! 416: int y_height = img->d_h;
! 417: int y_stride = y_width;
! 418: int uv_width = (y_width + 1) >> 1;
! 419: int uv_stride = uv_width;
! 420: int uv_height = ((y_height + 1) >> 1);
! 421: int y;
! 422:
! 423: *p_width = y_width;
! 424: *p_height = y_height;
! 425: if ((*p_Y = (uint8 *)(calloc(y_stride * y_height
! 426: + 2 * uv_stride * uv_height,
! 427: sizeof(uint8)))) != NULL) {
! 428: *p_U = *p_Y + y_height * y_stride;
! 429: *p_V = *p_U + uv_height * uv_stride;
! 430: for (y = 0; y < y_height; ++y) {
! 431: memcpy(*p_Y + y * y_stride,
! 432: img->planes[0] + y * img->stride[0],
! 433: y_width);
! 434: }
! 435: for (y = 0; y < uv_height; ++y) {
! 436: memcpy(*p_U + y * uv_stride,
! 437: img->planes[1] + y * img->stride[1],
! 438: uv_width);
! 439: memcpy(*p_V + y * uv_stride,
! 440: img->planes[2] + y * img->stride[2],
! 441: uv_width);
! 442: }
! 443: result = webp_success;
! 444: }
! 445: }
! 446: }
! 447: vpx_codec_destroy(&dec);
! 448:
! 449: return result;
! 450: }
! 451:
! 452: WebPResult WebPDecode(const uint8* data,
! 453: int data_size,
! 454: uint8** p_Y,
! 455: uint8** p_U,
! 456: uint8** p_V,
! 457: int* p_width,
! 458: int* p_height) {
! 459:
! 460: const uint32 chunk_size = SkipRiffHeader(&data, &data_size);
! 461: if (!chunk_size) {
! 462: return webp_failure; /* unsupported RIFF header */
! 463: }
! 464:
! 465: return VPXDecode(data, data_size, p_Y, p_U, p_V, p_width, p_height);
! 466: }
! 467:
! 468: /*---------------------------------------------------------------------*
! 469: * Writing WebP *
! 470: *---------------------------------------------------------------------*/
! 471:
! 472: /* Takes a pair of RGBA row data as input and generates 2 rows of Y data and one
! 473: * row of subsampled U, V data as output
! 474: * Input:
! 475: * 1, 2. rgb_line1, rgb_line2 - input rgba rows
! 476: * 3. width - image width
! 477: * Outout:
! 478: * 4, 5, 6: Output Y, U, V row
! 479: */
! 480: static void RGBALinepairToYUV420(uint32* rgb_line1,
! 481: uint32* rgb_line2,
! 482: int width,
! 483: uint8* Y_dst1,
! 484: uint8* Y_dst2,
! 485: uint8* u_dst,
! 486: uint8* v_dst) {
! 487: int x;
! 488: for (x = (width >> 1); x > 0; --x) {
! 489: const int sum_r =
! 490: GetRed(rgb_line1 + 0) + GetRed(rgb_line1 + 1) +
! 491: GetRed(rgb_line2 + 0) + GetRed(rgb_line2 + 1);
! 492: const int sum_g =
! 493: GetGreen(rgb_line1 + 0) + GetGreen(rgb_line1 + 1) +
! 494: GetGreen(rgb_line2 + 0) + GetGreen(rgb_line2 + 1);
! 495: const int sum_b =
! 496: GetBlue(rgb_line1 + 0) + GetBlue(rgb_line1 + 1) +
! 497: GetBlue(rgb_line2 + 0) + GetBlue(rgb_line2 + 1);
! 498:
! 499: Y_dst1[0] = GetLumaYfromPtr(rgb_line1 + 0);
! 500: Y_dst1[1] = GetLumaYfromPtr(rgb_line1 + 1);
! 501: Y_dst2[0] = GetLumaYfromPtr(rgb_line2 + 0);
! 502: Y_dst2[1] = GetLumaYfromPtr(rgb_line2 + 1);
! 503:
! 504: *u_dst++ = GetChromaU(sum_r, sum_g, sum_b);
! 505: *v_dst++ = GetChromaV(sum_r, sum_g, sum_b);
! 506:
! 507: rgb_line1 += 2;
! 508: rgb_line2 += 2;
! 509: Y_dst1 += 2;
! 510: Y_dst2 += 2;
! 511: }
! 512:
! 513: if (width & 1) { /* rightmost pixel. */
! 514: const int sum_r = GetRed(rgb_line1) + GetRed(rgb_line2);
! 515: const int sum_g = GetGreen(rgb_line1) + GetGreen(rgb_line2);
! 516: const int sum_b = GetBlue(rgb_line1) + GetBlue(rgb_line2);
! 517:
! 518: Y_dst1[0] = GetLumaYfromPtr(rgb_line1);
! 519: Y_dst2[0] = GetLumaYfromPtr(rgb_line2);
! 520: *u_dst = GetChromaU(2 * sum_r, 2 * sum_g, 2 * sum_b);
! 521: *v_dst = GetChromaV(2 * sum_r, 2 * sum_g, 2 * sum_b);
! 522: }
! 523: }
! 524:
! 525: /* Generates Y, U, V data (with color subsampling) from 32 bits
! 526: * per pixel RGBA data buffer. The resulting YUV data can be directly fed into
! 527: * the WebPEncode routine.
! 528: * Input:
! 529: * 1. pixdatainput rgba data buffer
! 530: * 2. words per line corresponding to pixdata
! 531: * 3, 4. image width and height respectively
! 532: * Output:
! 533: * 5, 6, 7. Output YUV data buffers
! 534: */
! 535: void gd_RGBAToYUV420(gdImagePtr im2,
! 536: uint8* Y,
! 537: uint8* U,
! 538: uint8* V) {
! 539: int y_width = im2->sx;
! 540: int y_height = im2->sy;
! 541: int y_stride = y_width;
! 542: int uv_width = ((y_width + 1) >> 1);
! 543: int uv_stride = uv_width;
! 544: int y;
! 545: gdImagePtr im = NULL;
! 546: int free_im = 0;
! 547:
! 548: if (!im2->trueColor) {
! 549: /* Todo: Replace the color/YUV functions with our own and simplify
! 550: that should boost the conversion a bit as well, not only for
! 551: palette image. */
! 552: im = gdImageCreateTrueColor(im2->sx, im2->sy);
! 553: if (!im) {
! 554: php_gd_error("gd-webp error: cannot convert palette input to truecolor");
! 555: return;
! 556: }
! 557: gdImageCopy(im, im2, 0, 0, 0, 0, im->sx, im->sy);
! 558: free_im = 1;
! 559: } else {
! 560: im = im2;
! 561: }
! 562: for (y = 0; y < (y_height >> 1); ++y) {
! 563: RGBALinepairToYUV420(im->tpixels[2 * y],
! 564: im->tpixels[2 * y + 1],
! 565: y_width,
! 566: Y + 2 * y * y_stride,
! 567: Y + (2 * y + 1) * y_stride,
! 568: U + y * uv_stride,
! 569: V + y * uv_stride);
! 570: }
! 571: if (y_height & 1) {
! 572: RGBALinepairToYUV420(im->tpixels[y_height - 1],
! 573: im->tpixels[y_height - 1],
! 574: y_width,
! 575: Y + (y_height - 1) * y_stride,
! 576: Y + (y_height - 1) * y_stride,
! 577: U + (y_height >> 1) * uv_stride,
! 578: V + (y_height >> 1) * uv_stride);
! 579: }
! 580: if (free_im) {
! 581: gdImageDestroy(im);
! 582: }
! 583: }
! 584:
! 585: /* Generates Y, U, V data (with color subsampling) from 32 bits
! 586: * per pixel RGBA data buffer. The resulting YUV data can be directly fed into
! 587: * the WebPEncode routine.
! 588: * Input:
! 589: * 1. pixdatainput rgba data buffer
! 590: * 2. words per line corresponding to pixdata
! 591: * 3, 4. image width and height respectively
! 592: * Output:
! 593: * 5, 6, 7. Output YUV data buffers
! 594: */
! 595: void RGBAToYUV420(uint32* pixdata,
! 596: int words_per_line,
! 597: int width,
! 598: int height,
! 599: uint8* Y,
! 600: uint8* U,
! 601: uint8* V) {
! 602: int y_width = width;
! 603: int y_height = height;
! 604: int y_stride = y_width;
! 605: int uv_width = ((y_width + 1) >> 1);
! 606: int uv_stride = uv_width;
! 607: int y;
! 608:
! 609: for (y = 0; y < (y_height >> 1); ++y) {
! 610: RGBALinepairToYUV420(pixdata + 2 * y * words_per_line,
! 611: pixdata + (2 * y + 1) * words_per_line,
! 612: y_width,
! 613: Y + 2 * y * y_stride,
! 614: Y + (2 * y + 1) * y_stride,
! 615: U + y * uv_stride,
! 616: V + y * uv_stride);
! 617: }
! 618: if (y_height & 1) {
! 619: RGBALinepairToYUV420(pixdata + (y_height - 1) * words_per_line,
! 620: pixdata + (y_height - 1) * words_per_line,
! 621: y_width,
! 622: Y + (y_height - 1) * y_stride,
! 623: Y + (y_height - 1) * y_stride,
! 624: U + (y_height >> 1) * uv_stride,
! 625: V + (y_height >> 1) * uv_stride);
! 626: }
! 627: }
! 628:
! 629: static int codec_ctl(vpx_codec_ctx_t *enc,
! 630: enum vp8e_enc_control_id id,
! 631: int value) {
! 632: const vpx_codec_err_t res = vpx_codec_control_(enc, id, value);
! 633: if (res != VPX_CODEC_OK) {
! 634: return webp_failure;
! 635: }
! 636: return webp_success;
! 637: }
! 638:
! 639: static void SetupParams(vpx_codec_enc_cfg_t* cfg,
! 640: int QP) {
! 641: cfg->g_threads = 2;
! 642: cfg->rc_min_quantizer = QP;
! 643: cfg->rc_max_quantizer = QP;
! 644: cfg->kf_mode = VPX_KF_FIXED;
! 645: }
! 646:
! 647: /* VPXEncode: Takes a Y, U, V data buffers (with color components U and V
! 648: * subsampled to 1/2 resolution) and generates the VPX string.
! 649: * Output VPX string is placed in the *p_out buffer. container_size
! 650: * indicates number of bytes to be left blank at the beginning of
! 651: * *p_out buffer to accommodate for a container header.
! 652: *
! 653: * Return: success/failure
! 654: */
! 655: static WebPResult VPXEncode(const uint8* Y,
! 656: const uint8* U,
! 657: const uint8* V,
! 658: int y_width,
! 659: int y_height,
! 660: int y_stride,
! 661: int uv_width,
! 662: int uv_height,
! 663: int uv_stride,
! 664: int QP,
! 665: int container_size,
! 666: unsigned char** p_out,
! 667: int* p_out_size_bytes) {
! 668: vpx_codec_iface_t* iface = &vpx_codec_vp8_cx_algo;
! 669: vpx_codec_err_t res;
! 670: vpx_codec_enc_cfg_t cfg;
! 671: vpx_codec_ctx_t enc;
! 672: WebPResult result = webp_failure;
! 673: vpx_image_t img;
! 674:
! 675: *p_out = NULL;
! 676: *p_out_size_bytes = 0;
! 677:
! 678:
! 679: /* validate input parameters. */
! 680: if (!p_out || !Y || !U || !V
! 681: || y_width <= 0 || y_height <= 0 || uv_width <= 0 || uv_height <= 0
! 682: || y_stride < y_width || uv_stride < uv_width
! 683: || QP < 0 || QP > 63) {
! 684: return webp_failure;
! 685: }
! 686:
! 687: res = vpx_codec_enc_config_default(iface, &cfg, 0);
! 688: if (res != VPX_CODEC_OK) {
! 689: return webp_failure;
! 690: }
! 691:
! 692: SetupParams(&cfg, QP);
! 693: cfg.g_w = y_width;
! 694: cfg.g_h = y_height;
! 695:
! 696: res = vpx_codec_enc_init(&enc, iface, &cfg, 0);
! 697:
! 698: if (res == VPX_CODEC_OK) {
! 699: codec_ctl(&enc, VP8E_SET_CPUUSED, 3);
! 700: codec_ctl(&enc, VP8E_SET_NOISE_SENSITIVITY, 0);
! 701: codec_ctl(&enc, VP8E_SET_SHARPNESS, 0);
! 702: codec_ctl(&enc, VP8E_SET_ENABLEAUTOALTREF, 0);
! 703: codec_ctl(&enc, VP8E_SET_ARNR_MAXFRAMES, 0);
! 704: codec_ctl(&enc, VP8E_SET_ARNR_TYPE, 0);
! 705: codec_ctl(&enc, VP8E_SET_ARNR_STRENGTH, 0);
! 706: codec_ctl(&enc, VP8E_SET_STATIC_THRESHOLD, 0);
! 707: codec_ctl(&enc, VP8E_SET_TOKEN_PARTITIONS, 2);
! 708:
! 709: vpx_img_wrap(&img, IMG_FMT_I420,
! 710: y_width, y_height, 16, (uint8*)(Y));
! 711: img.planes[PLANE_Y] = (uint8*)(Y);
! 712: img.planes[PLANE_U] = (uint8*)(U);
! 713: img.planes[PLANE_V] = (uint8*)(V);
! 714: img.stride[PLANE_Y] = y_stride;
! 715: img.stride[PLANE_U] = uv_stride;
! 716: img.stride[PLANE_V] = uv_stride;
! 717:
! 718: res = vpx_codec_encode(&enc, &img, 0, 1, 0, VPX_DL_BEST_QUALITY);
! 719:
! 720: if (res == VPX_CODEC_OK) {
! 721: vpx_codec_iter_t iter = NULL;
! 722: const vpx_codec_cx_pkt_t* pkt = vpx_codec_get_cx_data(&enc, &iter);
! 723: if (pkt != NULL) {
! 724: *p_out = (unsigned char*)(calloc(container_size + pkt->data.frame.sz,
! 725: 1));
! 726:
! 727: memcpy(*p_out + container_size,
! 728: (const void*)(pkt->data.frame.buf),
! 729: pkt->data.frame.sz);
! 730: *p_out_size_bytes = container_size + pkt->data.frame.sz;
! 731:
! 732: result = webp_success;
! 733: }
! 734: }
! 735: }
! 736:
! 737: vpx_codec_destroy(&enc);
! 738:
! 739: return result;
! 740: }
! 741:
! 742: WebPResult WebPEncode(const uint8* Y,
! 743: const uint8* U,
! 744: const uint8* V,
! 745: int y_width,
! 746: int y_height,
! 747: int y_stride,
! 748: int uv_width,
! 749: int uv_height,
! 750: int uv_stride,
! 751: int QP,
! 752: unsigned char** p_out,
! 753: int* p_out_size_bytes,
! 754: double *psnr) {
! 755:
! 756: const int kRiffHeaderSize = 20;
! 757:
! 758: if (VPXEncode(Y, U, V,
! 759: y_width, y_height, y_stride,
! 760: uv_width, uv_height, uv_stride,
! 761: QP, kRiffHeaderSize,
! 762: p_out, p_out_size_bytes) != webp_success) {
! 763: return webp_failure;
! 764: } else {
! 765: /* Write RIFF header */
! 766: const int img_size_bytes = *p_out_size_bytes - kRiffHeaderSize;
! 767: const int chunk_size = (img_size_bytes + 1) & ~1; /* make size even */
! 768: const int riff_size = chunk_size + 12;
! 769: const uint8_t kRiffHeader[20] = { 'R', 'I', 'F', 'F',
! 770: (riff_size >> 0) & 255,
! 771: (riff_size >> 8) & 255,
! 772: (riff_size >> 16) & 255,
! 773: (riff_size >> 24) & 255,
! 774: 'W', 'E', 'B', 'P',
! 775: 'V', 'P', '8', ' ',
! 776: (chunk_size >> 0) & 255,
! 777: (chunk_size >> 8) & 255,
! 778: (chunk_size >> 16) & 255,
! 779: (chunk_size >> 24) & 255 };
! 780: memcpy(*p_out, kRiffHeader, kRiffHeaderSize);
! 781:
! 782: if (psnr) {
! 783: *psnr = WebPGetPSNR(Y, U, V, *p_out, *p_out_size_bytes);
! 784: }
! 785:
! 786: return webp_success;
! 787: }
! 788: }
! 789:
! 790: void AdjustColorspace(uint8* Y, uint8* U, uint8* V, int width, int height) {
! 791: int y_width = width;
! 792: int y_height = height;
! 793: int y_stride = y_width;
! 794: int uv_width = ((y_width + 1) >> 1);
! 795: int uv_height = ((y_height + 1) >> 1);
! 796: int uv_stride = uv_width;
! 797: int x, y;
! 798: /* convert luma */
! 799: for (y = 0; y < y_height; ++y) {
! 800: uint8* const Yrow = Y + y * y_stride;
! 801: for (x = 0; x < y_width; ++x) {
! 802: /* maps [0..255] to [16..235] */
! 803: Yrow[x] = ((Yrow[x] * 55 + 32) >> 6) + 16;
! 804: }
! 805: }
! 806: /* convert chroma */
! 807: for (y = 0; y < uv_height; ++y) {
! 808: uint8* const Urow = U + y * uv_stride;
! 809: uint8* const Vrow = V + y * uv_stride;
! 810: for (x = 0; x < uv_width; ++x) {
! 811: /* maps [0..255] to [16..240] */
! 812: Urow[x] = (((Urow[x] - 127) * 7) >> 3) + 128;
! 813: Vrow[x] = (((Vrow[x] - 127) * 7) >> 3) + 128;
! 814: }
! 815: }
! 816: }
! 817:
! 818: void AdjustColorspaceBack(uint8* Y, uint8* U, uint8* V, int width, int height) {
! 819: int y_width = width;
! 820: int y_height = height;
! 821: int y_stride = y_width;
! 822: int uv_width = ((y_width + 1) >> 1);
! 823: int uv_height = ((y_height + 1) >> 1);
! 824: int uv_stride = uv_width;
! 825: int x, y;
! 826: /* convert luma */
! 827: for (y = 0; y < y_height; ++y) {
! 828: uint8* const Yrow = Y + y * y_stride;
! 829: for (x = 0; x < y_width; ++x) {
! 830: /* maps [16..235] to [0..255] */
! 831: const int v = ((Yrow[x] - 16) * 149 + 64) >> 7;
! 832: Yrow[x] = (v < 0) ? 0 : (v > 255) ? 255u : v;
! 833: }
! 834: }
! 835: /* convert chroma */
! 836: for (y = 0; y < uv_height; ++y) {
! 837: uint8* const Urow = U + y * uv_stride;
! 838: uint8* const Vrow = V + y * uv_stride;
! 839: for (x = 0; x < uv_width; ++x) {
! 840: /* maps [0..255] to [16..240] */
! 841: const int ru = (((Urow[x] - 128) * 73) >> 6) + 128;
! 842: const int rv = (((Vrow[x] - 128) * 73) >> 6) + 128;
! 843: Urow[x] = (ru < 0) ? 0 : (ru > 255) ? 255u : ru;
! 844: Vrow[x] = (rv < 0) ? 0 : (rv > 255) ? 255u : rv;
! 845: }
! 846: }
! 847: }
! 848:
! 849: WebPResult WebPGetInfo(const uint8* data,
! 850: int data_size,
! 851: int *width,
! 852: int *height) {
! 853: const uint32 chunk_size = SkipRiffHeader(&data, &data_size);
! 854:
! 855: if (width) *width = 0;
! 856: if (height) *height = 0;
! 857:
! 858: if (!chunk_size) {
! 859: return webp_failure; /* unsupported RIFF header */
! 860: }
! 861:
! 862: /* Validate raw video data */
! 863: if (data_size < 10) {
! 864: return webp_failure; /* not enough data */
! 865: }
! 866:
! 867: /* check signature */
! 868: if (data[3] != 0x9d || data[4] != 0x01 || data[5] != 0x2a) {
! 869: return webp_failure; /* Wrong signature. */
! 870: } else {
! 871: const uint32 bits = data[0] | (data[1] << 8) | (data[2] << 16);
! 872:
! 873: if ((bits & 1)) { /* Not a keyframe. */
! 874: return webp_failure;
! 875: } else {
! 876: const int profile = (bits >> 1) & 7;
! 877: const int show_frame = (bits >> 4) & 1;
! 878: const uint32 partition_length = (bits >> 5);
! 879:
! 880: if (profile > 3) {
! 881: return webp_failure; /* unknown profile */
! 882: }
! 883: if (!show_frame) {
! 884: return webp_failure; /* first frame is invisible! */
! 885: }
! 886: if (partition_length >= chunk_size) {
! 887: return webp_failure; /* inconsistent size information. */
! 888: } else {
! 889: const int w = ((data[7] << 8) | data[6]) & 0x3fff;
! 890: const int h = ((data[9] << 8) | data[8]) & 0x3fff;
! 891: if (width) *width = w;
! 892: if (height) *height = h;
! 893:
! 894: return webp_success;
! 895: }
! 896: }
! 897: }
! 898: return webp_failure;
! 899: }
! 900: #endif /* HAVE_LIBVPX */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to webpimg.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / php / ext / gd / libgd