dany/libwebp
1
0
Fork 0
mirror of https://github.com/webmproject/libwebp.git synced 2024-11-19 20:08:28 +01:00
Code Issues Actions Packages Projects Releases Wiki Activity

convert to ANSI-C

Browse Source
This commit is contained in:
Pierre Joye 2010-10-05 16:58:47 -07:00 committed by Pascal Massimino
parent c3f41cb47e
commit c8d15efa12
11 changed files with 382 additions and 482 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
AUTHORS
View File

@ -1,3 +1,5 @@
Main stuff:
Initial release:
- Pascal Massimino (pascal.massimino@gmail.com)
Contributors:
- pierre.php@gmail.com (ansi-C port)

2
Android.mk
View File

@ -13,7 +13,7 @@ LOCAL_SRC_FILES := \
LOCAL_CFLAGS := -Wall -DANDROID -DHAVE_MALLOC_H -DHAVE_PTHREAD \
-finline-functions -frename-registers -ffast-math \
-s -fomit-frame-pointer -std=gnu99
-s -fomit-frame-pointer
LOCAL_C_INCLUDES += $(LOCAL_PATH)/src

201
configure vendored
View File

@ -19742,207 +19742,6 @@ LIBTOOL='$(SHELL) $(top_builddir)/libtool'
{ echo "$as_me:$LINENO: checking for $CC option to accept ISO C99" >&5
echo $ECHO_N "checking for $CC option to accept ISO C99... $ECHO_C" >&6; }
if test "${ac_cv_prog_cc_c99+set}" = set; then
echo $ECHO_N "(cached) $ECHO_C" >&6
else
ac_cv_prog_cc_c99=no
ac_save_CC=$CC
cat >conftest.$ac_ext <<_ACEOF
/* confdefs.h. */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h. */
#include <stdarg.h>
#include <stdbool.h>
#include <stdlib.h>
#include <wchar.h>
#include <stdio.h>
// Check varargs macros. These examples are taken from C99 6.10.3.5.
#define debug(...) fprintf (stderr, __VA_ARGS__)
#define showlist(...) puts (#__VA_ARGS__)
#define report(test,...) ((test) ? puts (#test) : printf (__VA_ARGS__))
static void
test_varargs_macros (void)
{
int x = 1234;
int y = 5678;
debug ("Flag");
debug ("X = %d\n", x);
showlist (The first, second, and third items.);
report (x>y, "x is %d but y is %d", x, y);
}
// Check long long types.
#define BIG64 18446744073709551615ull
#define BIG32 4294967295ul
#define BIG_OK (BIG64 / BIG32 == 4294967297ull && BIG64 % BIG32 == 0)
#if !BIG_OK
your preprocessor is broken;
#endif
#if BIG_OK
#else
your preprocessor is broken;
#endif
static long long int bignum = -9223372036854775807LL;
static unsigned long long int ubignum = BIG64;
struct incomplete_array
{
int datasize;
double data[];
};
struct named_init {
int number;
const wchar_t *name;
double average;
};
typedef const char *ccp;
static inline int
test_restrict (ccp restrict text)
{
// See if C++-style comments work.
// Iterate through items via the restricted pointer.
// Also check for declarations in for loops.
for (unsigned int i = 0; *(text+i) != '\0'; ++i)
continue;
return 0;
}
// Check varargs and va_copy.
static void
test_varargs (const char *format, ...)
{
va_list args;
va_start (args, format);
va_list args_copy;
va_copy (args_copy, args);
const char *str;
int number;
float fnumber;
while (*format)
{
switch (*format++)
{
case 's': // string
str = va_arg (args_copy, const char *);
break;
case 'd': // int
number = va_arg (args_copy, int);
break;
case 'f': // float
fnumber = va_arg (args_copy, double);
break;
default:
break;
}
}
va_end (args_copy);
va_end (args);
}
int
main ()
{
// Check bool.
_Bool success = false;
// Check restrict.
if (test_restrict ("String literal") == 0)
success = true;
char *restrict newvar = "Another string";
// Check varargs.
test_varargs ("s, d' f .", "string", 65, 34.234);
test_varargs_macros ();
// Check flexible array members.
struct incomplete_array *ia =
malloc (sizeof (struct incomplete_array) + (sizeof (double) * 10));
ia->datasize = 10;
for (int i = 0; i < ia->datasize; ++i)
ia->data[i] = i * 1.234;
// Check named initializers.
struct named_init ni = {
.number = 34,
.name = L"Test wide string",
.average = 543.34343,
};
ni.number = 58;
int dynamic_array[ni.number];
dynamic_array[ni.number - 1] = 543;
// work around unused variable warnings
return (!success || bignum == 0LL || ubignum == 0uLL || newvar[0] == 'x'
|| dynamic_array[ni.number - 1] != 543);
;
return 0;
}
_ACEOF
for ac_arg in '' -std=gnu99 -c99 -qlanglvl=extc99
do
CC="$ac_save_CC $ac_arg"
rm -f conftest.$ac_objext
if { (ac_try="$ac_compile"
case "(($ac_try" in
*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
*) ac_try_echo=$ac_try;;
esac
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
(eval "$ac_compile") 2>conftest.er1
ac_status=$?
grep -v '^ *+' conftest.er1 >conftest.err
rm -f conftest.er1
cat conftest.err >&5
echo "$as_me:$LINENO: \$? = $ac_status" >&5
(exit $ac_status); } && {
test -z "$ac_c_werror_flag" ||
test ! -s conftest.err
} && test -s conftest.$ac_objext; then
ac_cv_prog_cc_c99=$ac_arg
else
echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5
fi
rm -f core conftest.err conftest.$ac_objext
test "x$ac_cv_prog_cc_c99" != "xno" && break
done
rm -f conftest.$ac_ext
CC=$ac_save_CC
fi
# AC_CACHE_VAL
case "x$ac_cv_prog_cc_c99" in
x)
{ echo "$as_me:$LINENO: result: none needed" >&5
echo "${ECHO_T}none needed" >&6; } ;;
xno)
{ echo "$as_me:$LINENO: result: unsupported" >&5
echo "${ECHO_T}unsupported" >&6; } ;;
*)
CC="$CC $ac_cv_prog_cc_c99"
{ echo "$as_me:$LINENO: result: $ac_cv_prog_cc_c99" >&5
echo "${ECHO_T}$ac_cv_prog_cc_c99" >&6; } ;;
esac
ac_config_headers="$ac_config_headers config.h"
ac_config_files="$ac_config_files Makefile examples/Makefile src/Makefile"

1
configure.ac
View File

@ -1,7 +1,6 @@
AC_INIT([webpdecode], [0.1])
AM_INIT_AUTOMAKE
AC_PROG_LIBTOOL
AC_PROG_CC_C99
AC_CONFIG_HEADERS([config.h])
AC_CONFIG_FILES([Makefile examples/Makefile src/Makefile])
AC_OUTPUT

93
src/dsp.c
View File

@ -32,17 +32,18 @@ static int tables_ok = 0;
void VP8DspInitTables() {
if (!tables_ok) {
for (int i = -255; i <= 255; ++i) {
int i;
for (i = -255; i <= 255; ++i) {
abs0[255 + i] = (i < 0) ? -i : i;
abs1[255 + i] = abs0[255 + i] >> 1;
}
for (int i = -1020; i <= 1020; ++i) {
for (i = -1020; i <= 1020; ++i) {
sclip1[1020 + i] = (i < -128) ? -128 : (i > 127) ? 127 : i;
}
for (int i = -112; i <= 112; ++i) {
for (i = -112; i <= 112; ++i) {
sclip2[112 + i] = (i < -16) ? -16 : (i > 15) ? 15 : i;
}
for (int i = -255; i <= 255 + 255; ++i) {
for (i = -255; i <= 255 + 255; ++i) {
clip1[255 + i] = (i < 0) ? 0 : (i > 255) ? 255 : i;
}
tables_ok = 1;
@ -66,8 +67,9 @@ static const int kC2 = 35468;
static void Transform(const int16_t* in, uint8_t* dst) {
int C[4 * 4], *tmp;
int i;
tmp = C;
for (int i = 0; i < 4; ++i) { // vertical pass
for (i = 0; i < 4; ++i) { // vertical pass
const int a = in[0] + in[8];
const int b = in[0] - in[8];
const int c = MUL(in[4], kC2) - MUL(in[12], kC1);
@ -81,7 +83,7 @@ static void Transform(const int16_t* in, uint8_t* dst) {
}
tmp = C;
for (int i = 0; i < 4; ++i) { // horizontal pass
for (i = 0; i < 4; ++i) { // horizontal pass
const int dc = tmp[0] + 4;
const int a = dc + tmp[8];
const int b = dc - tmp[8];
@ -106,8 +108,9 @@ static void TransformUV(const int16_t* in, uint8_t* dst) {
static void TransformDC(const int16_t *in, uint8_t* dst) {
const int DC = in[0] + 4;
for (int j = 0; j < 4; ++j) {
for (int i = 0; i < 4; ++i) {
int i, j;
for (j = 0; j < 4; ++j) {
for (i = 0; i < 4; ++i) {
STORE(i, j, DC);
}
}
@ -133,7 +136,8 @@ VP8Idct VP8TransformDCUV = TransformDCUV;
static void TransformWHT(const int16_t* in, int16_t* out) {
int tmp[16];
for (int i = 0; i < 4; ++i) {
int i;
for (i = 0; i < 4; ++i) {
const int a0 = in[0 + i] + in[12 + i];
const int a1 = in[4 + i] + in[ 8 + i];
const int a2 = in[4 + i] - in[ 8 + i];
@ -143,7 +147,7 @@ static void TransformWHT(const int16_t* in, int16_t* out) {
tmp[4 + i] = a3 + a2;
tmp[12 + i] = a3 - a2;
}
for (int i = 0; i < 4; ++i) {
for (i = 0; i < 4; ++i) {
const int dc = tmp[0 + i * 4] + 3; // w/ rounder
const int a0 = dc + tmp[3 + i * 4];
const int a1 = tmp[1 + i * 4] + tmp[2 + i * 4];
@ -167,9 +171,11 @@ void (*VP8TransformWHT)(const int16_t* in, int16_t* out) = TransformWHT;
static inline void TrueMotion(uint8_t *dst, int size) {
const uint8_t* top = dst - BPS;
const int tl = top[-1];
for (int y = 0; y < size; ++y) {
int x, y;
for (y = 0; y < size; ++y) {
const uint8_t* const clip = clip1 + 255 + dst[-1] - tl;
for (int x = 0; x < size; ++x) {
for (x = 0; x < size; ++x) {
dst[x] = clip[top[x]];
}
dst += BPS;
@ -183,27 +189,31 @@ static void TM16(uint8_t *dst) { TrueMotion(dst, 16); }
// 16x16
static void V16(uint8_t *dst) { // vertical
for (int j = 0; j < 16; ++j) {
int j;
for (j = 0; j < 16; ++j) {
memcpy(dst + j * BPS, dst - BPS, 16);
}
}
static void H16(uint8_t *dst) { // horizontal
for (int j = 16; j > 0; --j) {
int j;
for (j = 16; j > 0; --j) {
memset(dst, dst[-1], 16);
dst += BPS;
}
}
static inline void Put16(int v, uint8_t* dst) {
for (int j = 0; j < 16; ++j) {
int j;
for (j = 0; j < 16; ++j) {
memset(dst + j * BPS, v, 16);
}
}
static void DC16(uint8_t *dst) { // DC
int DC = 16;
for (int j = 0; j < 16; ++j) {
int j;
for (j = 0; j < 16; ++j) {
DC += dst[-1 + j * BPS] + dst[j - BPS];
}
Put16(DC >> 5, dst);
@ -235,7 +245,8 @@ static void DC16NoTopLeft(uint8_t *dst) { // DC with no top and left samples
// 4x4
static inline void Put4(uint32_t v, uint8_t* dst) {
for (int i = 4; i > 0; --i) {
int i;
for (i = 4; i > 0; --i) {
*(uint32_t*)dst = v;
dst += BPS;
}
@ -270,7 +281,8 @@ static void H4(uint8_t *dst) { // horizontal
static void DC4(uint8_t *dst) { // DC
uint32_t dc = 4;
for (int i = 0; i < 4; ++i) {
int i;
for (i = 0; i < 4; ++i) {
dc += dst[i - BPS] + dst[-1 + i * BPS];
}
Put4((dc >> 3) * 0x01010101U, dst);
@ -402,13 +414,15 @@ static void HD4(uint8_t *dst) { // Horizontal-Down
// Chroma
static void V8uv(uint8_t *dst) { // vertical
for (int j = 0; j < 8; ++j) {
int j;
for (j = 0; j < 8; ++j) {
memcpy(dst + j * BPS, dst - BPS, 8);
}
}
static void H8uv(uint8_t *dst) { // horizontal
for (int j = 0; j < 8; ++j) {
int j;
for (j = 0; j < 8; ++j) {
memset(dst, dst[-1], 8);
dst += BPS;
}
@ -416,36 +430,37 @@ static void H8uv(uint8_t *dst) { // horizontal
// helper for chroma-DC predictions
static inline void Put8x8uv(uint64_t v, uint8_t* dst) {
for (int j = 0; j < 8; ++j) {
int j;
for (j = 0; j < 8; ++j) {
*(uint64_t*)(dst + j * BPS) = v;
}
}
static void DC8uv(uint8_t *dst) { // DC
int dc0 = 8;
for (int i = 0; i < 8; ++i) {
int i;
for (i = 0; i < 8; ++i) {
dc0 += dst[i - BPS] + dst[-1 + i * BPS];
}
const uint64_t t = (dc0 >> 4) * 0x0101010101010101ULL;
Put8x8uv(t, dst);
Put8x8uv((uint64_t)((dc0 >> 4) * 0x0101010101010101ULL), dst);
}
static void DC8uvNoLeft(uint8_t *dst) { // DC with no left samples
int dc0 = 4;
for (int i = 0; i < 8; ++i) {
int i;
for (i = 0; i < 8; ++i) {
dc0 += dst[i - BPS];
}
const uint64_t v = (dc0 >> 3) * 0x0101010101010101ULL;
Put8x8uv(v, dst);
Put8x8uv((uint64_t)((dc0 >> 3) * 0x0101010101010101ULL), dst);
}
static void DC8uvNoTop(uint8_t *dst) { // DC with no top samples
int dc0 = 4;
for (int i = 0; i < 8; ++i) {
int i;
for (i = 0; i < 8; ++i) {
dc0 += dst[-1 + i * BPS];
}
const uint64_t v = (dc0 >> 3) * 0x0101010101010101ULL;
Put8x8uv(v, dst);
Put8x8uv((uint64_t)((dc0 >> 3) * 0x0101010101010101ULL), dst);
}
static void DC8uvNoTopLeft(uint8_t *dst) { // DC with nothing
@ -535,7 +550,8 @@ static inline int needs_filter2(const uint8_t* p, int step, int t, int it) {
// Simple In-loop filtering (Paragraph 15.2)
static void SimpleVFilter16(uint8_t* p, int stride, int thresh) {
for (int i = 0; i < 16; ++i) {
int i;
for (i = 0; i < 16; ++i) {
if (needs_filter(p + i, stride, thresh)) {
do_filter2(p + i, stride);
}
@ -543,7 +559,8 @@ static void SimpleVFilter16(uint8_t* p, int stride, int thresh) {
}
static void SimpleHFilter16(uint8_t* p, int stride, int thresh) {
for (int i = 0; i < 16; ++i) {
int i;
for (i = 0; i < 16; ++i) {
if (needs_filter(p + i * stride, 1, thresh)) {
do_filter2(p + i * stride, 1);
}
@ -551,14 +568,16 @@ static void SimpleHFilter16(uint8_t* p, int stride, int thresh) {
}
static void SimpleVFilter16i(uint8_t* p, int stride, int thresh) {
for (int k = 3; k > 0; --k) {
int k;
for (k = 3; k > 0; --k) {
p += 4 * stride;
SimpleVFilter16(p, stride, thresh);
}
}
static void SimpleHFilter16i(uint8_t* p, int stride, int thresh) {
for (int k = 3; k > 0; --k) {
int k;
for (k = 3; k > 0; --k) {
p += 4;
SimpleHFilter16(p, stride, thresh);
}
@ -609,7 +628,8 @@ static void HFilter16(uint8_t* p, int stride,
// on three inner edges
static void VFilter16i(uint8_t* p, int stride,
int thresh, int ithresh, int hev_thresh) {
for (int k = 3; k > 0; --k) {
int k;
for (k = 3; k > 0; --k) {
p += 4 * stride;
FilterLoop24(p, stride, 1, 16, thresh, ithresh, hev_thresh);
}
@ -617,7 +637,8 @@ static void VFilter16i(uint8_t* p, int stride,
static void HFilter16i(uint8_t* p, int stride,
int thresh, int ithresh, int hev_thresh) {
for (int k = 3; k > 0; --k) {
int k;
for (k = 3; k > 0; --k) {
p += 4;
FilterLoop24(p, 1, stride, 16, thresh, ithresh, hev_thresh);
}

254
src/frame.c
View File

@ -38,6 +38,8 @@ int VP8InitFrame(VP8Decoder* const dec, VP8Io* io) {
+ top_size + info_size
+ yuv_size + coeffs_size
+ cache_size + ALIGN_MASK;
uint8_t* mem;
if (needed > dec->mem_size_) {
free(dec->mem_);
dec->mem_size_ = 0;
@ -48,7 +50,7 @@ int VP8InitFrame(VP8Decoder* const dec, VP8Io* io) {
dec->mem_size_ = needed;
}
uint8_t* mem = (uint8_t*)dec->mem_;
mem = (uint8_t*)dec->mem_;
dec->intra_t_ = (uint8_t*)mem;
mem += intra_pred_mode_size;
@ -198,65 +200,71 @@ void VP8StoreBlock(VP8Decoder* const dec) {
level = 9 - dec->filter_hdr_.sharpness_;
}
}
info->f_ilevel_ = (level < 1) ? 1 : level;
info->f_inner_ = (!info->skip_ || dec->is_i4x4_);
// Transfer samples to row cache
uint8_t* const ydst = dec->cache_y_ + dec->mb_x_ * 16;
uint8_t* const udst = dec->cache_u_ + dec->mb_x_ * 8;
uint8_t* const vdst = dec->cache_v_ + dec->mb_x_ * 8;
for (int y = 0; y < 16; ++y) {
memcpy(ydst + y * dec->cache_y_stride_,
dec->yuv_b_ + Y_OFF + y * BPS, 16);
}
for (int y = 0; y < 8; ++y) {
memcpy(udst + y * dec->cache_uv_stride_,
{
// Transfer samples to row cache
int y;
uint8_t* const ydst = dec->cache_y_ + dec->mb_x_ * 16;
uint8_t* const udst = dec->cache_u_ + dec->mb_x_ * 8;
uint8_t* const vdst = dec->cache_v_ + dec->mb_x_ * 8;
for (y = 0; y < 16; ++y) {
memcpy(ydst + y * dec->cache_y_stride_,
dec->yuv_b_ + Y_OFF + y * BPS, 16);
}
for (y = 0; y < 8; ++y) {
memcpy(udst + y * dec->cache_uv_stride_,
dec->yuv_b_ + U_OFF + y * BPS, 8);
memcpy(vdst + y * dec->cache_uv_stride_,
memcpy(vdst + y * dec->cache_uv_stride_,
dec->yuv_b_ + V_OFF + y * BPS, 8);
}
}
}
void VP8FilterRow(VP8Decoder* const dec, VP8Io* io) {
for (int mb_x = 0; mb_x < dec->mb_w_; ++mb_x) {
int mb_x;
for (mb_x = 0; mb_x < dec->mb_w_; ++mb_x) {
DoFilter(dec, mb_x, dec->mb_y_);
}
const int extra_y_rows = kFilterExtraRows[dec->filter_type_];
const int ysize = extra_y_rows * dec->cache_y_stride_;
const int uvsize = (extra_y_rows / 2) * dec->cache_uv_stride_;
uint8_t* const ydst = dec->cache_y_ - ysize;
uint8_t* const udst = dec->cache_u_ - uvsize;
uint8_t* const vdst = dec->cache_v_ - uvsize;
if (io->put) {
int y_end;
if (dec->mb_y_ > 0) {
io->mb_y = dec->mb_y_ * 16 - extra_y_rows;
io->y = ydst;
io->u = udst;
io->v = vdst;
if (dec->mb_y_ < dec->mb_h_ - 1) {
y_end = io->mb_y + 16;
} else {
y_end = io->height; // last macroblock row.
{
const int extra_y_rows = kFilterExtraRows[dec->filter_type_];
const int ysize = extra_y_rows * dec->cache_y_stride_;
const int uvsize = (extra_y_rows / 2) * dec->cache_uv_stride_;
uint8_t* const ydst = dec->cache_y_ - ysize;
uint8_t* const udst = dec->cache_u_ - uvsize;
uint8_t* const vdst = dec->cache_v_ - uvsize;
if (io->put) {
int y_end;
if (dec->mb_y_ > 0) {
io->mb_y = dec->mb_y_ * 16 - extra_y_rows;
io->y = ydst;
io->u = udst;
io->v = vdst;
if (dec->mb_y_ < dec->mb_h_ - 1) {
y_end = io->mb_y + 16;
} else {
y_end = io->height; // last macroblock row.
}
} else { // first macroblock row.
io->mb_y = 0;
y_end = 16 - extra_y_rows;
io->y = dec->cache_y_;
io->u = dec->cache_u_;
io->v = dec->cache_v_;
}
} else { // first macroblock row.
io->mb_y = 0;
y_end = 16 - extra_y_rows;
io->y = dec->cache_y_;
io->u = dec->cache_u_;
io->v = dec->cache_v_;
if (y_end > io->height) {
y_end = io->height;
}
io->mb_h = y_end - io->mb_y;
io->put(io);
}
if (y_end > io->height) {
y_end = io->height;
// rotate top samples
if (dec->mb_y_ < dec->mb_h_ - 1) {
memcpy(ydst, ydst + 16 * dec->cache_y_stride_, ysize);
memcpy(udst, udst + 8 * dec->cache_uv_stride_, uvsize);
memcpy(vdst, vdst + 8 * dec->cache_uv_stride_, uvsize);
}
io->mb_h = y_end - io->mb_y;
io->put(io);
}
// rotate top samples
if (dec->mb_y_ < dec->mb_h_ - 1) {
memcpy(ydst, ydst + 16 * dec->cache_y_stride_, ysize);
memcpy(udst, udst + 8 * dec->cache_uv_stride_, uvsize);
memcpy(vdst, vdst + 8 * dec->cache_uv_stride_, uvsize);
}
}
@ -294,18 +302,20 @@ void VP8ReconstructBlock(VP8Decoder* const dec) {
// Rotate in the left samples from previously decoded block. We move four
// pixels at a time for alignment reason, and because of in-loop filter.
if (dec->mb_x_ > 0) {
for (int j = -1; j < 16; ++j) {
int j;
for (j = -1; j < 16; ++j) {
Copy32b(&y_dst[j * BPS - 4], &y_dst[j * BPS + 12]);
}
for (int j = -1; j < 8; ++j) {
for (j = -1; j < 8; ++j) {
Copy32b(&u_dst[j * BPS - 4], &u_dst[j * BPS + 4]);
Copy32b(&v_dst[j * BPS - 4], &v_dst[j * BPS + 4]);
}
} else {
for (int j = 0; j < 16; ++j) {
int j;
for (j = 0; j < 16; ++j) {
y_dst[j * BPS - 1] = 129;
}
for (int j = 0; j < 8; ++j) {
for (j = 0; j < 8; ++j) {
u_dst[j * BPS - 1] = 129;
v_dst[j * BPS - 1] = 129;
}
@ -314,90 +324,96 @@ void VP8ReconstructBlock(VP8Decoder* const dec) {
y_dst[-1 - BPS] = u_dst[-1 - BPS] = v_dst[-1 - BPS] = 129;
}
}
{
// bring top samples into the cache
uint8_t* const top_y = dec->y_t_ + dec->mb_x_ * 16;
uint8_t* const top_u = dec->u_t_ + dec->mb_x_ * 8;
uint8_t* const top_v = dec->v_t_ + dec->mb_x_ * 8;
const int16_t* coeffs = dec->coeffs_;
int n;
// bring top samples into the cache
uint8_t* const top_y = dec->y_t_ + dec->mb_x_ * 16;
uint8_t* const top_u = dec->u_t_ + dec->mb_x_ * 8;
uint8_t* const top_v = dec->v_t_ + dec->mb_x_ * 8;
if (dec->mb_y_ > 0) {
memcpy(y_dst - BPS, top_y, 16);
memcpy(u_dst - BPS, top_u, 8);
memcpy(v_dst - BPS, top_v, 8);
} else if (dec->mb_x_ == 0) {
// we only need to do this init once at block (0,0).
// Afterward, it remains valid for the whole topmost row.
memset(y_dst - BPS - 1, 127, 16 + 4 + 1);
memset(u_dst - BPS - 1, 127, 8 + 1);
memset(v_dst - BPS - 1, 127, 8 + 1);
}
// predict and add residuals
const int16_t* coeffs = dec->coeffs_;
if (dec->is_i4x4_) { // 4x4
uint32_t* const top_right = (uint32_t*)(y_dst - BPS + 16);
if (dec->mb_y_ > 0) {
if (dec->mb_x_ >= dec->mb_w_ - 1) { // on rightmost border
top_right[0] = top_y[15] * 0x01010101u;
} else {
memcpy(top_right, top_y + 16, sizeof(*top_right));
}
memcpy(y_dst - BPS, top_y, 16);
memcpy(u_dst - BPS, top_u, 8);
memcpy(v_dst - BPS, top_v, 8);
} else if (dec->mb_x_ == 0) {
// we only need to do this init once at block (0,0).
// Afterward, it remains valid for the whole topmost row.
memset(y_dst - BPS - 1, 127, 16 + 4 + 1);
memset(u_dst - BPS - 1, 127, 8 + 1);
memset(v_dst - BPS - 1, 127, 8 + 1);
}
// replicate the top-right pixels below
top_right[BPS] = top_right[2 * BPS] = top_right[3 * BPS] = top_right[0];
// predict and add residues for all 4x4 blocks in turn.
for (int n = 0; n < 16; n++) {
uint8_t* const dst = y_dst + kScan[n];
VP8PredLuma4[dec->imodes_[n]](dst);
if (dec->non_zero_ & (1 << n)) {
VP8Transform(coeffs + n * 16, dst);
} else if (dec->non_zero_ & (1 << n)) { // only DC is present
VP8TransformDC(coeffs + n * 16, dst);
// predict and add residuals
if (dec->is_i4x4_) { // 4x4
uint32_t* const top_right = (uint32_t*)(y_dst - BPS + 16);
if (dec->mb_y_ > 0) {
if (dec->mb_x_ >= dec->mb_w_ - 1) { // on rightmost border
top_right[0] = top_y[15] * 0x01010101u;
} else {
memcpy(top_right, top_y + 16, sizeof(*top_right));
}
}
}
} else { // 16x16
const int pred_func = CheckMode(dec, dec->imodes_[0]);
VP8PredLuma16[pred_func](y_dst);
if (dec->non_zero_) {
for (int n = 0; n < 16; n++) {
// replicate the top-right pixels below
top_right[BPS] = top_right[2 * BPS] = top_right[3 * BPS] = top_right[0];
// predict and add residues for all 4x4 blocks in turn.
for (n = 0; n < 16; n++) {
uint8_t* const dst = y_dst + kScan[n];
if (dec->non_zero_ac_ & (1 << n)) {
VP8PredLuma4[dec->imodes_[n]](dst);
if (dec->non_zero_ & (1 << n)) {
VP8Transform(coeffs + n * 16, dst);
} else if (dec->non_zero_ & (1 << n)) { // only DC is present
VP8TransformDC(coeffs + n * 16, dst);
}
}
} else { // 16x16
const int pred_func = CheckMode(dec, dec->imodes_[0]);
VP8PredLuma16[pred_func](y_dst);
if (dec->non_zero_) {
for (n = 0; n < 16; n++) {
uint8_t* const dst = y_dst + kScan[n];
if (dec->non_zero_ac_ & (1 << n)) {
VP8Transform(coeffs + n * 16, dst);
} else if (dec->non_zero_ & (1 << n)) { // only DC is present
VP8TransformDC(coeffs + n * 16, dst);
}
}
}
}
}
{
// Chroma
const int pred_func = CheckMode(dec, dec->uvmode_);
VP8PredChroma8[pred_func](u_dst);
VP8PredChroma8[pred_func](v_dst);
// Chroma
const int pred_func = CheckMode(dec, dec->uvmode_);
VP8PredChroma8[pred_func](u_dst);
VP8PredChroma8[pred_func](v_dst);
if (dec->non_zero_ & 0x0f0000) { // chroma-U
const int16_t* const u_coeffs = dec->coeffs_ + 16 * 16;
if (dec->non_zero_ac_ & 0x0f0000) {
VP8TransformUV(u_coeffs, u_dst);
} else {
VP8TransformDCUV(u_coeffs, u_dst);
}
}
if (dec->non_zero_ & 0xf00000) { // chroma-V
const int16_t* const v_coeffs = dec->coeffs_ + 20 * 16;
if (dec->non_zero_ac_ & 0xf00000) {
VP8TransformUV(v_coeffs, v_dst);
} else {
VP8TransformDCUV(v_coeffs, v_dst);
}
}
if (dec->non_zero_ & 0x0f0000) { // chroma-U
const int16_t* const u_coeffs = dec->coeffs_ + 16 * 16;
if (dec->non_zero_ac_ & 0x0f0000) {
VP8TransformUV(u_coeffs, u_dst);
} else {
VP8TransformDCUV(u_coeffs, u_dst);
// stash away top samples for next block
if (dec->mb_y_ < dec->mb_h_ - 1) {
memcpy(top_y, y_dst + 15 * BPS, 16);
memcpy(top_u, u_dst + 7 * BPS, 8);
memcpy(top_v, v_dst + 7 * BPS, 8);
}
}
}
if (dec->non_zero_ & 0xf00000) { // chroma-V
const int16_t* const v_coeffs = dec->coeffs_ + 20 * 16;
if (dec->non_zero_ac_ & 0xf00000) {
VP8TransformUV(v_coeffs, v_dst);
} else {
VP8TransformDCUV(v_coeffs, v_dst);
}
}
// stash away top samples for next block
if (dec->mb_y_ < dec->mb_h_ - 1) {
memcpy(top_y, y_dst + 15 * BPS, 16);
memcpy(top_u, u_dst + 7 * BPS, 8);
memcpy(top_v, v_dst + 7 * BPS, 8);
}
}
//-----------------------------------------------------------------------------

24
src/quant.c
View File

@ -71,7 +71,9 @@ void VP8ParseQuant(VP8Decoder* const dec) {
const int dquv_ac = VP8Get(br) ? VP8GetSignedValue(br, 4) : 0;
const VP8SegmentHeader* const hdr = &dec->segment_hdr_;
for (int i = 0; i < NUM_MB_SEGMENTS; ++i) {
int i;
for (i = 0; i < NUM_MB_SEGMENTS; ++i) {
int q;
if (hdr->use_segment_) {
q = hdr->quantizer_[i];
@ -86,17 +88,19 @@ void VP8ParseQuant(VP8Decoder* const dec) {
q = base_q0;
}
}
VP8QuantMatrix* const m = &dec->dqm_[i];
m->y1_mat_[0] = kDcTable[clip(q + dqy1_dc, 127)];
m->y1_mat_[1] = kAcTable[clip(q + 0, 127)];
{
VP8QuantMatrix* const m = &dec->dqm_[i];
m->y1_mat_[0] = kDcTable[clip(q + dqy1_dc, 127)];
m->y1_mat_[1] = kAcTable[clip(q + 0, 127)];
m->y2_mat_[0] = kDcTable[clip(q + dqy2_dc, 127)] * 2;
// TODO(skal): make it another table?
m->y2_mat_[1] = kAcTable[clip(q + dqy2_ac, 127)] * 155 / 100;
if (m->y2_mat_[1] < 8) m->y2_mat_[1] = 8;
m->y2_mat_[0] = kDcTable[clip(q + dqy2_dc, 127)] * 2;
// TODO(skal): make it another table?
m->y2_mat_[1] = kAcTable[clip(q + dqy2_ac, 127)] * 155 / 100;
if (m->y2_mat_[1] < 8) m->y2_mat_[1] = 8;
m->uv_mat_[0] = kDcTable[clip(q + dquv_ac, 117)];
m->uv_mat_[1] = kAcTable[clip(q + dquv_dc, 127)];
m->uv_mat_[0] = kDcTable[clip(q + dquv_ac, 117)];
m->uv_mat_[1] = kAcTable[clip(q + dquv_dc, 127)];
}
}
}

15
src/tree.c
View File

@ -343,9 +343,11 @@ void VP8ParseIntraMode(VP8BitReader* const br, VP8Decoder* const dec) {
memset(left, ymode, 4 * sizeof(left[0]));
} else {
uint8_t* modes = dec->imodes_;
for (int y = 0; y < 4; ++y) {
int y;
for (y = 0; y < 4; ++y) {
int ymode = left[y];
for (int x = 0; x < 4; ++x) {
int x;
for (x = 0; x < 4; ++x) {
const uint8_t* const prob = kBModesProba[top[x]][ymode];
#ifdef USE_GENERIC_TREE
// Generic tree-parsing
@ -531,10 +533,11 @@ static const uint8_t MVUpdateProba[2][NUM_MV_PROBAS] = {
// Paragraph 9.9
void VP8ParseProba(VP8BitReader* const br, VP8Decoder* const dec) {
VP8Proba* const proba = &dec->proba_;
for (int t = 0; t < NUM_TYPES; ++t) {
for (int b = 0; b < NUM_BANDS; ++b) {
for (int c = 0; c < NUM_CTX; ++c) {
for (int p = 0; p < NUM_PROBAS; ++p) {
int t, b, c, p;
for (t = 0; t < NUM_TYPES; ++t) {
for (b = 0; b < NUM_BANDS; ++b) {
for (c = 0; c < NUM_CTX; ++c) {
for (p = 0; p < NUM_PROBAS; ++p) {
if (VP8GetBit(br, CoeffsUpdateProba[t][b][c][p])) {
proba->coeffs_[t][b][c][p] = VP8GetValue(br, 8);
}

108
src/vp8.c
View File

@ -80,18 +80,19 @@ static int ParseSegmentHeader(VP8BitReader* br,
hdr->use_segment_ = VP8Get(br);
if (hdr->use_segment_) {
hdr->update_map_ = VP8Get(br);
const int update_data = VP8Get(br);
if (update_data) {
if (VP8Get(br)) { // update data
int s;
hdr->absolute_delta_ = VP8Get(br);
for (int s = 0; s < NUM_MB_SEGMENTS; ++s) {
for (s = 0; s < NUM_MB_SEGMENTS; ++s) {
hdr->quantizer_[s] = VP8Get(br) ? VP8GetSignedValue(br, 7) : 0;
}
for (int s = 0; s < NUM_MB_SEGMENTS; ++s) {
for (s = 0; s < NUM_MB_SEGMENTS; ++s) {
hdr->filter_strength_[s] = VP8Get(br) ? VP8GetSignedValue(br, 6) : 0;
}
}
if (hdr->update_map_) {
for (int s = 0; s < MB_FEATURE_TREE_PROBS; ++s) {
int s;
for (s = 0; s < MB_FEATURE_TREE_PROBS; ++s) {
proba->segments_[s] = VP8Get(br) ? VP8GetValue(br, 8) : 255u;
}
}
@ -105,14 +106,19 @@ static int ParseSegmentHeader(VP8BitReader* br,
static int ParsePartitions(VP8Decoder* const dec,
const uint8_t* buf, uint32_t size) {
VP8BitReader* const br = &dec->br_;
dec->num_parts_ = 1 << VP8GetValue(br, 2);
const uint8_t* sz = buf;
const int last_part = dec->num_parts_ - 1;
uint32_t offset = last_part * 3;
int last_part;
uint32_t offset;
int p;
dec->num_parts_ = 1 << VP8GetValue(br, 2);
last_part = dec->num_parts_ - 1;
offset = last_part * 3;
if (size <= offset) {
return 0;
}
for (int p = 0; p < last_part; ++p) {
for (p = 0; p < last_part; ++p) {
const uint32_t psize = sz[0] | (sz[1] << 8) | (sz[2] << 16);
if (offset + psize > size) {
return 0;
@ -135,12 +141,13 @@ static int ParseFilterHeader(VP8BitReader* br, VP8Decoder* const dec) {
hdr->use_lf_delta_ = VP8Get(br);
if (hdr->use_lf_delta_) {
if (VP8Get(br)) { // update lf-delta?
for (int i = 0; i < NUM_REF_LF_DELTAS; ++i) {
int i;
for (i = 0; i < NUM_REF_LF_DELTAS; ++i) {
if (VP8Get(br)) {
hdr->ref_lf_delta_[i] = VP8GetSignedValue(br, 6);
}
}
for (int i = 0; i < NUM_MODE_LF_DELTAS; ++i) {
for (i = 0; i < NUM_MODE_LF_DELTAS; ++i) {
if (VP8Get(br)) {
hdr->mode_lf_delta_[i] = VP8GetSignedValue(br, 6);
}
@ -150,7 +157,8 @@ static int ParseFilterHeader(VP8BitReader* br, VP8Decoder* const dec) {
dec->filter_type_ = (hdr->level_ == 0) ? 0 : hdr->simple_ ? 1 : 2;
if (dec->filter_type_ > 0) { // precompute filter levels per segment
if (dec->segment_hdr_.use_segment_) {
for (int s = 0; s < NUM_MB_SEGMENTS; ++s) {
int s;
for (s = 0; s < NUM_MB_SEGMENTS; ++s) {
int strength = dec->segment_hdr_.filter_strength_[s];
if (!dec->segment_hdr_.absolute_delta_) {
strength += hdr->level_;
@ -170,6 +178,12 @@ static inline uint32_t get_le32(const uint8_t* const data) {
// Topmost call
int VP8GetHeaders(VP8Decoder* const dec, VP8Io* const io) {
uint8_t* buf;
uint32_t buf_size;
VP8FrameHeader* frm_hdr;
VP8PictureHeader* pic_hdr;
VP8BitReader* br;
if (dec == NULL) {
return 0;
}
@ -177,25 +191,28 @@ int VP8GetHeaders(VP8Decoder* const dec, VP8Io* const io) {
if (io == NULL || io->data == NULL || io->data_size <= 4) {
return VP8SetError(dec, 2, "null VP8Io passed to VP8GetHeaders()");
}
const uint8_t* buf = io->data;
uint32_t buf_size = io->data_size;
buf = (uint8_t *)io->data;
buf_size = io->data_size;
if (buf_size < 4) {
return VP8SetError(dec, 2, "Not enough data to parse frame header");
}
// Skip over valid RIFF headers
if (!memcmp(buf, "RIFF", 4)) {
uint32_t riff_size;
uint32_t chunk_size;
if (buf_size < 20 + 4) {
return VP8SetError(dec, 2, "RIFF: Truncated header.");
}
if (memcmp(buf + 8, "WEBP", 4)) { // wrong image file signature
return VP8SetError(dec, 2, "RIFF: WEBP signature not found.");
}
const uint32_t riff_size = get_le32(buf + 4);
riff_size = get_le32(buf + 4);
if (memcmp(buf + 12, "VP8 ", 4)) {
return VP8SetError(dec, 2, "RIFF: Invalid compression format.");
}
const uint32_t chunk_size = get_le32(buf + 16);
chunk_size = get_le32(buf + 16);
if ((chunk_size > riff_size + 8) || (chunk_size & 1)) {
return VP8SetError(dec, 2, "RIFF: Inconsistent size information.");
}
@ -204,16 +221,18 @@ int VP8GetHeaders(VP8Decoder* const dec, VP8Io* const io) {
}
// Paragraph 9.1
VP8FrameHeader* const frm_hdr = &dec->frm_hdr_;
const uint32_t bits = buf[0] | (buf[1] << 8) | (buf[2] << 16);
frm_hdr->key_frame_ = !(bits & 1);
frm_hdr->profile_ = (bits >> 1) & 7;
frm_hdr->show_ = (bits >> 4) & 1;
frm_hdr->partition_length_ = (bits >> 5);
buf += 3;
buf_size -= 3;
{
frm_hdr = &dec->frm_hdr_;
const uint32_t bits = buf[0] | (buf[1] << 8) | (buf[2] << 16);
frm_hdr->key_frame_ = !(bits & 1);
frm_hdr->profile_ = (bits >> 1) & 7;
frm_hdr->show_ = (bits >> 4) & 1;
frm_hdr->partition_length_ = (bits >> 5);
buf += 3;
buf_size -= 3;
}
VP8PictureHeader* const pic_hdr = &dec->pic_hdr_;
pic_hdr = &dec->pic_hdr_;
if (frm_hdr->key_frame_) {
// Paragraph 9.2
if (buf_size < 7) {
@ -239,7 +258,7 @@ int VP8GetHeaders(VP8Decoder* const dec, VP8Io* const io) {
dec->segment_ = 0; // default for intra
}
VP8BitReader* const br = &dec->br_;
br = &dec->br_;
VP8Init(br, buf, buf_size);
buf += frm_hdr->partition_length_;
buf_size -= frm_hdr->partition_length_;
@ -333,7 +352,7 @@ static int GetCoeffs(VP8BitReader* const br,
if (!VP8GetBit(br, p[1])) {
p = prob[kBands[n]][0];
} else { // non zero coeff
int v;
int v, j;
if (!VP8GetBit(br, p[2])) {
p = prob[kBands[n]][1];
v = 1;
@ -352,11 +371,12 @@ static int GetCoeffs(VP8BitReader* const br,
v = 7 + 2 * VP8GetBit(br, 165) + VP8GetBit(br, 145);
}
} else {
uint8_t* tab;
const int bit1 = VP8GetBit(br, p[8]);
const int bit0 = VP8GetBit(br, p[9 + bit1]);
const int cat = 2 * bit1 + bit0;
v = 0;
for (const uint8_t* tab = kCat3456[cat]; *tab; ++tab) {
for (tab = (uint8_t*)kCat3456[cat]; *tab; ++tab) {
v += v + VP8GetBit(br, *tab);
}
v += 3 + (8 << cat);
@ -364,7 +384,7 @@ static int GetCoeffs(VP8BitReader* const br,
}
p = prob[kBands[n]][2];
}
const int j = kZigzag[n - 1];
j = kZigzag[n - 1];
out[j] = VP8GetSigned(br, v) * dq[j > 0];
if (n == 16) break;
if (!VP8GetBit(br, p[0])) { // EOB
@ -394,6 +414,12 @@ static int ParseResiduals(VP8Decoder* const dec,
const VP8QuantMatrix* q = &dec->dqm_[dec->segment_];
int16_t* dst = dec->coeffs_;
VP8MB* const left_mb = dec->mb_info_ - 1;
uint8_t nz_ac[4], nz_dc[4];
uint32_t non_zero_ac = 0;
uint32_t non_zero_dc = 0;
uint8_t tnz[4], lnz[4];
int x, y, ch;
memset(dst, 0, 384 * sizeof(*dst));
if (!dec->is_i4x4_) { // parse DC
int16_t dc[16] = { 0 };
@ -409,16 +435,12 @@ static int ParseResiduals(VP8Decoder* const dec,
ac_prob = (Proba_t)dec->proba_.coeffs_[3];
}
uint8_t nz_ac[4], nz_dc[4];
uint32_t non_zero_ac = 0;
uint32_t non_zero_dc = 0;
uint8_t tnz[4], lnz[4];
memcpy(tnz, kUnpackTab[mb->nz_ & 0xf], sizeof(tnz));
memcpy(lnz, kUnpackTab[left_mb->nz_ & 0xf], sizeof(lnz));
for (int y = 0; y < 4; ++y) {
for (y = 0; y < 4; ++y) {
int l = lnz[y];
for (int x = 0; x < 4; ++x) {
for (x = 0; x < 4; ++x) {
const int ctx = l + tnz[x];
const int last = GetCoeffs(token_br, ac_prob, ctx,
q->y1_mat_, first, dst);
@ -436,10 +458,10 @@ static int ParseResiduals(VP8Decoder* const dec,
memcpy(tnz, kUnpackTab[mb->nz_ >> 4], sizeof(tnz));
memcpy(lnz, kUnpackTab[left_mb->nz_ >> 4], sizeof(lnz));
for (int ch = 0; ch < 4; ch += 2) {
for (int y = 0; y < 2; ++y) {
for (ch = 0; ch < 4; ch += 2) {
for (y = 0; y < 2; ++y) {
int l = lnz[ch + y];
for (int x = 0; x < 2; ++x) {
for (x = 0; x < 2; ++x) {
const int ctx = l + tnz[ch + x];
const int last =
GetCoeffs(token_br, (Proba_t)dec->proba_.coeffs_[2],
@ -485,13 +507,17 @@ static void SendBlock(VP8Decoder* const dec, VP8Io* io) {
static int ParseFrame(VP8Decoder* const dec, VP8Io* io) {
int ok = 1;
VP8BitReader* const br = &dec->br_;
VP8BitReader* token_br;
for (dec->mb_y_ = 0; dec->mb_y_ < dec->mb_h_; ++dec->mb_y_) {
memset(dec->intra_l_, B_DC_PRED, sizeof(dec->intra_l_));
VP8MB* const left = dec->mb_info_ - 1;
memset(dec->intra_l_, B_DC_PRED, sizeof(dec->intra_l_));
left->nz_ = 0;
left->dc_nz_ = 0;
VP8BitReader* token_br = &dec->parts_[dec->mb_y_ & (dec->num_parts_ - 1)];
token_br = &dec->parts_[dec->mb_y_ & (dec->num_parts_ - 1)];
for (dec->mb_x_ = 0; dec->mb_x_ < dec->mb_w_; dec->mb_x_++) {
VP8MB* const info = dec->mb_info_ + dec->mb_x_;

153
src/webp.c
View File

@ -35,25 +35,28 @@ static inline uint32_t get_le32(const uint8_t* const data) {
}
// If a RIFF container is detected, validate it and skip over it.
static int CheckRIFFHeader(const uint8_t** data_ptr, uint32_t *data_size_ptr) {
static uint32_t CheckRIFFHeader(const uint8_t** data_ptr,
uint32_t *data_size_ptr) {
uint32_t chunk_size = 0xffffffffu;
if (*data_size_ptr >= 10 + 20 && !memcmp(*data_ptr, "RIFF", 4)) {
if (memcmp(*data_ptr + 8, "WEBP", 4)) {
return 0; // wrong image file signature
} else {
const uint32_t riff_size = get_le32(*data_ptr + 4);
if (memcmp(*data_ptr + 12, "VP8 ", 4)) {
return 0; // invalid compression format
}
chunk_size = get_le32(*data_ptr + 16);
if ((chunk_size > riff_size + 8) || (chunk_size & 1)) {
return 0; // inconsistent size information.
}
// We have a IFF container. Skip it.
*data_ptr += 20;
*data_size_ptr -= 20;
}
const uint32_t riff_size = get_le32(*data_ptr + 4);
if (memcmp(*data_ptr + 12, "VP8 ", 4)) {
return 0; // invalid compression format
}
chunk_size = get_le32(*data_ptr + 16);
if ((chunk_size > riff_size + 8) || (chunk_size & 1)) {
return 0; // inconsistent size information.
}
// We have a IFF container. Skip it.
*data_ptr += 20;
*data_size_ptr -= 20;
return chunk_size;
}
return chunk_size;
return *data_size_ptr;
}
//-----------------------------------------------------------------------------
@ -75,24 +78,32 @@ static void CustomPut(const VP8Io* io) {
Params *p = (Params*)io->opaque;
const int mb_w = io->mb_w;
const int mb_h = io->mb_h;
int j;
if (p->mode == MODE_YUV) {
uint8_t* const y_dst = p->output + io->mb_x + io->mb_y * p->stride;
for (int j = 0; j < mb_h; ++j) {
uint8_t* u_dst;
uint8_t* v_dst;
int uv_w;
for (j = 0; j < mb_h; ++j) {
memcpy(y_dst + j * p->stride, io->y + j * io->y_stride, mb_w);
}
uint8_t* const u_dst = p->u + (io->mb_x / 2) + (io->mb_y / 2) * p->u_stride;
uint8_t* const v_dst = p->v + (io->mb_x / 2) + (io->mb_y / 2) * p->v_stride;
const int uv_w = (mb_w + 1) / 2;
for (int j = 0; j < (mb_h + 1) / 2; ++j) {
u_dst = p->u + (io->mb_x / 2) + (io->mb_y / 2) * p->u_stride;
v_dst = p->v + (io->mb_x / 2) + (io->mb_y / 2) * p->v_stride;
uv_w = (mb_w + 1) / 2;
for (j = 0; j < (mb_h + 1) / 2; ++j) {
memcpy(u_dst + j * p->u_stride, io->u + j * io->uv_stride, uv_w);
memcpy(v_dst + j * p->v_stride, io->v + j * io->uv_stride, uv_w);
}
} else {
const int psize = (p->mode == MODE_RGB || p->mode == MODE_BGR) ? 3 : 4;
uint8_t* dst = p->output + psize * io->mb_x + io->mb_y * p->stride;
for (int j = 0; j < mb_h; ++j) {
int i;
for (j = 0; j < mb_h; ++j) {
const uint8_t* y_src = io->y + j * io->y_stride;
for (int i = 0; i < mb_w; ++i) {
for (i = 0; i < mb_w; ++i) {
const int y = y_src[i];
const int u = io->u[(j / 2) * io->uv_stride + (i / 2)];
const int v = io->v[(j / 2) * io->uv_stride + (i / 2)];
@ -120,11 +131,13 @@ static uint8_t* DecodeInto(CSP_MODE mode,
Params* params, int output_size,
int output_u_size, int output_v_size) {
VP8Decoder* dec = VP8New();
VP8Io io;
int ok = 1;
if (dec == NULL) {
return NULL;
}
VP8Io io;
VP8InitIo(&io);
io.data = data;
io.data_size = data_size;
@ -138,17 +151,17 @@ static uint8_t* DecodeInto(CSP_MODE mode,
return NULL;
}
// check output buffers
int ok = 1;
ok &= (params->stride * io.height <= output_size);
if (mode == MODE_RGB || mode == MODE_BGR) {
ok &= (params->stride >= io.width * 3);
} else if (mode == MODE_RGBA || mode == MODE_BGRA) {
ok &= (params->stride >= io.width * 4);
} else {
ok &= (params->stride >= io.width);
// some extra checks for U/V
const int u_size = params->u_stride * ((io.height + 1) / 2);
const int v_size = params->v_stride * ((io.height + 1) / 2);
ok &= (params->stride >= io.width);
ok &= (params->u_stride >= (io.width + 1) / 2) &&
(params->v_stride >= (io.width + 1) / 2);
ok &= (u_size <= output_u_size && v_size <= output_v_size);
@ -170,10 +183,12 @@ static uint8_t* DecodeInto(CSP_MODE mode,
uint8_t* WebPDecodeRGBInto(const uint8_t* data, uint32_t data_size,
uint8_t* output, int output_size,
int output_stride) {
Params params;
if (output == NULL) {
return NULL;
}
Params params;
params.output = output;
params.stride = output_stride;
return DecodeInto(MODE_RGB, data, data_size, &params, output_size, 0, 0);
@ -182,10 +197,12 @@ uint8_t* WebPDecodeRGBInto(const uint8_t* data, uint32_t data_size,
uint8_t* WebPDecodeRGBAInto(const uint8_t* data, uint32_t data_size,
uint8_t* output, int output_size,
int output_stride) {
Params params;
if (output == NULL) {
return NULL;
}
Params params;
params.output = output;
params.stride = output_stride;
return DecodeInto(MODE_RGBA, data, data_size, &params, output_size, 0, 0);
@ -194,10 +211,12 @@ uint8_t* WebPDecodeRGBAInto(const uint8_t* data, uint32_t data_size,
uint8_t* WebPDecodeBGRInto(const uint8_t* data, uint32_t data_size,
uint8_t* output, int output_size,
int output_stride) {
Params params;
if (output == NULL) {
return NULL;
}
Params params;
params.output = output;
params.stride = output_stride;
return DecodeInto(MODE_BGR, data, data_size, &params, output_size, 0, 0);
@ -206,10 +225,12 @@ uint8_t* WebPDecodeBGRInto(const uint8_t* data, uint32_t data_size,
uint8_t* WebPDecodeBGRAInto(const uint8_t* data, uint32_t data_size,
uint8_t* output, int output_size,
int output_stride) {
Params params;
if (output == NULL) {
return NULL;
}
Params params;
params.output = output;
params.stride = output_stride;
return DecodeInto(MODE_BGRA, data, data_size, &params, output_size, 0, 0);
@ -219,10 +240,12 @@ uint8_t* WebPDecodeYUVInto(const uint8_t* data, uint32_t data_size,
uint8_t* luma, int luma_size, int luma_stride,
uint8_t* u, int u_size, int u_stride,
uint8_t* v, int v_size, int v_stride) {
Params params;
if (luma == NULL) {
return NULL;
}
Params params;
params.output = luma;
params.stride = luma_stride;
params.u = u;
@ -237,7 +260,13 @@ uint8_t* WebPDecodeYUVInto(const uint8_t* data, uint32_t data_size,
static uint8_t* Decode(CSP_MODE mode, const uint8_t* data, uint32_t data_size,
int* width, int* height, Params* params_out) {
int w, h;
int w, h, stride;
int uv_size = 0;
int uv_stride = 0;
int size;
uint8_t* output;
Params params = { 0 };
if (!WebPGetInfo(data, data_size, &w, &h)) {
return NULL;
}
@ -245,21 +274,21 @@ static uint8_t* Decode(CSP_MODE mode, const uint8_t* data, uint32_t data_size,
if (height) *height = h;
// initialize output buffer, now that dimensions are known.
int stride = (mode == MODE_RGB || mode == MODE_BGR) ? 3 * w
stride = (mode == MODE_RGB || mode == MODE_BGR) ? 3 * w
: (mode == MODE_RGBA || mode == MODE_BGRA) ? 4 * w
: w;
const int size = stride * h;
int uv_size = 0;
int uv_stride = 0;
size = stride * h;
if (mode == MODE_YUV) {
uv_stride = (w + 1) / 2;
uv_size = uv_stride * ((h + 1) / 2);
}
uint8_t* const output = (uint8_t*)malloc(size + 2 * uv_size);
output = (uint8_t*)malloc(size + 2 * uv_size);
if (!output) {
return NULL;
}
Params params = { 0 };
params.output = output;
params.stride = stride;
if (mode == MODE_YUV) {
@ -325,35 +354,35 @@ int WebPGetInfo(const uint8_t* data, uint32_t data_size,
// check signature
if (data[3] != 0x9d || data[4] != 0x01 || data[5] != 0x2a) {
return 0; // Wrong signature.
}
const uint32_t bits = data[0] | (data[1] << 8) | (data[2] << 16);
const int key_frame = !(bits & 1);
if (!key_frame) { // Not a keyframe.
return 0;
}
const int profile = (bits >> 1) & 7;
const int show_frame = (bits >> 4) & 1;
const uint32_t partition_length = (bits >> 5);
if (profile > 3) {
return 0; // unknown profile
}
if (!show_frame) {
return 0; // first frame is invisible!
}
if (partition_length >= chunk_size) {
return 0; // inconsistent size information.
}
} else {
const uint32_t bits = data[0] | (data[1] << 8) | (data[2] << 16);
const int key_frame = !(bits & 1);
const int w = ((data[7] << 8) | data[6]) & 0x3fff;
const int h = ((data[9] << 8) | data[8]) & 0x3fff;
const int w = ((data[7] << 8) | data[6]) & 0x3fff;
const int h = ((data[9] << 8) | data[8]) & 0x3fff;
if (width) {
*width = w;
}
if (height) {
*height = h;
}
if (!key_frame) { // Not a keyframe.
return 0;
}
return 1;
if (((bits >> 1) & 7) > 3) {
return 0; // unknown profile
}
if (!((bits >> 4) & 1)) {
return 0; // first frame is invisible!
}
if (((bits >> 5)) >= chunk_size) { // partition_length
return 0; // inconsistent size information.
}
if (width) {
*width = w;
}
if (height) {
*height = h;
}
return 1;
}
}
#if defined(__cplusplus) || defined(c_plusplus)

9
src/yuv.c
View File

@ -24,18 +24,19 @@ uint8_t VP8kClip[YUV_RANGE_MAX - YUV_RANGE_MIN];
static int done = 0;
void VP8YUVInit() {
int i;
if (done) {
return;
}
for (int i = 0; i < 256; ++i) {
for (i = 0; i < 256; ++i) {
VP8kVToR[i] = (89858 * (i - 128) + YUV_HALF) >> YUV_FIX;
VP8kUToG[i] = -22014 * (i - 128) + YUV_HALF;
VP8kVToG[i] = -45773 * (i - 128);
VP8kUToB[i] = (113618 * (i - 128) + YUV_HALF) >> YUV_FIX;
}
for (int i = YUV_RANGE_MIN; i < YUV_RANGE_MAX; ++i) {
const int j = ((i - 16) * 76283 + YUV_HALF) >> YUV_FIX;
VP8kClip[i - YUV_RANGE_MIN] = (j < 0) ? 0 : (j > 255) ? 255 : j;
for (i = YUV_RANGE_MIN; i < YUV_RANGE_MAX; ++i) {
const int k = ((i - 16) * 76283 + YUV_HALF) >> YUV_FIX;
VP8kClip[i - YUV_RANGE_MIN] = (k < 0) ? 0 : (k > 255) ? 255 : k;
}
done = 1;
}