285 lines
8.3 KiB
C
285 lines
8.3 KiB
C
/*
|
|
* Copyright (c) 2010 The WebM project authors. All Rights Reserved.
|
|
*
|
|
* Use of this source code is governed by a BSD-style license
|
|
* that can be found in the LICENSE file in the root of the source
|
|
* tree. An additional intellectual property rights grant can be found
|
|
* in the file PATENTS. All contributing project authors may
|
|
* be found in the AUTHORS file in the root of the source tree.
|
|
*/
|
|
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
|
|
#include "vpx/vpx_image.h"
|
|
#include "vpx/vpx_integer.h"
|
|
#include "vpx_mem/vpx_mem.h"
|
|
|
|
static vpx_image_t *img_alloc_helper(vpx_image_t *img,
|
|
vpx_img_fmt_t fmt,
|
|
unsigned int d_w,
|
|
unsigned int d_h,
|
|
unsigned int buf_align,
|
|
unsigned int stride_align,
|
|
unsigned char *img_data) {
|
|
unsigned int h, w, s, xcs, ycs, bps;
|
|
unsigned int stride_in_bytes;
|
|
int align;
|
|
|
|
/* Treat align==0 like align==1 */
|
|
if (!buf_align)
|
|
buf_align = 1;
|
|
|
|
/* Validate alignment (must be power of 2) */
|
|
if (buf_align & (buf_align - 1))
|
|
goto fail;
|
|
|
|
/* Treat align==0 like align==1 */
|
|
if (!stride_align)
|
|
stride_align = 1;
|
|
|
|
/* Validate alignment (must be power of 2) */
|
|
if (stride_align & (stride_align - 1))
|
|
goto fail;
|
|
|
|
/* Get sample size for this format */
|
|
switch (fmt) {
|
|
case VPX_IMG_FMT_RGB32:
|
|
case VPX_IMG_FMT_RGB32_LE:
|
|
case VPX_IMG_FMT_ARGB:
|
|
case VPX_IMG_FMT_ARGB_LE:
|
|
bps = 32;
|
|
break;
|
|
case VPX_IMG_FMT_RGB24:
|
|
case VPX_IMG_FMT_BGR24:
|
|
bps = 24;
|
|
break;
|
|
case VPX_IMG_FMT_RGB565:
|
|
case VPX_IMG_FMT_RGB565_LE:
|
|
case VPX_IMG_FMT_RGB555:
|
|
case VPX_IMG_FMT_RGB555_LE:
|
|
case VPX_IMG_FMT_UYVY:
|
|
case VPX_IMG_FMT_YUY2:
|
|
case VPX_IMG_FMT_YVYU:
|
|
bps = 16;
|
|
break;
|
|
case VPX_IMG_FMT_I420:
|
|
case VPX_IMG_FMT_YV12:
|
|
case VPX_IMG_FMT_VPXI420:
|
|
case VPX_IMG_FMT_VPXYV12:
|
|
bps = 12;
|
|
break;
|
|
case VPX_IMG_FMT_I422:
|
|
case VPX_IMG_FMT_I440:
|
|
bps = 16;
|
|
break;
|
|
case VPX_IMG_FMT_I444:
|
|
bps = 24;
|
|
break;
|
|
case VPX_IMG_FMT_I42016:
|
|
bps = 24;
|
|
break;
|
|
case VPX_IMG_FMT_I42216:
|
|
case VPX_IMG_FMT_I44016:
|
|
bps = 32;
|
|
break;
|
|
case VPX_IMG_FMT_I44416:
|
|
bps = 48;
|
|
break;
|
|
default:
|
|
bps = 16;
|
|
break;
|
|
}
|
|
|
|
/* Get chroma shift values for this format */
|
|
switch (fmt) {
|
|
case VPX_IMG_FMT_I420:
|
|
case VPX_IMG_FMT_YV12:
|
|
case VPX_IMG_FMT_VPXI420:
|
|
case VPX_IMG_FMT_VPXYV12:
|
|
case VPX_IMG_FMT_I422:
|
|
case VPX_IMG_FMT_I42016:
|
|
case VPX_IMG_FMT_I42216:
|
|
xcs = 1;
|
|
break;
|
|
default:
|
|
xcs = 0;
|
|
break;
|
|
}
|
|
|
|
switch (fmt) {
|
|
case VPX_IMG_FMT_I420:
|
|
case VPX_IMG_FMT_I440:
|
|
case VPX_IMG_FMT_YV12:
|
|
case VPX_IMG_FMT_VPXI420:
|
|
case VPX_IMG_FMT_VPXYV12:
|
|
case VPX_IMG_FMT_I42016:
|
|
case VPX_IMG_FMT_I44016:
|
|
ycs = 1;
|
|
break;
|
|
default:
|
|
ycs = 0;
|
|
break;
|
|
}
|
|
|
|
/* Calculate storage sizes given the chroma subsampling */
|
|
align = (1 << xcs) - 1;
|
|
w = (d_w + align) & ~align;
|
|
align = (1 << ycs) - 1;
|
|
h = (d_h + align) & ~align;
|
|
s = (fmt & VPX_IMG_FMT_PLANAR) ? w : bps * w / 8;
|
|
s = (s + stride_align - 1) & ~(stride_align - 1);
|
|
stride_in_bytes = (fmt & VPX_IMG_FMT_HIGHBITDEPTH) ? s * 2 : s;
|
|
|
|
/* Allocate the new image */
|
|
if (!img) {
|
|
img = (vpx_image_t *)calloc(1, sizeof(vpx_image_t));
|
|
|
|
if (!img)
|
|
goto fail;
|
|
|
|
img->self_allocd = 1;
|
|
} else {
|
|
memset(img, 0, sizeof(vpx_image_t));
|
|
}
|
|
|
|
img->img_data = img_data;
|
|
|
|
if (!img_data) {
|
|
const uint64_t alloc_size = (fmt & VPX_IMG_FMT_PLANAR) ?
|
|
(uint64_t)h * s * bps / 8 : (uint64_t)h * s;
|
|
|
|
if (alloc_size != (size_t)alloc_size)
|
|
goto fail;
|
|
|
|
img->img_data = (uint8_t *)vpx_memalign(buf_align, (size_t)alloc_size);
|
|
img->img_data_owner = 1;
|
|
}
|
|
|
|
if (!img->img_data)
|
|
goto fail;
|
|
|
|
img->fmt = fmt;
|
|
img->bit_depth = (fmt & VPX_IMG_FMT_HIGHBITDEPTH) ? 16 : 8;
|
|
img->w = w;
|
|
img->h = h;
|
|
img->x_chroma_shift = xcs;
|
|
img->y_chroma_shift = ycs;
|
|
img->bps = bps;
|
|
|
|
/* Calculate strides */
|
|
img->stride[VPX_PLANE_Y] = img->stride[VPX_PLANE_ALPHA] = stride_in_bytes;
|
|
img->stride[VPX_PLANE_U] = img->stride[VPX_PLANE_V] = stride_in_bytes >> xcs;
|
|
|
|
/* Default viewport to entire image */
|
|
if (!vpx_img_set_rect(img, 0, 0, d_w, d_h))
|
|
return img;
|
|
|
|
fail:
|
|
vpx_img_free(img);
|
|
return NULL;
|
|
}
|
|
|
|
vpx_image_t *vpx_img_alloc(vpx_image_t *img,
|
|
vpx_img_fmt_t fmt,
|
|
unsigned int d_w,
|
|
unsigned int d_h,
|
|
unsigned int align) {
|
|
return img_alloc_helper(img, fmt, d_w, d_h, align, align, NULL);
|
|
}
|
|
|
|
vpx_image_t *vpx_img_wrap(vpx_image_t *img,
|
|
vpx_img_fmt_t fmt,
|
|
unsigned int d_w,
|
|
unsigned int d_h,
|
|
unsigned int stride_align,
|
|
unsigned char *img_data) {
|
|
/* By setting buf_align = 1, we don't change buffer alignment in this
|
|
* function. */
|
|
return img_alloc_helper(img, fmt, d_w, d_h, 1, stride_align, img_data);
|
|
}
|
|
|
|
int vpx_img_set_rect(vpx_image_t *img,
|
|
unsigned int x,
|
|
unsigned int y,
|
|
unsigned int w,
|
|
unsigned int h) {
|
|
unsigned char *data;
|
|
|
|
if (x + w <= img->w && y + h <= img->h) {
|
|
img->d_w = w;
|
|
img->d_h = h;
|
|
|
|
/* Calculate plane pointers */
|
|
if (!(img->fmt & VPX_IMG_FMT_PLANAR)) {
|
|
img->planes[VPX_PLANE_PACKED] =
|
|
img->img_data + x * img->bps / 8 + y * img->stride[VPX_PLANE_PACKED];
|
|
} else {
|
|
const int bytes_per_sample =
|
|
(img->fmt & VPX_IMG_FMT_HIGHBITDEPTH) ? 2 : 1;
|
|
data = img->img_data;
|
|
|
|
if (img->fmt & VPX_IMG_FMT_HAS_ALPHA) {
|
|
img->planes[VPX_PLANE_ALPHA] =
|
|
data + x * bytes_per_sample + y * img->stride[VPX_PLANE_ALPHA];
|
|
data += img->h * img->stride[VPX_PLANE_ALPHA];
|
|
}
|
|
|
|
img->planes[VPX_PLANE_Y] = data + x * bytes_per_sample +
|
|
y * img->stride[VPX_PLANE_Y];
|
|
data += img->h * img->stride[VPX_PLANE_Y];
|
|
|
|
if (!(img->fmt & VPX_IMG_FMT_UV_FLIP)) {
|
|
img->planes[VPX_PLANE_U] =
|
|
data + (x >> img->x_chroma_shift) * bytes_per_sample +
|
|
(y >> img->y_chroma_shift) * img->stride[VPX_PLANE_U];
|
|
data += (img->h >> img->y_chroma_shift) * img->stride[VPX_PLANE_U];
|
|
img->planes[VPX_PLANE_V] =
|
|
data + (x >> img->x_chroma_shift) * bytes_per_sample +
|
|
(y >> img->y_chroma_shift) * img->stride[VPX_PLANE_V];
|
|
} else {
|
|
img->planes[VPX_PLANE_V] =
|
|
data + (x >> img->x_chroma_shift) * bytes_per_sample +
|
|
(y >> img->y_chroma_shift) * img->stride[VPX_PLANE_V];
|
|
data += (img->h >> img->y_chroma_shift) * img->stride[VPX_PLANE_V];
|
|
img->planes[VPX_PLANE_U] =
|
|
data + (x >> img->x_chroma_shift) * bytes_per_sample +
|
|
(y >> img->y_chroma_shift) * img->stride[VPX_PLANE_U];
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
void vpx_img_flip(vpx_image_t *img) {
|
|
/* Note: In the calculation pointer adjustment calculation, we want the
|
|
* rhs to be promoted to a signed type. Section 6.3.1.8 of the ISO C99
|
|
* standard indicates that if the adjustment parameter is unsigned, the
|
|
* stride parameter will be promoted to unsigned, causing errors when
|
|
* the lhs is a larger type than the rhs.
|
|
*/
|
|
img->planes[VPX_PLANE_Y] += (signed)(img->d_h - 1) * img->stride[VPX_PLANE_Y];
|
|
img->stride[VPX_PLANE_Y] = -img->stride[VPX_PLANE_Y];
|
|
|
|
img->planes[VPX_PLANE_U] += (signed)((img->d_h >> img->y_chroma_shift) - 1)
|
|
* img->stride[VPX_PLANE_U];
|
|
img->stride[VPX_PLANE_U] = -img->stride[VPX_PLANE_U];
|
|
|
|
img->planes[VPX_PLANE_V] += (signed)((img->d_h >> img->y_chroma_shift) - 1)
|
|
* img->stride[VPX_PLANE_V];
|
|
img->stride[VPX_PLANE_V] = -img->stride[VPX_PLANE_V];
|
|
|
|
img->planes[VPX_PLANE_ALPHA] += (signed)(img->d_h - 1) * img->stride[VPX_PLANE_ALPHA];
|
|
img->stride[VPX_PLANE_ALPHA] = -img->stride[VPX_PLANE_ALPHA];
|
|
}
|
|
|
|
void vpx_img_free(vpx_image_t *img) {
|
|
if (img) {
|
|
if (img->img_data && img->img_data_owner)
|
|
vpx_free(img->img_data);
|
|
|
|
if (img->self_allocd)
|
|
free(img);
|
|
}
|
|
}
|