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 "libavutil/intreadwrite.h"
24 #include "libavutil/mem.h"
25 
26 #include "avcodec.h"
27 #include "bytestream.h"
28 #include "internal.h"
29 
30 typedef struct XanContext {
33 
38 } XanContext;
39 
41 {
42  XanContext *s = avctx->priv_data;
43 
44  av_frame_free(&s->pic);
45 
46  av_freep(&s->y_buffer);
48 
49  return 0;
50 }
51 
53 {
54  XanContext *s = avctx->priv_data;
55 
56  s->avctx = avctx;
57 
58  avctx->pix_fmt = AV_PIX_FMT_YUV420P;
59 
60  if (avctx->height < 8) {
61  av_log(avctx, AV_LOG_ERROR, "Invalid frame height: %d.\n", avctx->height);
62  return AVERROR(EINVAL);
63  }
64  if (avctx->width & 1) {
65  av_log(avctx, AV_LOG_ERROR, "Invalid frame width: %d.\n", avctx->width);
66  return AVERROR(EINVAL);
67  }
68 
69  s->buffer_size = avctx->width * avctx->height;
71  if (!s->y_buffer)
72  return AVERROR(ENOMEM);
73  s->scratch_buffer = av_malloc(s->buffer_size + 130);
74  if (!s->scratch_buffer) {
75  xan_decode_end(avctx);
76  return AVERROR(ENOMEM);
77  }
78 
79  s->pic = av_frame_alloc();
80  if (!s->pic) {
81  xan_decode_end(avctx);
82  return AVERROR(ENOMEM);
83  }
84 
85  return 0;
86 }
87 
89  uint8_t *dst, const int dst_size)
90 {
91  int tree_size, eof;
92  int bits, mask;
93  int tree_root, node;
94  const uint8_t *dst_end = dst + dst_size;
95  GetByteContext tree = s->gb;
96  int start_off = bytestream2_tell(&tree);
97 
98  tree_size = bytestream2_get_byte(&s->gb);
99  eof = bytestream2_get_byte(&s->gb);
100  tree_root = eof + tree_size;
101  bytestream2_skip(&s->gb, tree_size * 2);
102 
103  node = tree_root;
104  bits = bytestream2_get_byte(&s->gb);
105  mask = 0x80;
106  for (;;) {
107  int bit = !!(bits & mask);
108  mask >>= 1;
109  bytestream2_seek(&tree, start_off + node*2 + bit - eof * 2, SEEK_SET);
110  node = bytestream2_get_byte(&tree);
111  if (node == eof)
112  break;
113  if (node < eof) {
114  *dst++ = node;
115  if (dst > dst_end)
116  break;
117  node = tree_root;
118  }
119  if (!mask) {
120  if (bytestream2_get_bytes_left(&s->gb) <= 0)
121  break;
122  bits = bytestream2_get_byteu(&s->gb);
123  mask = 0x80;
124  }
125  }
126  return dst != dst_end ? AVERROR_INVALIDDATA : 0;
127 }
128 
129 /* almost the same as in xan_wc3 decoder */
130 static int xan_unpack(XanContext *s,
131  uint8_t *dest, const int dest_len)
132 {
133  uint8_t opcode;
134  int size;
135  uint8_t *orig_dest = dest;
136  const uint8_t *dest_end = dest + dest_len;
137 
138  while (dest < dest_end) {
139  if (bytestream2_get_bytes_left(&s->gb) <= 0)
140  return AVERROR_INVALIDDATA;
141 
142  opcode = bytestream2_get_byteu(&s->gb);
143 
144  if (opcode < 0xe0) {
145  int size2, back;
146  if ((opcode & 0x80) == 0) {
147  size = opcode & 3;
148  back = ((opcode & 0x60) << 3) + bytestream2_get_byte(&s->gb) + 1;
149  size2 = ((opcode & 0x1c) >> 2) + 3;
150  } else if ((opcode & 0x40) == 0) {
151  size = bytestream2_peek_byte(&s->gb) >> 6;
152  back = (bytestream2_get_be16(&s->gb) & 0x3fff) + 1;
153  size2 = (opcode & 0x3f) + 4;
154  } else {
155  size = opcode & 3;
156  back = ((opcode & 0x10) << 12) + bytestream2_get_be16(&s->gb) + 1;
157  size2 = ((opcode & 0x0c) << 6) + bytestream2_get_byte(&s->gb) + 5;
158  if (size + size2 > dest_end - dest)
159  break;
160  }
161  if (dest + size + size2 > dest_end ||
162  dest - orig_dest + size < back)
163  return AVERROR_INVALIDDATA;
164  bytestream2_get_buffer(&s->gb, dest, size);
165  dest += size;
166  av_memcpy_backptr(dest, back, size2);
167  dest += size2;
168  } else {
169  int finish = opcode >= 0xfc;
170 
171  size = finish ? opcode & 3 : ((opcode & 0x1f) << 2) + 4;
172  if (dest_end - dest < size)
173  return AVERROR_INVALIDDATA;
174  bytestream2_get_buffer(&s->gb, dest, size);
175  dest += size;
176  if (finish)
177  break;
178  }
179  }
180  return dest - orig_dest;
181 }
182 
183 static int xan_decode_chroma(AVCodecContext *avctx, unsigned chroma_off)
184 {
185  XanContext *s = avctx->priv_data;
186  uint8_t *U, *V;
187  int val, uval, vval;
188  int i, j;
189  const uint8_t *src, *src_end;
190  const uint8_t *table;
191  int mode, offset, dec_size, table_size;
192 
193  if (!chroma_off)
194  return 0;
195  if (chroma_off + 4 >= bytestream2_get_bytes_left(&s->gb)) {
196  av_log(avctx, AV_LOG_ERROR, "Invalid chroma block position\n");
197  return AVERROR_INVALIDDATA;
198  }
199  bytestream2_seek(&s->gb, chroma_off + 4, SEEK_SET);
200  mode = bytestream2_get_le16(&s->gb);
201  table = s->gb.buffer;
202  table_size = bytestream2_get_le16(&s->gb);
203  offset = table_size * 2;
204  table_size += 1;
205 
206  if (offset >= bytestream2_get_bytes_left(&s->gb)) {
207  av_log(avctx, AV_LOG_ERROR, "Invalid chroma block offset\n");
208  return AVERROR_INVALIDDATA;
209  }
210 
211  bytestream2_skip(&s->gb, offset);
212  memset(s->scratch_buffer, 0, s->buffer_size);
213  dec_size = xan_unpack(s, s->scratch_buffer, s->buffer_size);
214  if (dec_size < 0) {
215  av_log(avctx, AV_LOG_ERROR, "Chroma unpacking failed\n");
216  return dec_size;
217  }
218 
219  U = s->pic->data[1];
220  V = s->pic->data[2];
221  src = s->scratch_buffer;
222  src_end = src + dec_size;
223  if (mode) {
224  for (j = 0; j < avctx->height >> 1; j++) {
225  for (i = 0; i < avctx->width >> 1; i++) {
226  if (src_end - src < 1)
227  return 0;
228  val = *src++;
229  if (val) {
230  if (val >= table_size)
231  return AVERROR_INVALIDDATA;
232  val = AV_RL16(table + (val << 1));
233  uval = (val >> 3) & 0xF8;
234  vval = (val >> 8) & 0xF8;
235  U[i] = uval | (uval >> 5);
236  V[i] = vval | (vval >> 5);
237  }
238  }
239  U += s->pic->linesize[1];
240  V += s->pic->linesize[2];
241  }
242  if (avctx->height & 1) {
243  memcpy(U, U - s->pic->linesize[1], avctx->width >> 1);
244  memcpy(V, V - s->pic->linesize[2], avctx->width >> 1);
245  }
246  } else {
247  uint8_t *U2 = U + s->pic->linesize[1];
248  uint8_t *V2 = V + s->pic->linesize[2];
249 
250  for (j = 0; j < avctx->height >> 2; j++) {
251  for (i = 0; i < avctx->width >> 1; i += 2) {
252  if (src_end - src < 1)
253  return 0;
254  val = *src++;
255  if (val) {
256  if (val >= table_size)
257  return AVERROR_INVALIDDATA;
258  val = AV_RL16(table + (val << 1));
259  uval = (val >> 3) & 0xF8;
260  vval = (val >> 8) & 0xF8;
261  U[i] = U[i+1] = U2[i] = U2[i+1] = uval | (uval >> 5);
262  V[i] = V[i+1] = V2[i] = V2[i+1] = vval | (vval >> 5);
263  }
264  }
265  U += s->pic->linesize[1] * 2;
266  V += s->pic->linesize[2] * 2;
267  U2 += s->pic->linesize[1] * 2;
268  V2 += s->pic->linesize[2] * 2;
269  }
270  if (avctx->height & 3) {
271  int lines = ((avctx->height + 1) >> 1) - (avctx->height >> 2) * 2;
272 
273  memcpy(U, U - lines * s->pic->linesize[1], lines * s->pic->linesize[1]);
274  memcpy(V, V - lines * s->pic->linesize[2], lines * s->pic->linesize[2]);
275  }
276  }
277 
278  return 0;
279 }
280 
282 {
283  XanContext *s = avctx->priv_data;
284  uint8_t *ybuf, *prev_buf, *src = s->scratch_buffer;
285  unsigned chroma_off, corr_off;
286  int cur, last;
287  int i, j;
288  int ret;
289 
290  chroma_off = bytestream2_get_le32(&s->gb);
291  corr_off = bytestream2_get_le32(&s->gb);
292 
293  if ((ret = xan_decode_chroma(avctx, chroma_off)) != 0)
294  return ret;
295 
296  if (corr_off >= bytestream2_size(&s->gb)) {
297  av_log(avctx, AV_LOG_WARNING, "Ignoring invalid correction block position\n");
298  corr_off = 0;
299  }
300  bytestream2_seek(&s->gb, 12, SEEK_SET);
301  ret = xan_unpack_luma(s, src, s->buffer_size >> 1);
302  if (ret) {
303  av_log(avctx, AV_LOG_ERROR, "Luma decoding failed\n");
304  return ret;
305  }
306 
307  ybuf = s->y_buffer;
308  last = *src++;
309  ybuf[0] = last << 1;
310  for (j = 1; j < avctx->width - 1; j += 2) {
311  cur = (last + *src++) & 0x1F;
312  ybuf[j] = last + cur;
313  ybuf[j+1] = cur << 1;
314  last = cur;
315  }
316  ybuf[j] = last << 1;
317  prev_buf = ybuf;
318  ybuf += avctx->width;
319 
320  for (i = 1; i < avctx->height; i++) {
321  last = ((prev_buf[0] >> 1) + *src++) & 0x1F;
322  ybuf[0] = last << 1;
323  for (j = 1; j < avctx->width - 1; j += 2) {
324  cur = ((prev_buf[j + 1] >> 1) + *src++) & 0x1F;
325  ybuf[j] = last + cur;
326  ybuf[j+1] = cur << 1;
327  last = cur;
328  }
329  ybuf[j] = last << 1;
330  prev_buf = ybuf;
331  ybuf += avctx->width;
332  }
333 
334  if (corr_off) {
335  int dec_size;
336 
337  bytestream2_seek(&s->gb, 8 + corr_off, SEEK_SET);
338  dec_size = xan_unpack(s, s->scratch_buffer, s->buffer_size / 2);
339  if (dec_size < 0)
340  dec_size = 0;
341  else
342  dec_size = FFMIN(dec_size, s->buffer_size/2 - 1);
343 
344  for (i = 0; i < dec_size; i++)
345  s->y_buffer[i*2+1] = (s->y_buffer[i*2+1] + (s->scratch_buffer[i] << 1)) & 0x3F;
346  }
347 
348  src = s->y_buffer;
349  ybuf = s->pic->data[0];
350  for (j = 0; j < avctx->height; j++) {
351  for (i = 0; i < avctx->width; i++)
352  ybuf[i] = (src[i] << 2) | (src[i] >> 3);
353  src += avctx->width;
354  ybuf += s->pic->linesize[0];
355  }
356 
357  return 0;
358 }
359 
361 {
362  XanContext *s = avctx->priv_data;
363  uint8_t *ybuf, *src = s->scratch_buffer;
364  int cur, last;
365  int i, j;
366  int ret;
367 
368  if ((ret = xan_decode_chroma(avctx, bytestream2_get_le32(&s->gb))) != 0)
369  return ret;
370 
371  bytestream2_seek(&s->gb, 16, SEEK_SET);
372  ret = xan_unpack_luma(s, src,
373  s->buffer_size >> 1);
374  if (ret) {
375  av_log(avctx, AV_LOG_ERROR, "Luma decoding failed\n");
376  return ret;
377  }
378 
379  ybuf = s->y_buffer;
380  for (i = 0; i < avctx->height; i++) {
381  last = (ybuf[0] + (*src++ << 1)) & 0x3F;
382  ybuf[0] = last;
383  for (j = 1; j < avctx->width - 1; j += 2) {
384  cur = (ybuf[j + 1] + (*src++ << 1)) & 0x3F;
385  ybuf[j] = (last + cur) >> 1;
386  ybuf[j+1] = cur;
387  last = cur;
388  }
389  ybuf[j] = last;
390  ybuf += avctx->width;
391  }
392 
393  src = s->y_buffer;
394  ybuf = s->pic->data[0];
395  for (j = 0; j < avctx->height; j++) {
396  for (i = 0; i < avctx->width; i++)
397  ybuf[i] = (src[i] << 2) | (src[i] >> 3);
398  src += avctx->width;
399  ybuf += s->pic->linesize[0];
400  }
401 
402  return 0;
403 }
404 
406  void *data, int *got_frame,
407  AVPacket *avpkt)
408 {
409  XanContext *s = avctx->priv_data;
410  int ftype;
411  int ret;
412 
413  if ((ret = ff_reget_buffer(avctx, s->pic)) < 0)
414  return ret;
415 
416  bytestream2_init(&s->gb, avpkt->data, avpkt->size);
417  ftype = bytestream2_get_le32(&s->gb);
418  switch (ftype) {
419  case 0:
420  ret = xan_decode_frame_type0(avctx);
421  break;
422  case 1:
423  ret = xan_decode_frame_type1(avctx);
424  break;
425  default:
426  av_log(avctx, AV_LOG_ERROR, "Unknown frame type %d\n", ftype);
427  return AVERROR_INVALIDDATA;
428  }
429  if (ret)
430  return ret;
431 
432  if ((ret = av_frame_ref(data, s->pic)) < 0)
433  return ret;
434 
435  *got_frame = 1;
436 
437  return avpkt->size;
438 }
439 
441  .name = "xan_wc4",
442  .long_name = NULL_IF_CONFIG_SMALL("Wing Commander IV / Xxan"),
443  .type = AVMEDIA_TYPE_VIDEO,
444  .id = AV_CODEC_ID_XAN_WC4,
445  .priv_data_size = sizeof(XanContext),
447  .close = xan_decode_end,
449  .capabilities = AV_CODEC_CAP_DR1,
450 };
const char const char void * val
Definition: avisynth_c.h:771
const char * s
Definition: avisynth_c.h:768
#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:1591
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1887
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:440
AVCodec.
Definition: avcodec.h:3573
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:281
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:1590
const uint8_t * buffer
Definition: bytestream.h:34
void av_memcpy_backptr(uint8_t *dst, int back, int cnt)
Overlapping memcpy() implementation.
Definition: mem.c:430
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:3580
static const uint8_t offset[127][2]
Definition: vf_spp.c:92
uint8_t * y_buffer
Definition: xxan.c:34
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:35
#define FFMIN(a, b)
Definition: common.h:96
int width
picture width / height.
Definition: avcodec.h:1846
static int xan_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: xxan.c:405
#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:40
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:1659
Definition: xan.c:53
static int xan_unpack_luma(XanContext *s, uint8_t *dst, const int dst_size)
Definition: xxan.c:88
static av_cold int xan_decode_init(AVCodecContext *avctx)
Definition: xxan.c:52
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:198
int buffer_size
Definition: xxan.c:36
static int decode(AVCodecContext *avctx, void *data, int *got_sub, AVPacket *avpkt)
Definition: ccaption_dec.c:752
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:360
void * priv_data
Definition: avcodec.h:1701
static int xan_unpack(XanContext *s, uint8_t *dest, const int dest_len)
Definition: xxan.c:130
static av_always_inline int bytestream2_seek(GetByteContext *g, int offset, int whence)
Definition: bytestream.h:208
AVFrame * pic
Definition: xxan.c:32
#define av_freep(p)
GetByteContext gb
Definition: xxan.c:37
This structure stores compressed data.
Definition: avcodec.h:1567
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: avcodec.h:958
AVCodecContext * avctx
Definition: xan.c:55
static int xan_decode_chroma(AVCodecContext *avctx, unsigned chroma_off)
Definition: xxan.c:183
#define V
Definition: avdct.c:30