FFmpeg
 All Data Structures Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
eatgv.c
Go to the documentation of this file.
1 /*
2  * Electronic Arts TGV Video Decoder
3  * Copyright (c) 2007-2008 Peter Ross
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg 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.
11  *
12  * FFmpeg 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.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
22 /**
23  * @file
24  * Electronic Arts TGV Video Decoder
25  * by Peter Ross (pross@xvid.org)
26  *
27  * Technical details here:
28  * http://wiki.multimedia.cx/index.php?title=Electronic_Arts_TGV
29  */
30 
31 #include "avcodec.h"
32 #define BITSTREAM_READER_LE
33 #include "get_bits.h"
34 #include "libavutil/imgutils.h"
35 #include "libavutil/mem.h"
36 
37 #define EA_PREAMBLE_SIZE 8
38 #define kVGT_TAG MKTAG('k', 'V', 'G', 'T')
39 
40 typedef struct TgvContext {
46 
47  int (*mv_codebook)[2];
49  int num_mvs; ///< current length of mv_codebook
50  int num_blocks_packed; ///< current length of block_codebook
51 } TgvContext;
52 
54 {
55  TgvContext *s = avctx->priv_data;
56  s->avctx = avctx;
57  avctx->time_base = (AVRational){1, 15};
58  avctx->pix_fmt = AV_PIX_FMT_PAL8;
61  return 0;
62 }
63 
64 /**
65  * Unpack buffer
66  * @return 0 on success, -1 on critical buffer underflow
67  */
68 static int unpack(const uint8_t *src, const uint8_t *src_end,
69  uint8_t *dst, int width, int height)
70 {
71  uint8_t *dst_end = dst + width*height;
72  int size, size1, size2, offset, run;
73  uint8_t *dst_start = dst;
74 
75  if (src[0] & 0x01)
76  src += 5;
77  else
78  src += 2;
79 
80  if (src_end - src < 3)
81  return AVERROR_INVALIDDATA;
82  size = AV_RB24(src);
83  src += 3;
84 
85  while (size > 0 && src < src_end) {
86 
87  /* determine size1 and size2 */
88  size1 = (src[0] & 3);
89  if (src[0] & 0x80) { // 1
90  if (src[0] & 0x40 ) { // 11
91  if (src[0] & 0x20) { // 111
92  if (src[0] < 0xFC) // !(111111)
93  size1 = (((src[0] & 31) + 1) << 2);
94  src++;
95  size2 = 0;
96  } else { // 110
97  offset = ((src[0] & 0x10) << 12) + AV_RB16(&src[1]) + 1;
98  size2 = ((src[0] & 0xC) << 6) + src[3] + 5;
99  src += 4;
100  }
101  } else { // 10
102  size1 = ((src[1] & 0xC0) >> 6);
103  offset = (AV_RB16(&src[1]) & 0x3FFF) + 1;
104  size2 = (src[0] & 0x3F) + 4;
105  src += 3;
106  }
107  } else { // 0
108  offset = ((src[0] & 0x60) << 3) + src[1] + 1;
109  size2 = ((src[0] & 0x1C) >> 2) + 3;
110  src += 2;
111  }
112 
113 
114  /* fetch strip from src */
115  if (size1 > src_end - src)
116  break;
117 
118  if (size1 > 0) {
119  size -= size1;
120  run = FFMIN(size1, dst_end - dst);
121  memcpy(dst, src, run);
122  dst += run;
123  src += run;
124  }
125 
126  if (size2 > 0) {
127  if (dst - dst_start < offset)
128  return 0;
129  size -= size2;
130  run = FFMIN(size2, dst_end - dst);
131  av_memcpy_backptr(dst, offset, run);
132  dst += run;
133  }
134  }
135 
136  return 0;
137 }
138 
139 /**
140  * Decode inter-frame
141  * @return 0 on success, -1 on critical buffer underflow
142  */
143 static int tgv_decode_inter(TgvContext *s, const uint8_t *buf,
144  const uint8_t *buf_end)
145 {
146  int num_mvs;
147  int num_blocks_raw;
148  int num_blocks_packed;
149  int vector_bits;
150  int i,j,x,y;
151  GetBitContext gb;
152  int mvbits;
153  const uint8_t *blocks_raw;
154 
155  if(buf_end - buf < 12)
156  return AVERROR_INVALIDDATA;
157 
158  num_mvs = AV_RL16(&buf[0]);
159  num_blocks_raw = AV_RL16(&buf[2]);
160  num_blocks_packed = AV_RL16(&buf[4]);
161  vector_bits = AV_RL16(&buf[6]);
162  buf += 12;
163 
164  if (vector_bits > MIN_CACHE_BITS || !vector_bits) {
166  "Invalid value for motion vector bits: %d\n", vector_bits);
167  return AVERROR_INVALIDDATA;
168  }
169 
170  /* allocate codebook buffers as necessary */
171  if (num_mvs > s->num_mvs) {
172  s->mv_codebook = av_realloc(s->mv_codebook, num_mvs*2*sizeof(int));
173  s->num_mvs = num_mvs;
174  }
175 
176  if (num_blocks_packed > s->num_blocks_packed) {
177  s->block_codebook = av_realloc(s->block_codebook, num_blocks_packed*16);
178  s->num_blocks_packed = num_blocks_packed;
179  }
180 
181  /* read motion vectors */
182  mvbits = (num_mvs * 2 * 10 + 31) & ~31;
183 
184  if (buf_end - buf < (mvbits>>3) + 16*num_blocks_raw + 8*num_blocks_packed)
185  return AVERROR_INVALIDDATA;
186 
187  init_get_bits(&gb, buf, mvbits);
188  for (i = 0; i < num_mvs; i++) {
189  s->mv_codebook[i][0] = get_sbits(&gb, 10);
190  s->mv_codebook[i][1] = get_sbits(&gb, 10);
191  }
192  buf += mvbits >> 3;
193 
194  /* note ptr to uncompressed blocks */
195  blocks_raw = buf;
196  buf += num_blocks_raw * 16;
197 
198  /* read compressed blocks */
199  init_get_bits(&gb, buf, (buf_end - buf) << 3);
200  for (i = 0; i < num_blocks_packed; i++) {
201  int tmp[4];
202  for (j = 0; j < 4; j++)
203  tmp[j] = get_bits(&gb, 8);
204  for (j = 0; j < 16; j++)
205  s->block_codebook[i][15-j] = tmp[get_bits(&gb, 2)];
206  }
207 
208  if (get_bits_left(&gb) < vector_bits *
209  (s->avctx->height / 4) * (s->avctx->width / 4))
210  return AVERROR_INVALIDDATA;
211 
212  /* read vectors and build frame */
213  for (y = 0; y < s->avctx->height / 4; y++)
214  for (x = 0; x < s->avctx->width / 4; x++) {
215  unsigned int vector = get_bits(&gb, vector_bits);
216  const uint8_t *src;
217  int src_stride;
218 
219  if (vector < num_mvs) {
220  int mx = x * 4 + s->mv_codebook[vector][0];
221  int my = y * 4 + s->mv_codebook[vector][1];
222 
223  if (mx < 0 || mx + 4 > s->avctx->width ||
224  my < 0 || my + 4 > s->avctx->height) {
225  av_log(s->avctx, AV_LOG_ERROR, "MV %d %d out of picture\n", mx, my);
226  continue;
227  }
228 
229  src = s->last_frame.data[0] + mx + my * s->last_frame.linesize[0];
230  src_stride = s->last_frame.linesize[0];
231  } else {
232  int offset = vector - num_mvs;
233  if (offset < num_blocks_raw)
234  src = blocks_raw + 16*offset;
235  else if (offset - num_blocks_raw < num_blocks_packed)
236  src = s->block_codebook[offset - num_blocks_raw];
237  else
238  continue;
239  src_stride = 4;
240  }
241 
242  for (j = 0; j < 4; j++)
243  for (i = 0; i < 4; i++)
244  s->frame.data[0][(y * 4 + j) * s->frame.linesize[0] + (x * 4 + i)] =
245  src[j * src_stride + i];
246  }
247 
248  return 0;
249 }
250 
251 /** release AVFrame buffers if allocated */
252 static void cond_release_buffer(AVFrame *pic)
253 {
254  if (pic->data[0]) {
255  av_freep(&pic->data[0]);
256  av_free(pic->data[1]);
257  }
258 }
259 
261  void *data, int *got_frame,
262  AVPacket *avpkt)
263 {
264  const uint8_t *buf = avpkt->data;
265  int buf_size = avpkt->size;
266  TgvContext *s = avctx->priv_data;
267  const uint8_t *buf_end = buf + buf_size;
268  int chunk_type, ret;
269 
270  if (buf_end - buf < EA_PREAMBLE_SIZE)
271  return AVERROR_INVALIDDATA;
272 
273  chunk_type = AV_RL32(&buf[0]);
274  buf += EA_PREAMBLE_SIZE;
275 
276  if (chunk_type == kVGT_TAG) {
277  int pal_count, i;
278  if(buf_end - buf < 12) {
279  av_log(avctx, AV_LOG_WARNING, "truncated header\n");
280  return AVERROR_INVALIDDATA;
281  }
282 
283  s->width = AV_RL16(&buf[0]);
284  s->height = AV_RL16(&buf[2]);
285  if (s->avctx->width != s->width || s->avctx->height != s->height) {
289  }
290 
291  pal_count = AV_RL16(&buf[6]);
292  buf += 12;
293  for(i = 0; i < pal_count && i < AVPALETTE_COUNT && buf_end - buf >= 3; i++) {
294  s->palette[i] = 0xFFU << 24 | AV_RB24(buf);
295  buf += 3;
296  }
297  }
298 
299  if ((ret = av_image_check_size(s->width, s->height, 0, avctx)) < 0)
300  return ret;
301 
302  /* shuffle */
303  FFSWAP(AVFrame, s->frame, s->last_frame);
304  if (!s->frame.data[0]) {
305  s->frame.reference = 3;
307  s->frame.linesize[0] = s->width;
308 
309  s->frame.data[0] = av_malloc(s->width * s->height);
310  if (!s->frame.data[0])
311  return AVERROR(ENOMEM);
313  if (!s->frame.data[1]) {
314  av_freep(&s->frame.data[0]);
315  return AVERROR(ENOMEM);
316  }
317  }
318  memcpy(s->frame.data[1], s->palette, AVPALETTE_SIZE);
319 
320  if (chunk_type == kVGT_TAG) {
321  s->frame.key_frame = 1;
323  if (unpack(buf, buf_end, s->frame.data[0], s->avctx->width, s->avctx->height) < 0) {
324  av_log(avctx, AV_LOG_WARNING, "truncated intra frame\n");
325  return AVERROR_INVALIDDATA;
326  }
327  } else {
328  if (!s->last_frame.data[0]) {
329  av_log(avctx, AV_LOG_WARNING, "inter frame without corresponding intra frame\n");
330  return buf_size;
331  }
332  s->frame.key_frame = 0;
334  if (tgv_decode_inter(s, buf, buf_end) < 0) {
335  av_log(avctx, AV_LOG_WARNING, "truncated inter frame\n");
336  return AVERROR_INVALIDDATA;
337  }
338  }
339 
340  *got_frame = 1;
341  *(AVFrame*)data = s->frame;
342 
343  return buf_size;
344 }
345 
347 {
348  TgvContext *s = avctx->priv_data;
351  av_free(s->mv_codebook);
353  return 0;
354 }
355 
357  .name = "eatgv",
358  .type = AVMEDIA_TYPE_VIDEO,
359  .id = AV_CODEC_ID_TGV,
360  .priv_data_size = sizeof(TgvContext),
364  .long_name = NULL_IF_CONFIG_SMALL("Electronic Arts TGV video"),
365 };