2 * Escape 130 video decoder
3 * Copyright (C) 2008 Eli Friedman (eli.friedman <at> gmail.com)
5 * This file is part of Libav.
7 * Libav is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * Libav is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with Libav; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
22 #include "libavutil/attributes.h"
23 #include "libavutil/mem.h"
25 #define BITSTREAM_READER_LE
29 typedef struct Escape130Context {
32 uint8_t *new_y, *old_y;
33 uint8_t *new_u, *old_u;
34 uint8_t *new_v, *old_v;
40 static const uint8_t offset_table[] = { 2, 4, 10, 20 };
41 static const int8_t sign_table[64][4] = {
101 static const int8_t luma_adjust[] = { -4, -3, -2, -1, 1, 2, 3, 4 };
103 static const int8_t chroma_adjust[2][8] = {
104 { 1, 1, 0, -1, -1, -1, 0, 1 },
105 { 0, 1, 1, 1, 0, -1, -1, -1 }
108 const uint8_t chroma_vals[] = {
109 20, 28, 36, 44, 52, 60, 68, 76,
110 84, 92, 100, 106, 112, 116, 120, 124,
111 128, 132, 136, 140, 144, 150, 156, 164,
112 172, 180, 188, 196, 204, 212, 220, 228
115 static av_cold int escape130_decode_init(AVCodecContext *avctx)
117 Escape130Context *s = avctx->priv_data;
118 avctx->pix_fmt = PIX_FMT_YUV420P;
120 if ((avctx->width & 1) || (avctx->height & 1)) {
121 av_log(avctx, AV_LOG_ERROR,
122 "Dimensions should be a multiple of two.\n");
123 return AVERROR_INVALIDDATA;
126 s->old_y_avg = av_malloc(avctx->width * avctx->height / 4);
127 s->buf1 = av_malloc(avctx->width * avctx->height * 3 / 2);
128 s->buf2 = av_malloc(avctx->width * avctx->height * 3 / 2);
129 if (!s->old_y_avg || !s->buf1 || !s->buf2) {
130 av_freep(&s->old_y_avg);
133 av_log(avctx, AV_LOG_ERROR, "Could not allocate buffer.\n");
134 return AVERROR(ENOMEM);
137 s->linesize[0] = avctx->width;
139 s->linesize[2] = avctx->width / 2;
142 s->new_u = s->new_y + avctx->width * avctx->height;
143 s->new_v = s->new_u + avctx->width * avctx->height / 4;
145 s->old_u = s->old_y + avctx->width * avctx->height;
146 s->old_v = s->old_u + avctx->width * avctx->height / 4;
147 memset(s->old_y, 0, avctx->width * avctx->height);
148 memset(s->old_u, 0x10, avctx->width * avctx->height / 4);
149 memset(s->old_v, 0x10, avctx->width * avctx->height / 4);
154 static av_cold int escape130_decode_close(AVCodecContext *avctx)
156 Escape130Context *s = avctx->priv_data;
158 av_freep(&s->old_y_avg);
165 static int decode_skip_count(GetBitContext* gb)
169 value = get_bits1(gb);
173 value = get_bits(gb, 3);
177 value = get_bits(gb, 8);
181 value = get_bits(gb, 15);
188 static int escape130_decode_frame(AVCodecContext *avctx, void *data,
189 int *got_frame, AVPacket *avpkt)
191 const uint8_t *buf = avpkt->data;
192 int buf_size = avpkt->size;
193 Escape130Context *s = avctx->priv_data;
198 uint8_t *old_y, *old_cb, *old_cr,
199 *new_y, *new_cb, *new_cr;
200 uint8_t *dstY, *dstU, *dstV;
201 unsigned old_y_stride, old_cb_stride, old_cr_stride,
202 new_y_stride, new_cb_stride, new_cr_stride;
203 unsigned total_blocks = avctx->width * avctx->height / 4,
204 block_index, block_x = 0;
205 unsigned y[4] = { 0 }, cb = 0x10, cr = 0x10;
206 int skip = -1, y_avg = 0, i, j;
207 uint8_t *ya = s->old_y_avg;
209 // first 16 bytes are header; no useful information in here
210 if (buf_size <= 16) {
211 av_log(avctx, AV_LOG_ERROR, "Insufficient frame data\n");
212 return AVERROR_INVALIDDATA;
215 if ((ret = ff_get_buffer(avctx, pic, 0)) < 0)
218 init_get_bits(&gb, buf + 16, (buf_size - 16) * 8);
223 new_y_stride = s->linesize[0];
224 new_cb_stride = s->linesize[1];
225 new_cr_stride = s->linesize[2];
229 old_y_stride = s->linesize[0];
230 old_cb_stride = s->linesize[1];
231 old_cr_stride = s->linesize[2];
233 for (block_index = 0; block_index < total_blocks; block_index++) {
234 // Note that this call will make us skip the rest of the blocks
235 // if the frame ends prematurely.
237 skip = decode_skip_count(&gb);
239 av_log(avctx, AV_LOG_ERROR, "Error decoding skip value\n");
240 return AVERROR_INVALIDDATA;
246 y[2] = old_y[old_y_stride];
247 y[3] = old_y[old_y_stride + 1];
252 if (get_bits1(&gb)) {
253 unsigned sign_selector = get_bits(&gb, 6);
254 unsigned difference_selector = get_bits(&gb, 2);
255 y_avg = 2 * get_bits(&gb, 5);
256 for (i = 0; i < 4; i++) {
257 y[i] = av_clip(y_avg + offset_table[difference_selector] *
258 sign_table[sign_selector][i], 0, 63);
260 } else if (get_bits1(&gb)) {
261 if (get_bits1(&gb)) {
262 y_avg = get_bits(&gb, 6);
264 unsigned adjust_index = get_bits(&gb, 3);
265 y_avg = (y_avg + luma_adjust[adjust_index]) & 63;
267 for (i = 0; i < 4; i++)
271 if (get_bits1(&gb)) {
272 if (get_bits1(&gb)) {
273 cb = get_bits(&gb, 5);
274 cr = get_bits(&gb, 5);
276 unsigned adjust_index = get_bits(&gb, 3);
277 cb = (cb + chroma_adjust[0][adjust_index]) & 31;
278 cr = (cr + chroma_adjust[1][adjust_index]) & 31;
286 new_y[new_y_stride] = y[2];
287 new_y[new_y_stride + 1] = y[3];
298 if (block_x * 2 == avctx->width) {
300 old_y += old_y_stride * 2 - avctx->width;
301 old_cb += old_cb_stride - avctx->width / 2;
302 old_cr += old_cr_stride - avctx->width / 2;
303 new_y += new_y_stride * 2 - avctx->width;
304 new_cb += new_cb_stride - avctx->width / 2;
305 new_cr += new_cr_stride - avctx->width / 2;
317 for (j = 0; j < avctx->height; j++) {
318 for (i = 0; i < avctx->width; i++)
319 dstY[i] = new_y[i] << 2;
320 dstY += pic->linesize[0];
321 new_y += new_y_stride;
323 for (j = 0; j < avctx->height / 2; j++) {
324 for (i = 0; i < avctx->width / 2; i++) {
325 dstU[i] = chroma_vals[new_cb[i]];
326 dstV[i] = chroma_vals[new_cr[i]];
328 dstU += pic->linesize[1];
329 dstV += pic->linesize[2];
330 new_cb += new_cb_stride;
331 new_cr += new_cr_stride;
334 av_dlog(avctx, "Frame data: provided %d bytes, used %d bytes\n",
335 buf_size, get_bits_count(&gb) >> 3);
337 FFSWAP(uint8_t*, s->old_y, s->new_y);
338 FFSWAP(uint8_t*, s->old_u, s->new_u);
339 FFSWAP(uint8_t*, s->old_v, s->new_v);
346 AVCodec ff_escape130_decoder = {
348 .type = AVMEDIA_TYPE_VIDEO,
349 .id = AV_CODEC_ID_ESCAPE130,
350 .priv_data_size = sizeof(Escape130Context),
351 .init = escape130_decode_init,
352 .close = escape130_decode_close,
353 .decode = escape130_decode_frame,
354 .capabilities = CODEC_CAP_DR1,
355 .long_name = NULL_IF_CONFIG_SMALL("Escape 130"),