FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
xxan.c
Go to the documentation of this file.
1 /*
2  * Wing Commander/Xan Video Decoder
3  * Copyright (C) 2011 Konstantin Shishkov
4  * based on work by Mike Melanson
5  *
6  * This file is part of FFmpeg.
7  *
8  * FFmpeg is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Lesser General Public
10  * License as published by the Free Software Foundation; either
11  * version 2.1 of the License, or (at your option) any later version.
12  *
13  * FFmpeg is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16  * Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with FFmpeg; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21  */
22 
23 #include "avcodec.h"
24 #include "libavutil/intreadwrite.h"
25 #include "libavutil/mem.h"
26 #include "bytestream.h"
27 #define BITSTREAM_READER_LE
28 #include "get_bits.h"
29 #include "internal.h"
30 
31 typedef struct XanContext {
34 
39 } XanContext;
40 
42 {
43  XanContext *s = avctx->priv_data;
44 
45  av_frame_free(&s->pic);
46 
47  av_freep(&s->y_buffer);
49 
50  return 0;
51 }
52 
54 {
55  XanContext *s = avctx->priv_data;
56 
57  s->avctx = avctx;
58 
59  avctx->pix_fmt = AV_PIX_FMT_YUV420P;
60 
61  if (avctx->height < 8) {
62  av_log(avctx, AV_LOG_ERROR, "Invalid frame height: %d.\n", avctx->height);
63  return AVERROR(EINVAL);
64  }
65  if (avctx->width & 1) {
66  av_log(avctx, AV_LOG_ERROR, "Invalid frame width: %d.\n", avctx->width);
67  return AVERROR(EINVAL);
68  }
69 
70  s->buffer_size = avctx->width * avctx->height;
72  if (!s->y_buffer)
73  return AVERROR(ENOMEM);
74  s->scratch_buffer = av_malloc(s->buffer_size + 130);
75  if (!s->scratch_buffer) {
76  xan_decode_end(avctx);
77  return AVERROR(ENOMEM);
78  }
79 
80  s->pic = av_frame_alloc();
81  if (!s->pic) {
82  xan_decode_end(avctx);
83  return AVERROR(ENOMEM);
84  }
85 
86  return 0;
87 }
88 
90  uint8_t *dst, const int dst_size)
91 {
92  int tree_size, eof;
93  int bits, mask;
94  int tree_root, node;
95  const uint8_t *dst_end = dst + dst_size;
96  GetByteContext tree = s->gb;
97  int start_off = bytestream2_tell(&tree);
98 
99  tree_size = bytestream2_get_byte(&s->gb);
100  eof = bytestream2_get_byte(&s->gb);
101  tree_root = eof + tree_size;
102  bytestream2_skip(&s->gb, tree_size * 2);
103 
104  node = tree_root;
105  bits = bytestream2_get_byte(&s->gb);
106  mask = 0x80;
107  for (;;) {
108  int bit = !!(bits & mask);
109  mask >>= 1;
110  bytestream2_seek(&tree, start_off + node*2 + bit - eof * 2, SEEK_SET);
111  node = bytestream2_get_byte(&tree);
112  if (node == eof)
113  break;
114  if (node < eof) {
115  *dst++ = node;
116  if (dst > dst_end)
117  break;
118  node = tree_root;
119  }
120  if (!mask) {
121  if (bytestream2_get_bytes_left(&s->gb) <= 0)
122  break;
123  bits = bytestream2_get_byteu(&s->gb);
124  mask = 0x80;
125  }
126  }
127  return dst != dst_end ? AVERROR_INVALIDDATA : 0;
128 }
129 
130 /* almost the same as in xan_wc3 decoder */
131 static int xan_unpack(XanContext *s,
132  uint8_t *dest, const int dest_len)
133 {
134  uint8_t opcode;
135  int size;
136  uint8_t *orig_dest = dest;
137  const uint8_t *dest_end = dest + dest_len;
138 
139  while (dest < dest_end) {
140  if (bytestream2_get_bytes_left(&s->gb) <= 0)
141  return AVERROR_INVALIDDATA;
142 
143  opcode = bytestream2_get_byteu(&s->gb);
144 
145  if (opcode < 0xe0) {
146  int size2, back;
147  if ((opcode & 0x80) == 0) {
148  size = opcode & 3;
149  back = ((opcode & 0x60) << 3) + bytestream2_get_byte(&s->gb) + 1;
150  size2 = ((opcode & 0x1c) >> 2) + 3;
151  } else if ((opcode & 0x40) == 0) {
152  size = bytestream2_peek_byte(&s->gb) >> 6;
153  back = (bytestream2_get_be16(&s->gb) & 0x3fff) + 1;
154  size2 = (opcode & 0x3f) + 4;
155  } else {
156  size = opcode & 3;
157  back = ((opcode & 0x10) << 12) + bytestream2_get_be16(&s->gb) + 1;
158  size2 = ((opcode & 0x0c) << 6) + bytestream2_get_byte(&s->gb) + 5;
159  if (size + size2 > dest_end - dest)
160  break;
161  }
162  if (dest + size + size2 > dest_end ||
163  dest - orig_dest + size < back)
164  return AVERROR_INVALIDDATA;
165  bytestream2_get_buffer(&s->gb, dest, size);
166  dest += size;
167  av_memcpy_backptr(dest, back, size2);
168  dest += size2;
169  } else {
170  int finish = opcode >= 0xfc;
171 
172  size = finish ? opcode & 3 : ((opcode & 0x1f) << 2) + 4;
173  if (dest_end - dest < size)
174  return AVERROR_INVALIDDATA;
175  bytestream2_get_buffer(&s->gb, dest, size);
176  dest += size;
177  if (finish)
178  break;
179  }
180  }
181  return dest - orig_dest;
182 }
183 
184 static int xan_decode_chroma(AVCodecContext *avctx, unsigned chroma_off)
185 {
186  XanContext *s = avctx->priv_data;
187  uint8_t *U, *V;
188  int val, uval, vval;
189  int i, j;
190  const uint8_t *src, *src_end;
191  const uint8_t *table;
192  int mode, offset, dec_size, table_size;
193 
194  if (!chroma_off)
195  return 0;
196  if (chroma_off + 4 >= bytestream2_get_bytes_left(&s->gb)) {
197  av_log(avctx, AV_LOG_ERROR, "Invalid chroma block position\n");
198  return AVERROR_INVALIDDATA;
199  }
200  bytestream2_seek(&s->gb, chroma_off + 4, SEEK_SET);
201  mode = bytestream2_get_le16(&s->gb);
202  table = s->gb.buffer;
203  table_size = bytestream2_get_le16(&s->gb);
204  offset = table_size * 2;
205  table_size += 1;
206 
207  if (offset >= bytestream2_get_bytes_left(&s->gb)) {
208  av_log(avctx, AV_LOG_ERROR, "Invalid chroma block offset\n");
209  return AVERROR_INVALIDDATA;
210  }
211 
212  bytestream2_skip(&s->gb, offset);
213  memset(s->scratch_buffer, 0, s->buffer_size);
214  dec_size = xan_unpack(s, s->scratch_buffer, s->buffer_size);
215  if (dec_size < 0) {
216  av_log(avctx, AV_LOG_ERROR, "Chroma unpacking failed\n");
217  return dec_size;
218  }
219 
220  U = s->pic->data[1];
221  V = s->pic->data[2];
222  src = s->scratch_buffer;
223  src_end = src + dec_size;
224  if (mode) {
225  for (j = 0; j < avctx->height >> 1; j++) {
226  for (i = 0; i < avctx->width >> 1; i++) {
227  if (src_end - src < 1)
228  return 0;
229  val = *src++;
230  if (val) {
231  if (val >= table_size)
232  return AVERROR_INVALIDDATA;
233  val = AV_RL16(table + (val << 1));
234  uval = (val >> 3) & 0xF8;
235  vval = (val >> 8) & 0xF8;
236  U[i] = uval | (uval >> 5);
237  V[i] = vval | (vval >> 5);
238  }
239  }
240  U += s->pic->linesize[1];
241  V += s->pic->linesize[2];
242  }
243  if (avctx->height & 1) {
244  memcpy(U, U - s->pic->linesize[1], avctx->width >> 1);
245  memcpy(V, V - s->pic->linesize[2], avctx->width >> 1);
246  }
247  } else {
248  uint8_t *U2 = U + s->pic->linesize[1];
249  uint8_t *V2 = V + s->pic->linesize[2];
250 
251  for (j = 0; j < avctx->height >> 2; j++) {
252  for (i = 0; i < avctx->width >> 1; i += 2) {
253  if (src_end - src < 1)
254  return 0;
255  val = *src++;
256  if (val) {
257  if (val >= table_size)
258  return AVERROR_INVALIDDATA;
259  val = AV_RL16(table + (val << 1));
260  uval = (val >> 3) & 0xF8;
261  vval = (val >> 8) & 0xF8;
262  U[i] = U[i+1] = U2[i] = U2[i+1] = uval | (uval >> 5);
263  V[i] = V[i+1] = V2[i] = V2[i+1] = vval | (vval >> 5);
264  }
265  }
266  U += s->pic->linesize[1] * 2;
267  V += s->pic->linesize[2] * 2;
268  U2 += s->pic->linesize[1] * 2;
269  V2 += s->pic->linesize[2] * 2;
270  }
271  if (avctx->height & 3) {
272  int lines = ((avctx->height + 1) >> 1) - (avctx->height >> 2) * 2;
273 
274  memcpy(U, U - lines * s->pic->linesize[1], lines * s->pic->linesize[1]);
275  memcpy(V, V - lines * s->pic->linesize[2], lines * s->pic->linesize[2]);
276  }
277  }
278 
279  return 0;
280 }
281 
283 {
284  XanContext *s = avctx->priv_data;
285  uint8_t *ybuf, *prev_buf, *src = s->scratch_buffer;
286  unsigned chroma_off, corr_off;
287  int cur, last;
288  int i, j;
289  int ret;
290 
291  chroma_off = bytestream2_get_le32(&s->gb);
292  corr_off = bytestream2_get_le32(&s->gb);
293 
294  if ((ret = xan_decode_chroma(avctx, chroma_off)) != 0)
295  return ret;
296 
297  if (corr_off >= bytestream2_size(&s->gb)) {
298  av_log(avctx, AV_LOG_WARNING, "Ignoring invalid correction block position\n");
299  corr_off = 0;
300  }
301  bytestream2_seek(&s->gb, 12, SEEK_SET);
302  ret = xan_unpack_luma(s, src, s->buffer_size >> 1);
303  if (ret) {
304  av_log(avctx, AV_LOG_ERROR, "Luma decoding failed\n");
305  return ret;
306  }
307 
308  ybuf = s->y_buffer;
309  last = *src++;
310  ybuf[0] = last << 1;
311  for (j = 1; j < avctx->width - 1; j += 2) {
312  cur = (last + *src++) & 0x1F;
313  ybuf[j] = last + cur;
314  ybuf[j+1] = cur << 1;
315  last = cur;
316  }
317  ybuf[j] = last << 1;
318  prev_buf = ybuf;
319  ybuf += avctx->width;
320 
321  for (i = 1; i < avctx->height; i++) {
322  last = ((prev_buf[0] >> 1) + *src++) & 0x1F;
323  ybuf[0] = last << 1;
324  for (j = 1; j < avctx->width - 1; j += 2) {
325  cur = ((prev_buf[j + 1] >> 1) + *src++) & 0x1F;
326  ybuf[j] = last + cur;
327  ybuf[j+1] = cur << 1;
328  last = cur;
329  }
330  ybuf[j] = last << 1;
331  prev_buf = ybuf;
332  ybuf += avctx->width;
333  }
334 
335  if (corr_off) {
336  int dec_size;
337 
338  bytestream2_seek(&s->gb, 8 + corr_off, SEEK_SET);
339  dec_size = xan_unpack(s, s->scratch_buffer, s->buffer_size / 2);
340  if (dec_size < 0)
341  dec_size = 0;
342  else
343  dec_size = FFMIN(dec_size, s->buffer_size/2 - 1);
344 
345  for (i = 0; i < dec_size; i++)
346  s->y_buffer[i*2+1] = (s->y_buffer[i*2+1] + (s->scratch_buffer[i] << 1)) & 0x3F;
347  }
348 
349  src = s->y_buffer;
350  ybuf = s->pic->data[0];
351  for (j = 0; j < avctx->height; j++) {
352  for (i = 0; i < avctx->width; i++)
353  ybuf[i] = (src[i] << 2) | (src[i] >> 3);
354  src += avctx->width;
355  ybuf += s->pic->linesize[0];
356  }
357 
358  return 0;
359 }
360 
362 {
363  XanContext *s = avctx->priv_data;
364  uint8_t *ybuf, *src = s->scratch_buffer;
365  int cur, last;
366  int i, j;
367  int ret;
368 
369  if ((ret = xan_decode_chroma(avctx, bytestream2_get_le32(&s->gb))) != 0)
370  return ret;
371 
372  bytestream2_seek(&s->gb, 16, SEEK_SET);
373  ret = xan_unpack_luma(s, src,
374  s->buffer_size >> 1);
375  if (ret) {
376  av_log(avctx, AV_LOG_ERROR, "Luma decoding failed\n");
377  return ret;
378  }
379 
380  ybuf = s->y_buffer;
381  for (i = 0; i < avctx->height; i++) {
382  last = (ybuf[0] + (*src++ << 1)) & 0x3F;
383  ybuf[0] = last;
384  for (j = 1; j < avctx->width - 1; j += 2) {
385  cur = (ybuf[j + 1] + (*src++ << 1)) & 0x3F;
386  ybuf[j] = (last + cur) >> 1;
387  ybuf[j+1] = cur;
388  last = cur;
389  }
390  ybuf[j] = last;
391  ybuf += avctx->width;
392  }
393 
394  src = s->y_buffer;
395  ybuf = s->pic->data[0];
396  for (j = 0; j < avctx->height; j++) {
397  for (i = 0; i < avctx->width; i++)
398  ybuf[i] = (src[i] << 2) | (src[i] >> 3);
399  src += avctx->width;
400  ybuf += s->pic->linesize[0];
401  }
402 
403  return 0;
404 }
405 
407  void *data, int *got_frame,
408  AVPacket *avpkt)
409 {
410  XanContext *s = avctx->priv_data;
411  int ftype;
412  int ret;
413 
414  if ((ret = ff_reget_buffer(avctx, s->pic)) < 0)
415  return ret;
416 
417  bytestream2_init(&s->gb, avpkt->data, avpkt->size);
418  ftype = bytestream2_get_le32(&s->gb);
419  switch (ftype) {
420  case 0:
421  ret = xan_decode_frame_type0(avctx);
422  break;
423  case 1:
424  ret = xan_decode_frame_type1(avctx);
425  break;
426  default:
427  av_log(avctx, AV_LOG_ERROR, "Unknown frame type %d\n", ftype);
428  return AVERROR_INVALIDDATA;
429  }
430  if (ret)
431  return ret;
432 
433  if ((ret = av_frame_ref(data, s->pic)) < 0)
434  return ret;
435 
436  *got_frame = 1;
437 
438  return avpkt->size;
439 }
440 
442  .name = "xan_wc4",
443  .long_name = NULL_IF_CONFIG_SMALL("Wing Commander IV / Xxan"),
444  .type = AVMEDIA_TYPE_VIDEO,
445  .id = AV_CODEC_ID_XAN_WC4,
446  .priv_data_size = sizeof(XanContext),
448  .close = xan_decode_end,
450  .capabilities = AV_CODEC_CAP_DR1,
451 };
const char const char void * val
Definition: avisynth_c.h:634
const char * s
Definition: avisynth_c.h:631
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
This structure describes decoded (raw) audio or video data.
Definition: frame.h:184
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:101
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
memory handling functions
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
int size
Definition: avcodec.h:1581
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1877
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
Definition: bytestream.h:133
AVCodec ff_xan_wc4_decoder
Definition: xxan.c:441
AVCodec.
Definition: avcodec.h:3542
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_RL16
Definition: bytestream.h:87
uint8_t bits
Definition: crc.c:296
uint8_t
#define av_cold
Definition: attributes.h:82
#define av_malloc(s)
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:140
static int xan_decode_frame_type0(AVCodecContext *avctx)
Definition: xxan.c:282
mode
Definition: f_perms.c:27
int av_frame_ref(AVFrame *dst, const AVFrame *src)
Set up a new reference to the data described by the source frame.
Definition: frame.c:374
static void finish(void)
Definition: movenc.c:338
uint8_t * data
Definition: avcodec.h:1580
const uint8_t * buffer
Definition: bytestream.h:34
bitstream reader API header.
ptrdiff_t size
Definition: opengl_enc.c:101
#define av_log(a,...)
static av_always_inline int bytestream2_size(GetByteContext *g)
Definition: bytestream.h:198
#define U(x)
Definition: vp56_arith.h:37
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
static const uint16_t mask[17]
Definition: lzw.c:38
#define AVERROR(e)
Definition: error.h:43
static av_always_inline void bytestream2_skip(GetByteContext *g, unsigned int size)
Definition: bytestream.h:164
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:153
static const struct endianess table[]
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:176
static av_always_inline unsigned int bytestream2_get_buffer(GetByteContext *g, uint8_t *dst, unsigned int size)
Definition: bytestream.h:263
static av_always_inline unsigned int bytestream2_get_bytes_left(GetByteContext *g)
Definition: bytestream.h:154
const char * name
Name of the codec implementation.
Definition: avcodec.h:3549
static const uint8_t offset[127][2]
Definition: vf_spp.c:92
uint8_t * y_buffer
Definition: xxan.c:35
int ff_reget_buffer(AVCodecContext *avctx, AVFrame *frame)
Identical in function to av_frame_make_writable(), except it uses ff_get_buffer() to allocate the buf...
Definition: utils.c:977
uint8_t * scratch_buffer
Definition: xxan.c:36
#define FFMIN(a, b)
Definition: common.h:96
int width
picture width / height.
Definition: avcodec.h:1836
static int xan_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: xxan.c:406
#define src
Definition: vp9dsp.c:530
static av_always_inline int bytestream2_tell(GetByteContext *g)
Definition: bytestream.h:188
static av_cold int xan_decode_end(AVCodecContext *avctx)
Definition: xxan.c:41
Libavcodec external API header.
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:215
main external API structure.
Definition: avcodec.h:1649
Definition: xan.c:52
static int xan_unpack_luma(XanContext *s, uint8_t *dst, const int dst_size)
Definition: xxan.c:89
static av_cold int xan_decode_init(AVCodecContext *avctx)
Definition: xxan.c:53
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:198
int buffer_size
Definition: xxan.c:37
static int decode(AVCodecContext *avctx, void *data, int *got_sub, AVPacket *avpkt)
Definition: ccaption_dec.c:728
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:62
common internal api header.
static int xan_decode_frame_type1(AVCodecContext *avctx)
Definition: xxan.c:361
void * priv_data
Definition: avcodec.h:1691
static int xan_unpack(XanContext *s, uint8_t *dest, const int dest_len)
Definition: xxan.c:131
static av_always_inline int bytestream2_seek(GetByteContext *g, int offset, int whence)
Definition: bytestream.h:208
AVFrame * pic
Definition: xxan.c:33
#define av_freep(p)
void av_memcpy_backptr(uint8_t *dst, int back, int cnt)
deliberately overlapping memcpy implementation
Definition: mem.c:430
GetByteContext gb
Definition: xxan.c:38
This structure stores compressed data.
Definition: avcodec.h:1557
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: avcodec.h:956
AVCodecContext * avctx
Definition: xan.c:54
static int xan_decode_chroma(AVCodecContext *avctx, unsigned chroma_off)
Definition: xxan.c:184
#define V
Definition: avdct.c:30