From 25074f9ff39c1b4c44eded356b0285291585ac31 Mon Sep 17 00:00:00 2001 From: David McPaul Date: Mon, 15 Sep 2008 14:07:34 +0000 Subject: [PATCH] Update avcodec to 20080825 git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@27554 a95241bf-73f2-0310-859d-f6bbb57e9c96 --- .../media/plugins/avcodec/libavcodec/zmbv.c | 667 ++++++++++++++++++ .../plugins/avcodec/libavcodec/zmbvenc.c | 334 +++++++++ 2 files changed, 1001 insertions(+) create mode 100644 src/add-ons/media/plugins/avcodec/libavcodec/zmbv.c create mode 100644 src/add-ons/media/plugins/avcodec/libavcodec/zmbvenc.c diff --git a/src/add-ons/media/plugins/avcodec/libavcodec/zmbv.c b/src/add-ons/media/plugins/avcodec/libavcodec/zmbv.c new file mode 100644 index 0000000000..b9751a0faa --- /dev/null +++ b/src/add-ons/media/plugins/avcodec/libavcodec/zmbv.c @@ -0,0 +1,667 @@ +/* + * Zip Motion Blocks Video (ZMBV) decoder + * Copyright (c) 2006 Konstantin Shishkov + * + * This file is part of FFmpeg. + * + * FFmpeg is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * FFmpeg is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with FFmpeg; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +/** + * @file zmbv.c + * Zip Motion Blocks Video decoder + */ + +#include +#include + +#include "avcodec.h" + +#include + +#define ZMBV_KEYFRAME 1 +#define ZMBV_DELTAPAL 2 + +enum ZmbvFormat { + ZMBV_FMT_NONE = 0, + ZMBV_FMT_1BPP = 1, + ZMBV_FMT_2BPP = 2, + ZMBV_FMT_4BPP = 3, + ZMBV_FMT_8BPP = 4, + ZMBV_FMT_15BPP = 5, + ZMBV_FMT_16BPP = 6, + ZMBV_FMT_24BPP = 7, + ZMBV_FMT_32BPP = 8 +}; + +/* + * Decoder context + */ +typedef struct ZmbvContext { + AVCodecContext *avctx; + AVFrame pic; + + int bpp; + unsigned int decomp_size; + uint8_t* decomp_buf; + uint8_t pal[768]; + uint8_t *prev, *cur; + int width, height; + int fmt; + int comp; + int flags; + int bw, bh, bx, by; + int decomp_len; + z_stream zstream; + int (*decode_intra)(struct ZmbvContext *c); + int (*decode_xor)(struct ZmbvContext *c); +} ZmbvContext; + +/** + * Decode XOR'ed frame - 8bpp version + */ + +static int zmbv_decode_xor_8(ZmbvContext *c) +{ + uint8_t *src = c->decomp_buf; + uint8_t *output, *prev; + int8_t *mvec; + int x, y; + int d, dx, dy, bw2, bh2; + int block; + int i, j; + int mx, my; + + output = c->cur; + prev = c->prev; + + if(c->flags & ZMBV_DELTAPAL){ + for(i = 0; i < 768; i++) + c->pal[i] ^= *src++; + } + + mvec = (int8_t*)src; + src += ((c->bx * c->by * 2 + 3) & ~3); + + block = 0; + for(y = 0; y < c->height; y += c->bh) { + bh2 = ((c->height - y) > c->bh) ? c->bh : (c->height - y); + for(x = 0; x < c->width; x += c->bw) { + uint8_t *out, *tprev; + + d = mvec[block] & 1; + dx = mvec[block] >> 1; + dy = mvec[block + 1] >> 1; + block += 2; + + bw2 = ((c->width - x) > c->bw) ? c->bw : (c->width - x); + + /* copy block - motion vectors out of bounds are used to zero blocks */ + out = output + x; + tprev = prev + x + dx + dy * c->width; + mx = x + dx; + my = y + dy; + for(j = 0; j < bh2; j++){ + if((my + j < 0) || (my + j >= c->height)) { + memset(out, 0, bw2); + } else { + for(i = 0; i < bw2; i++){ + if((mx + i < 0) || (mx + i >= c->width)) + out[i] = 0; + else + out[i] = tprev[i]; + } + } + out += c->width; + tprev += c->width; + } + + if(d) { /* apply XOR'ed difference */ + out = output + x; + for(j = 0; j < bh2; j++){ + for(i = 0; i < bw2; i++) + out[i] ^= *src++; + out += c->width; + } + } + } + output += c->width * c->bh; + prev += c->width * c->bh; + } + if(src - c->decomp_buf != c->decomp_len) + av_log(c->avctx, AV_LOG_ERROR, "Used %ti of %i bytes\n", src-c->decomp_buf, c->decomp_len); + return 0; +} + +/** + * Decode XOR'ed frame - 15bpp and 16bpp version + */ + +static int zmbv_decode_xor_16(ZmbvContext *c) +{ + uint8_t *src = c->decomp_buf; + uint16_t *output, *prev; + int8_t *mvec; + int x, y; + int d, dx, dy, bw2, bh2; + int block; + int i, j; + int mx, my; + + output = (uint16_t*)c->cur; + prev = (uint16_t*)c->prev; + + mvec = (int8_t*)src; + src += ((c->bx * c->by * 2 + 3) & ~3); + + block = 0; + for(y = 0; y < c->height; y += c->bh) { + bh2 = ((c->height - y) > c->bh) ? c->bh : (c->height - y); + for(x = 0; x < c->width; x += c->bw) { + uint16_t *out, *tprev; + + d = mvec[block] & 1; + dx = mvec[block] >> 1; + dy = mvec[block + 1] >> 1; + block += 2; + + bw2 = ((c->width - x) > c->bw) ? c->bw : (c->width - x); + + /* copy block - motion vectors out of bounds are used to zero blocks */ + out = output + x; + tprev = prev + x + dx + dy * c->width; + mx = x + dx; + my = y + dy; + for(j = 0; j < bh2; j++){ + if((my + j < 0) || (my + j >= c->height)) { + memset(out, 0, bw2 * 2); + } else { + for(i = 0; i < bw2; i++){ + if((mx + i < 0) || (mx + i >= c->width)) + out[i] = 0; + else + out[i] = tprev[i]; + } + } + out += c->width; + tprev += c->width; + } + + if(d) { /* apply XOR'ed difference */ + out = output + x; + for(j = 0; j < bh2; j++){ + for(i = 0; i < bw2; i++) { + out[i] ^= *((uint16_t*)src); + src += 2; + } + out += c->width; + } + } + } + output += c->width * c->bh; + prev += c->width * c->bh; + } + if(src - c->decomp_buf != c->decomp_len) + av_log(c->avctx, AV_LOG_ERROR, "Used %ti of %i bytes\n", src-c->decomp_buf, c->decomp_len); + return 0; +} + +#ifdef ZMBV_ENABLE_24BPP +/** + * Decode XOR'ed frame - 24bpp version + */ + +static int zmbv_decode_xor_24(ZmbvContext *c) +{ + uint8_t *src = c->decomp_buf; + uint8_t *output, *prev; + int8_t *mvec; + int x, y; + int d, dx, dy, bw2, bh2; + int block; + int i, j; + int mx, my; + int stride; + + output = c->cur; + prev = c->prev; + + stride = c->width * 3; + mvec = (int8_t*)src; + src += ((c->bx * c->by * 2 + 3) & ~3); + + block = 0; + for(y = 0; y < c->height; y += c->bh) { + bh2 = ((c->height - y) > c->bh) ? c->bh : (c->height - y); + for(x = 0; x < c->width; x += c->bw) { + uint8_t *out, *tprev; + + d = mvec[block] & 1; + dx = mvec[block] >> 1; + dy = mvec[block + 1] >> 1; + block += 2; + + bw2 = ((c->width - x) > c->bw) ? c->bw : (c->width - x); + + /* copy block - motion vectors out of bounds are used to zero blocks */ + out = output + x * 3; + tprev = prev + (x + dx) * 3 + dy * stride; + mx = x + dx; + my = y + dy; + for(j = 0; j < bh2; j++){ + if((my + j < 0) || (my + j >= c->height)) { + memset(out, 0, bw2 * 3); + } else { + for(i = 0; i < bw2; i++){ + if((mx + i < 0) || (mx + i >= c->width)) { + out[i * 3 + 0] = 0; + out[i * 3 + 1] = 0; + out[i * 3 + 2] = 0; + } else { + out[i * 3 + 0] = tprev[i * 3 + 0]; + out[i * 3 + 1] = tprev[i * 3 + 1]; + out[i * 3 + 2] = tprev[i * 3 + 2]; + } + } + } + out += stride; + tprev += stride; + } + + if(d) { /* apply XOR'ed difference */ + out = output + x * 3; + for(j = 0; j < bh2; j++){ + for(i = 0; i < bw2; i++) { + out[i * 3 + 0] ^= *src++; + out[i * 3 + 1] ^= *src++; + out[i * 3 + 2] ^= *src++; + } + out += stride; + } + } + } + output += stride * c->bh; + prev += stride * c->bh; + } + if(src - c->decomp_buf != c->decomp_len) + av_log(c->avctx, AV_LOG_ERROR, "Used %i of %i bytes\n", src-c->decomp_buf, c->decomp_len); + return 0; +} +#endif //ZMBV_ENABLE_24BPP + +/** + * Decode XOR'ed frame - 32bpp version + */ + +static int zmbv_decode_xor_32(ZmbvContext *c) +{ + uint8_t *src = c->decomp_buf; + uint32_t *output, *prev; + int8_t *mvec; + int x, y; + int d, dx, dy, bw2, bh2; + int block; + int i, j; + int mx, my; + + output = (uint32_t*)c->cur; + prev = (uint32_t*)c->prev; + + mvec = (int8_t*)src; + src += ((c->bx * c->by * 2 + 3) & ~3); + + block = 0; + for(y = 0; y < c->height; y += c->bh) { + bh2 = ((c->height - y) > c->bh) ? c->bh : (c->height - y); + for(x = 0; x < c->width; x += c->bw) { + uint32_t *out, *tprev; + + d = mvec[block] & 1; + dx = mvec[block] >> 1; + dy = mvec[block + 1] >> 1; + block += 2; + + bw2 = ((c->width - x) > c->bw) ? c->bw : (c->width - x); + + /* copy block - motion vectors out of bounds are used to zero blocks */ + out = output + x; + tprev = prev + x + dx + dy * c->width; + mx = x + dx; + my = y + dy; + for(j = 0; j < bh2; j++){ + if((my + j < 0) || (my + j >= c->height)) { + memset(out, 0, bw2 * 4); + } else { + for(i = 0; i < bw2; i++){ + if((mx + i < 0) || (mx + i >= c->width)) + out[i] = 0; + else + out[i] = tprev[i]; + } + } + out += c->width; + tprev += c->width; + } + + if(d) { /* apply XOR'ed difference */ + out = output + x; + for(j = 0; j < bh2; j++){ + for(i = 0; i < bw2; i++) { + out[i] ^= *((uint32_t*)src); + src += 4; + } + out += c->width; + } + } + } + output += c->width * c->bh; + prev += c->width * c->bh; + } + if(src - c->decomp_buf != c->decomp_len) + av_log(c->avctx, AV_LOG_ERROR, "Used %ti of %i bytes\n", src-c->decomp_buf, c->decomp_len); + return 0; +} + +/** + * Decode intraframe + */ +static int zmbv_decode_intra(ZmbvContext *c) +{ + uint8_t *src = c->decomp_buf; + + /* make the palette available on the way out */ + if (c->fmt == ZMBV_FMT_8BPP) { + memcpy(c->pal, src, 768); + src += 768; + } + + memcpy(c->cur, src, c->width * c->height * (c->bpp / 8)); + return 0; +} + +static int decode_frame(AVCodecContext *avctx, void *data, int *data_size, const uint8_t *buf, int buf_size) +{ + ZmbvContext * const c = avctx->priv_data; + uint8_t *outptr; + int zret = Z_OK; // Zlib return code + int len = buf_size; + int hi_ver, lo_ver; + + if(c->pic.data[0]) + avctx->release_buffer(avctx, &c->pic); + + c->pic.reference = 1; + c->pic.buffer_hints = FF_BUFFER_HINTS_VALID; + if(avctx->get_buffer(avctx, &c->pic) < 0){ + av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n"); + return -1; + } + + outptr = c->pic.data[0]; // Output image pointer + + /* parse header */ + c->flags = buf[0]; + buf++; len--; + if(c->flags & ZMBV_KEYFRAME) { + hi_ver = buf[0]; + lo_ver = buf[1]; + c->comp = buf[2]; + c->fmt = buf[3]; + c->bw = buf[4]; + c->bh = buf[5]; + + buf += 6; + len -= 6; + av_log(avctx, AV_LOG_DEBUG, "Flags=%X ver=%i.%i comp=%i fmt=%i blk=%ix%i\n",c->flags,hi_ver,lo_ver,c->comp,c->fmt,c->bw,c->bh); + if(hi_ver != 0 || lo_ver != 1) { + av_log(avctx, AV_LOG_ERROR, "Unsupported version %i.%i\n", hi_ver, lo_ver); + return -1; + } + if(c->bw == 0 || c->bh == 0) { + av_log(avctx, AV_LOG_ERROR, "Unsupported block size %ix%i\n", c->bw, c->bh); + } + if(c->comp != 0 && c->comp != 1) { + av_log(avctx, AV_LOG_ERROR, "Unsupported compression type %i\n", c->comp); + return -1; + } + + switch(c->fmt) { + case ZMBV_FMT_8BPP: + c->bpp = 8; + c->decode_intra = zmbv_decode_intra; + c->decode_xor = zmbv_decode_xor_8; + break; + case ZMBV_FMT_15BPP: + case ZMBV_FMT_16BPP: + c->bpp = 16; + c->decode_intra = zmbv_decode_intra; + c->decode_xor = zmbv_decode_xor_16; + break; +#ifdef ZMBV_ENABLE_24BPP + case ZMBV_FMT_24BPP: + c->bpp = 24; + c->decode_intra = zmbv_decode_intra; + c->decode_xor = zmbv_decode_xor_24; + break; +#endif //ZMBV_ENABLE_24BPP + case ZMBV_FMT_32BPP: + c->bpp = 32; + c->decode_intra = zmbv_decode_intra; + c->decode_xor = zmbv_decode_xor_32; + break; + default: + c->decode_intra = NULL; + c->decode_xor = NULL; + av_log(avctx, AV_LOG_ERROR, "Unsupported (for now) format %i\n", c->fmt); + return -1; + } + + zret = inflateReset(&c->zstream); + if (zret != Z_OK) { + av_log(avctx, AV_LOG_ERROR, "Inflate reset error: %d\n", zret); + return -1; + } + + c->cur = av_realloc(c->cur, avctx->width * avctx->height * (c->bpp / 8)); + c->prev = av_realloc(c->prev, avctx->width * avctx->height * (c->bpp / 8)); + c->bx = (c->width + c->bw - 1) / c->bw; + c->by = (c->height+ c->bh - 1) / c->bh; + } + + if(c->decode_intra == NULL) { + av_log(avctx, AV_LOG_ERROR, "Error! Got no format or no keyframe!\n"); + return -1; + } + + if(c->comp == 0) { //Uncompressed data + memcpy(c->decomp_buf, buf, len); + c->decomp_size = 1; + } else { // ZLIB-compressed data + c->zstream.total_in = c->zstream.total_out = 0; + c->zstream.next_in = buf; + c->zstream.avail_in = len; + c->zstream.next_out = c->decomp_buf; + c->zstream.avail_out = c->decomp_size; + inflate(&c->zstream, Z_FINISH); + c->decomp_len = c->zstream.total_out; + } + if(c->flags & ZMBV_KEYFRAME) { + c->pic.key_frame = 1; + c->pic.pict_type = FF_I_TYPE; + c->decode_intra(c); + } else { + c->pic.key_frame = 0; + c->pic.pict_type = FF_P_TYPE; + if(c->decomp_len) + c->decode_xor(c); + } + + /* update frames */ + { + uint8_t *out, *src; + int i, j; + + out = c->pic.data[0]; + src = c->cur; + switch(c->fmt) { + case ZMBV_FMT_8BPP: + for(j = 0; j < c->height; j++) { + for(i = 0; i < c->width; i++) { + out[i * 3 + 0] = c->pal[(*src) * 3 + 0]; + out[i * 3 + 1] = c->pal[(*src) * 3 + 1]; + out[i * 3 + 2] = c->pal[(*src) * 3 + 2]; + src++; + } + out += c->pic.linesize[0]; + } + break; + case ZMBV_FMT_15BPP: + for(j = 0; j < c->height; j++) { + for(i = 0; i < c->width; i++) { + uint16_t tmp = AV_RL16(src); + src += 2; + out[i * 3 + 0] = (tmp & 0x7C00) >> 7; + out[i * 3 + 1] = (tmp & 0x03E0) >> 2; + out[i * 3 + 2] = (tmp & 0x001F) << 3; + } + out += c->pic.linesize[0]; + } + break; + case ZMBV_FMT_16BPP: + for(j = 0; j < c->height; j++) { + for(i = 0; i < c->width; i++) { + uint16_t tmp = AV_RL16(src); + src += 2; + out[i * 3 + 0] = (tmp & 0xF800) >> 8; + out[i * 3 + 1] = (tmp & 0x07E0) >> 3; + out[i * 3 + 2] = (tmp & 0x001F) << 3; + } + out += c->pic.linesize[0]; + } + break; +#ifdef ZMBV_ENABLE_24BPP + case ZMBV_FMT_24BPP: + for(j = 0; j < c->height; j++) { + memcpy(out, src, c->width * 3); + src += c->width * 3; + out += c->pic.linesize[0]; + } + break; +#endif //ZMBV_ENABLE_24BPP + case ZMBV_FMT_32BPP: + for(j = 0; j < c->height; j++) { + for(i = 0; i < c->width; i++) { + uint32_t tmp = AV_RL32(src); + src += 4; + AV_WB24(out+(i*3), tmp); + } + out += c->pic.linesize[0]; + } + break; + default: + av_log(avctx, AV_LOG_ERROR, "Cannot handle format %i\n", c->fmt); + } + memcpy(c->prev, c->cur, c->width * c->height * (c->bpp / 8)); + } + *data_size = sizeof(AVFrame); + *(AVFrame*)data = c->pic; + + /* always report that the buffer was completely consumed */ + return buf_size; +} + + + +/* + * + * Init zmbv decoder + * + */ +static av_cold int decode_init(AVCodecContext *avctx) +{ + ZmbvContext * const c = avctx->priv_data; + int zret; // Zlib return code + + c->avctx = avctx; + + c->pic.data[0] = NULL; + c->width = avctx->width; + c->height = avctx->height; + + if (avcodec_check_dimensions(avctx, avctx->width, avctx->height) < 0) { + return 1; + } + c->bpp = avctx->bits_per_sample; + + // Needed if zlib unused or init aborted before inflateInit + memset(&(c->zstream), 0, sizeof(z_stream)); + + avctx->pix_fmt = PIX_FMT_RGB24; + c->decomp_size = (avctx->width + 255) * 4 * (avctx->height + 64); + + /* Allocate decompression buffer */ + if (c->decomp_size) { + if ((c->decomp_buf = av_malloc(c->decomp_size)) == NULL) { + av_log(avctx, AV_LOG_ERROR, "Can't allocate decompression buffer.\n"); + return 1; + } + } + + c->zstream.zalloc = Z_NULL; + c->zstream.zfree = Z_NULL; + c->zstream.opaque = Z_NULL; + zret = inflateInit(&(c->zstream)); + if (zret != Z_OK) { + av_log(avctx, AV_LOG_ERROR, "Inflate init error: %d\n", zret); + return 1; + } + + return 0; +} + + + +/* + * + * Uninit zmbv decoder + * + */ +static av_cold int decode_end(AVCodecContext *avctx) +{ + ZmbvContext * const c = avctx->priv_data; + + av_freep(&c->decomp_buf); + + if (c->pic.data[0]) + avctx->release_buffer(avctx, &c->pic); + inflateEnd(&(c->zstream)); + av_freep(&c->cur); + av_freep(&c->prev); + + return 0; +} + +AVCodec zmbv_decoder = { + "zmbv", + CODEC_TYPE_VIDEO, + CODEC_ID_ZMBV, + sizeof(ZmbvContext), + decode_init, + NULL, + decode_end, + decode_frame, + .long_name = NULL_IF_CONFIG_SMALL("Zip Motion Blocks Video"), +}; + diff --git a/src/add-ons/media/plugins/avcodec/libavcodec/zmbvenc.c b/src/add-ons/media/plugins/avcodec/libavcodec/zmbvenc.c new file mode 100644 index 0000000000..a6b51ba306 --- /dev/null +++ b/src/add-ons/media/plugins/avcodec/libavcodec/zmbvenc.c @@ -0,0 +1,334 @@ +/* + * Zip Motion Blocks Video (ZMBV) encoder + * Copyright (c) 2006 Konstantin Shishkov + * + * This file is part of FFmpeg. + * + * FFmpeg is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * FFmpeg is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with FFmpeg; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +/** + * @file zmbvenc.c + * Zip Motion Blocks Video encoder + */ + +#include +#include + +#include "avcodec.h" + +#include + +#define ZMBV_KEYFRAME 1 +#define ZMBV_DELTAPAL 2 + +#define ZMBV_BLOCK 16 + +/** + * Encoder context + */ +typedef struct ZmbvEncContext { + AVCodecContext *avctx; + AVFrame pic; + + int range; + uint8_t *comp_buf, *work_buf; + uint8_t pal[768]; + uint32_t pal2[256]; //for quick comparisons + uint8_t *prev; + int pstride; + int comp_size; + int keyint, curfrm; + z_stream zstream; +} ZmbvEncContext; + +static int score_tab[256]; + +/** Block comparing function + * XXX should be optimized and moved to DSPContext + * TODO handle out of edge ME + */ +static inline int block_cmp(uint8_t *src, int stride, uint8_t *src2, int stride2, int bw, int bh) +{ + int sum = 0; + int i, j; + uint8_t histogram[256]={0}; + + for(j = 0; j < bh; j++){ + for(i = 0; i < bw; i++) + histogram[src[i] ^ src2[i]]++; + src += stride; + src2 += stride2; + } + + for(i=1; i<256; i++) + sum+= score_tab[histogram[i]]; + + return sum; +} + +/** Motion estimation function + * TODO make better ME decisions + */ +static int zmbv_me(ZmbvEncContext *c, uint8_t *src, int sstride, uint8_t *prev, int pstride, + int x, int y, int *mx, int *my) +{ + int dx, dy, tx, ty, tv, bv, bw, bh; + + *mx = *my = 0; + bw = FFMIN(ZMBV_BLOCK, c->avctx->width - x); + bh = FFMIN(ZMBV_BLOCK, c->avctx->height - y); + bv = block_cmp(src, sstride, prev, pstride, bw, bh); + if(!bv) return 0; + for(ty = FFMAX(y - c->range, 0); ty < FFMIN(y + c->range, c->avctx->height - bh); ty++){ + for(tx = FFMAX(x - c->range, 0); tx < FFMIN(x + c->range, c->avctx->width - bw); tx++){ + if(tx == x && ty == y) continue; // we already tested this block + dx = tx - x; + dy = ty - y; + tv = block_cmp(src, sstride, prev + dx + dy*pstride, pstride, bw, bh); + if(tv < bv){ + bv = tv; + *mx = dx; + *my = dy; + if(!bv) return 0; + } + } + } + return bv; +} + +static int encode_frame(AVCodecContext *avctx, uint8_t *buf, int buf_size, void *data) +{ + ZmbvEncContext * const c = avctx->priv_data; + AVFrame *pict = data; + AVFrame * const p = &c->pic; + uint8_t *src, *prev; + uint32_t *palptr; + int zret = Z_OK; + int len = 0; + int keyframe, chpal; + int fl; + int work_size = 0; + int bw, bh; + int i, j; + + keyframe = !c->curfrm; + c->curfrm++; + if(c->curfrm == c->keyint) + c->curfrm = 0; + *p = *pict; + p->pict_type= keyframe ? FF_I_TYPE : FF_P_TYPE; + p->key_frame= keyframe; + chpal = !keyframe && memcmp(p->data[1], c->pal2, 1024); + + fl = (keyframe ? ZMBV_KEYFRAME : 0) | (chpal ? ZMBV_DELTAPAL : 0); + *buf++ = fl; len++; + if(keyframe){ + deflateReset(&c->zstream); + *buf++ = 0; len++; // hi ver + *buf++ = 1; len++; // lo ver + *buf++ = 1; len++; // comp + *buf++ = 4; len++; // format - 8bpp + *buf++ = ZMBV_BLOCK; len++; // block width + *buf++ = ZMBV_BLOCK; len++; // block height + } + palptr = (uint32_t*)p->data[1]; + src = p->data[0]; + prev = c->prev; + if(chpal){ + uint8_t tpal[3]; + for(i = 0; i < 256; i++){ + AV_WB24(tpal, palptr[i]); + c->work_buf[work_size++] = tpal[0] ^ c->pal[i * 3 + 0]; + c->work_buf[work_size++] = tpal[1] ^ c->pal[i * 3 + 1]; + c->work_buf[work_size++] = tpal[2] ^ c->pal[i * 3 + 2]; + c->pal[i * 3 + 0] = tpal[0]; + c->pal[i * 3 + 1] = tpal[1]; + c->pal[i * 3 + 2] = tpal[2]; + } + memcpy(c->pal2, p->data[1], 1024); + } + if(keyframe){ + for(i = 0; i < 256; i++){ + AV_WB24(c->pal+(i*3), palptr[i]); + } + memcpy(c->work_buf, c->pal, 768); + memcpy(c->pal2, p->data[1], 1024); + work_size = 768; + for(i = 0; i < avctx->height; i++){ + memcpy(c->work_buf + work_size, src, avctx->width); + src += p->linesize[0]; + work_size += avctx->width; + } + }else{ + int x, y, bh2, bw2; + uint8_t *tsrc, *tprev; + uint8_t *mv; + int mx, my, bv; + + bw = (avctx->width + ZMBV_BLOCK - 1) / ZMBV_BLOCK; + bh = (avctx->height + ZMBV_BLOCK - 1) / ZMBV_BLOCK; + mv = c->work_buf + work_size; + memset(c->work_buf + work_size, 0, (bw * bh * 2 + 3) & ~3); + work_size += (bw * bh * 2 + 3) & ~3; + /* for now just XOR'ing */ + for(y = 0; y < avctx->height; y += ZMBV_BLOCK) { + bh2 = FFMIN(avctx->height - y, ZMBV_BLOCK); + for(x = 0; x < avctx->width; x += ZMBV_BLOCK, mv += 2) { + bw2 = FFMIN(avctx->width - x, ZMBV_BLOCK); + + tsrc = src + x; + tprev = prev + x; + + bv = zmbv_me(c, tsrc, p->linesize[0], tprev, c->pstride, x, y, &mx, &my); + mv[0] = (mx << 1) | !!bv; + mv[1] = my << 1; + tprev += mx + my * c->pstride; + if(bv){ + for(j = 0; j < bh2; j++){ + for(i = 0; i < bw2; i++) + c->work_buf[work_size++] = tsrc[i] ^ tprev[i]; + tsrc += p->linesize[0]; + tprev += c->pstride; + } + } + } + src += p->linesize[0] * ZMBV_BLOCK; + prev += c->pstride * ZMBV_BLOCK; + } + } + /* save the previous frame */ + src = p->data[0]; + prev = c->prev; + for(i = 0; i < avctx->height; i++){ + memcpy(prev, src, avctx->width); + prev += c->pstride; + src += p->linesize[0]; + } + + c->zstream.next_in = c->work_buf; + c->zstream.avail_in = work_size; + c->zstream.total_in = 0; + + c->zstream.next_out = c->comp_buf; + c->zstream.avail_out = c->comp_size; + c->zstream.total_out = 0; + if((zret = deflate(&c->zstream, Z_SYNC_FLUSH)) != Z_OK){ + av_log(avctx, AV_LOG_ERROR, "Error compressing data\n"); + return -1; + } + + memcpy(buf, c->comp_buf, c->zstream.total_out); + return len + c->zstream.total_out; +} + + +/** + * Init zmbv encoder + */ +static av_cold int encode_init(AVCodecContext *avctx) +{ + ZmbvEncContext * const c = avctx->priv_data; + int zret; // Zlib return code + int i; + int lvl = 9; + + for(i=1; i<256; i++) + score_tab[i]= -i * log(i/(double)(ZMBV_BLOCK*ZMBV_BLOCK)) * (256/M_LN2); + + c->avctx = avctx; + + c->pic.data[0] = NULL; + c->curfrm = 0; + c->keyint = avctx->keyint_min; + c->range = 8; + if(avctx->me_range > 0) + c->range = FFMIN(avctx->me_range, 127); + + if(avctx->compression_level >= 0) + lvl = avctx->compression_level; + if(lvl < 0 || lvl > 9){ + av_log(avctx, AV_LOG_ERROR, "Compression level should be 0-9, not %i\n", lvl); + return -1; + } + + if (avcodec_check_dimensions(avctx, avctx->width, avctx->height) < 0) { + return -1; + } + + // Needed if zlib unused or init aborted before deflateInit + memset(&(c->zstream), 0, sizeof(z_stream)); + c->comp_size = avctx->width * avctx->height + 1024 + + ((avctx->width + ZMBV_BLOCK - 1) / ZMBV_BLOCK) * ((avctx->height + ZMBV_BLOCK - 1) / ZMBV_BLOCK) * 2 + 4; + if ((c->work_buf = av_malloc(c->comp_size)) == NULL) { + av_log(avctx, AV_LOG_ERROR, "Can't allocate work buffer.\n"); + return -1; + } + /* Conservative upper bound taken from zlib v1.2.1 source via lcl.c */ + c->comp_size = c->comp_size + ((c->comp_size + 7) >> 3) + + ((c->comp_size + 63) >> 6) + 11; + + /* Allocate compression buffer */ + if ((c->comp_buf = av_malloc(c->comp_size)) == NULL) { + av_log(avctx, AV_LOG_ERROR, "Can't allocate compression buffer.\n"); + return -1; + } + c->pstride = (avctx->width + 15) & ~15; + if ((c->prev = av_malloc(c->pstride * avctx->height)) == NULL) { + av_log(avctx, AV_LOG_ERROR, "Can't allocate picture.\n"); + return -1; + } + + c->zstream.zalloc = Z_NULL; + c->zstream.zfree = Z_NULL; + c->zstream.opaque = Z_NULL; + zret = deflateInit(&(c->zstream), lvl); + if (zret != Z_OK) { + av_log(avctx, AV_LOG_ERROR, "Inflate init error: %d\n", zret); + return -1; + } + + return 0; +} + + + +/** + * Uninit zmbv encoder + */ +static av_cold int encode_end(AVCodecContext *avctx) +{ + ZmbvEncContext * const c = avctx->priv_data; + + av_freep(&c->comp_buf); + av_freep(&c->work_buf); + + deflateEnd(&(c->zstream)); + av_freep(&c->prev); + + return 0; +} + +AVCodec zmbv_encoder = { + "zmbv", + CODEC_TYPE_VIDEO, + CODEC_ID_ZMBV, + sizeof(ZmbvEncContext), + encode_init, + encode_frame, + encode_end, + .pix_fmts = (enum PixelFormat[]){PIX_FMT_PAL8, PIX_FMT_NONE}, + .long_name = NULL_IF_CONFIG_SMALL("Zip Motion Blocks Video"), +};