FFmpeg  2.8.17
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Modules Pages
xan.c
Go to the documentation of this file.
1 /*
2  * Wing Commander/Xan Video Decoder
3  * Copyright (c) 2003 The FFmpeg Project
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 Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
22 /**
23  * @file
24  * Xan video decoder for Wing Commander III computer game
25  * by Mario Brito (mbrito@student.dei.uc.pt)
26  * and Mike Melanson (melanson@pcisys.net)
27  *
28  * The xan_wc3 decoder outputs PAL8 data.
29  */
30 
31 #include <stdio.h>
32 #include <stdlib.h>
33 #include <string.h>
34 
35 #include "libavutil/intreadwrite.h"
36 #include "libavutil/mem.h"
37 #include "avcodec.h"
38 #include "bytestream.h"
39 #define BITSTREAM_READER_LE
40 #include "get_bits.h"
41 #include "internal.h"
42 
43 #define RUNTIME_GAMMA 0
44 
45 #define VGA__TAG MKTAG('V', 'G', 'A', ' ')
46 #define PALT_TAG MKTAG('P', 'A', 'L', 'T')
47 #define SHOT_TAG MKTAG('S', 'H', 'O', 'T')
48 #define PALETTE_COUNT 256
49 #define PALETTE_SIZE (PALETTE_COUNT * 3)
50 #define PALETTES_MAX 256
51 
52 typedef struct XanContext {
53 
56 
57  const uint8_t *buf;
58  int size;
59 
60  /* scratch space */
65 
66  unsigned *palettes;
69 
71 
72 } XanContext;
73 
75 {
76  XanContext *s = avctx->priv_data;
77 
79 
80  av_freep(&s->buffer1);
81  av_freep(&s->buffer2);
82  av_freep(&s->palettes);
83 
84  return 0;
85 }
86 
88 {
89  XanContext *s = avctx->priv_data;
90 
91  s->avctx = avctx;
92  s->frame_size = 0;
93 
94  avctx->pix_fmt = AV_PIX_FMT_PAL8;
95 
96  s->buffer1_size = avctx->width * avctx->height;
98  if (!s->buffer1)
99  return AVERROR(ENOMEM);
100  s->buffer2_size = avctx->width * avctx->height;
101  s->buffer2 = av_malloc(s->buffer2_size + 130);
102  if (!s->buffer2) {
103  av_freep(&s->buffer1);
104  return AVERROR(ENOMEM);
105  }
106 
107  s->last_frame = av_frame_alloc();
108  if (!s->last_frame) {
109  xan_decode_end(avctx);
110  return AVERROR(ENOMEM);
111  }
112 
113  return 0;
114 }
115 
116 static int xan_huffman_decode(uint8_t *dest, int dest_len,
117  const uint8_t *src, int src_len)
118 {
119  uint8_t byte = *src++;
120  uint8_t ival = byte + 0x16;
121  const uint8_t * ptr = src + byte*2;
122  int ptr_len = src_len - 1 - byte*2;
123  uint8_t val = ival;
124  uint8_t *dest_end = dest + dest_len;
125  uint8_t *dest_start = dest;
126  int ret;
127  GetBitContext gb;
128 
129  if ((ret = init_get_bits8(&gb, ptr, ptr_len)) < 0)
130  return ret;
131 
132  while (val != 0x16) {
133  unsigned idx;
134  if (get_bits_left(&gb) < 1)
135  return AVERROR_INVALIDDATA;
136  idx = val - 0x17 + get_bits1(&gb) * byte;
137  if (idx >= 2 * byte)
138  return AVERROR_INVALIDDATA;
139  val = src[idx];
140 
141  if (val < 0x16) {
142  if (dest >= dest_end)
143  return dest_len;
144  *dest++ = val;
145  val = ival;
146  }
147  }
148 
149  return dest - dest_start;
150 }
151 
152 /**
153  * unpack simple compression
154  *
155  * @param dest destination buffer of dest_len, must be padded with at least 130 bytes
156  */
157 static void xan_unpack(uint8_t *dest, int dest_len,
158  const uint8_t *src, int src_len)
159 {
160  uint8_t opcode;
161  int size;
162  uint8_t *dest_org = dest;
163  uint8_t *dest_end = dest + dest_len;
164  GetByteContext ctx;
165 
166  bytestream2_init(&ctx, src, src_len);
167  while (dest < dest_end && bytestream2_get_bytes_left(&ctx)) {
168  opcode = bytestream2_get_byte(&ctx);
169 
170  if (opcode < 0xe0) {
171  int size2, back;
172  if ((opcode & 0x80) == 0) {
173  size = opcode & 3;
174 
175  back = ((opcode & 0x60) << 3) + bytestream2_get_byte(&ctx) + 1;
176  size2 = ((opcode & 0x1c) >> 2) + 3;
177  } else if ((opcode & 0x40) == 0) {
178  size = bytestream2_peek_byte(&ctx) >> 6;
179 
180  back = (bytestream2_get_be16(&ctx) & 0x3fff) + 1;
181  size2 = (opcode & 0x3f) + 4;
182  } else {
183  size = opcode & 3;
184 
185  back = ((opcode & 0x10) << 12) + bytestream2_get_be16(&ctx) + 1;
186  size2 = ((opcode & 0x0c) << 6) + bytestream2_get_byte(&ctx) + 5;
187  }
188 
189  if (dest_end - dest < size + size2 ||
190  dest + size - dest_org < back ||
191  bytestream2_get_bytes_left(&ctx) < size)
192  return;
193  bytestream2_get_buffer(&ctx, dest, size);
194  dest += size;
195  av_memcpy_backptr(dest, back, size2);
196  dest += size2;
197  } else {
198  int finish = opcode >= 0xfc;
199  size = finish ? opcode & 3 : ((opcode & 0x1f) << 2) + 4;
200 
201  if (dest_end - dest < size || bytestream2_get_bytes_left(&ctx) < size)
202  return;
203  bytestream2_get_buffer(&ctx, dest, size);
204  dest += size;
205  if (finish)
206  return;
207  }
208  }
209 }
210 
212  const uint8_t *pixel_buffer, int x, int y, int pixel_count)
213 {
214  int stride;
215  int line_inc;
216  int index;
217  int current_x;
218  int width = s->avctx->width;
219  uint8_t *palette_plane;
220 
221  palette_plane = frame->data[0];
222  stride = frame->linesize[0];
223  line_inc = stride - width;
224  index = y * stride + x;
225  current_x = x;
226  while (pixel_count && index < s->frame_size) {
227  int count = FFMIN(pixel_count, width - current_x);
228  memcpy(palette_plane + index, pixel_buffer, count);
229  pixel_count -= count;
230  index += count;
231  pixel_buffer += count;
232  current_x += count;
233 
234  if (current_x >= width) {
235  index += line_inc;
236  current_x = 0;
237  }
238  }
239 }
240 
242  int x, int y,
243  int pixel_count, int motion_x,
244  int motion_y)
245 {
246  int stride;
247  int line_inc;
248  int curframe_index, prevframe_index;
249  int curframe_x, prevframe_x;
250  int width = s->avctx->width;
251  uint8_t *palette_plane, *prev_palette_plane;
252 
253  if (y + motion_y < 0 || y + motion_y >= s->avctx->height ||
254  x + motion_x < 0 || x + motion_x >= s->avctx->width)
255  return;
256 
257  palette_plane = frame->data[0];
258  prev_palette_plane = s->last_frame->data[0];
259  if (!prev_palette_plane)
260  prev_palette_plane = palette_plane;
261  stride = frame->linesize[0];
262  line_inc = stride - width;
263  curframe_index = y * stride + x;
264  curframe_x = x;
265  prevframe_index = (y + motion_y) * stride + x + motion_x;
266  prevframe_x = x + motion_x;
267 
268  if (prev_palette_plane == palette_plane && FFABS(motion_x + width*motion_y) < pixel_count) {
269  avpriv_request_sample(s->avctx, "Overlapping copy");
270  return ;
271  }
272 
273  while (pixel_count &&
274  curframe_index < s->frame_size &&
275  prevframe_index < s->frame_size) {
276  int count = FFMIN3(pixel_count, width - curframe_x,
277  width - prevframe_x);
278 
279  memcpy(palette_plane + curframe_index,
280  prev_palette_plane + prevframe_index, count);
281  pixel_count -= count;
282  curframe_index += count;
283  prevframe_index += count;
284  curframe_x += count;
285  prevframe_x += count;
286 
287  if (curframe_x >= width) {
288  curframe_index += line_inc;
289  curframe_x = 0;
290  }
291 
292  if (prevframe_x >= width) {
293  prevframe_index += line_inc;
294  prevframe_x = 0;
295  }
296  }
297 }
298 
300 {
301 
302  int width = s->avctx->width;
303  int height = s->avctx->height;
304  int total_pixels = width * height;
305  uint8_t opcode;
306  uint8_t flag = 0;
307  int size = 0;
308  int motion_x, motion_y;
309  int x, y, ret;
310 
311  uint8_t *opcode_buffer = s->buffer1;
312  uint8_t *opcode_buffer_end = s->buffer1 + s->buffer1_size;
313  int opcode_buffer_size = s->buffer1_size;
314  const uint8_t *imagedata_buffer = s->buffer2;
315 
316  /* pointers to segments inside the compressed chunk */
317  const uint8_t *huffman_segment;
318  GetByteContext size_segment;
319  GetByteContext vector_segment;
320  const uint8_t *imagedata_segment;
321  int huffman_offset, size_offset, vector_offset, imagedata_offset,
322  imagedata_size;
323 
324  if (s->size < 8)
325  return AVERROR_INVALIDDATA;
326 
327  huffman_offset = AV_RL16(&s->buf[0]);
328  size_offset = AV_RL16(&s->buf[2]);
329  vector_offset = AV_RL16(&s->buf[4]);
330  imagedata_offset = AV_RL16(&s->buf[6]);
331 
332  if (huffman_offset >= s->size ||
333  size_offset >= s->size ||
334  vector_offset >= s->size ||
335  imagedata_offset >= s->size)
336  return AVERROR_INVALIDDATA;
337 
338  huffman_segment = s->buf + huffman_offset;
339  bytestream2_init(&size_segment, s->buf + size_offset, s->size - size_offset);
340  bytestream2_init(&vector_segment, s->buf + vector_offset, s->size - vector_offset);
341  imagedata_segment = s->buf + imagedata_offset;
342 
343  if ((ret = xan_huffman_decode(opcode_buffer, opcode_buffer_size,
344  huffman_segment, s->size - huffman_offset)) < 0)
345  return AVERROR_INVALIDDATA;
346  opcode_buffer_end = opcode_buffer + ret;
347 
348  if (imagedata_segment[0] == 2) {
350  &imagedata_segment[1], s->size - imagedata_offset - 1);
351  imagedata_size = s->buffer2_size;
352  } else {
353  imagedata_size = s->size - imagedata_offset - 1;
354  imagedata_buffer = &imagedata_segment[1];
355  }
356 
357  /* use the decoded data segments to build the frame */
358  x = y = 0;
359  while (total_pixels && opcode_buffer < opcode_buffer_end) {
360 
361  opcode = *opcode_buffer++;
362  size = 0;
363 
364  switch (opcode) {
365 
366  case 0:
367  flag ^= 1;
368  continue;
369 
370  case 1:
371  case 2:
372  case 3:
373  case 4:
374  case 5:
375  case 6:
376  case 7:
377  case 8:
378  size = opcode;
379  break;
380 
381  case 12:
382  case 13:
383  case 14:
384  case 15:
385  case 16:
386  case 17:
387  case 18:
388  size += (opcode - 10);
389  break;
390 
391  case 9:
392  case 19:
393  if (bytestream2_get_bytes_left(&size_segment) < 1) {
394  av_log(s->avctx, AV_LOG_ERROR, "size_segment overread\n");
395  return AVERROR_INVALIDDATA;
396  }
397  size = bytestream2_get_byte(&size_segment);
398  break;
399 
400  case 10:
401  case 20:
402  if (bytestream2_get_bytes_left(&size_segment) < 2) {
403  av_log(s->avctx, AV_LOG_ERROR, "size_segment overread\n");
404  return AVERROR_INVALIDDATA;
405  }
406  size = bytestream2_get_be16(&size_segment);
407  break;
408 
409  case 11:
410  case 21:
411  if (bytestream2_get_bytes_left(&size_segment) < 3) {
412  av_log(s->avctx, AV_LOG_ERROR, "size_segment overread\n");
413  return AVERROR_INVALIDDATA;
414  }
415  size = bytestream2_get_be24(&size_segment);
416  break;
417  }
418 
419  if (size > total_pixels)
420  break;
421 
422  if (opcode < 12) {
423  flag ^= 1;
424  if (flag) {
425  /* run of (size) pixels is unchanged from last frame */
426  xan_wc3_copy_pixel_run(s, frame, x, y, size, 0, 0);
427  } else {
428  /* output a run of pixels from imagedata_buffer */
429  if (imagedata_size < size)
430  break;
431  xan_wc3_output_pixel_run(s, frame, imagedata_buffer, x, y, size);
432  imagedata_buffer += size;
433  imagedata_size -= size;
434  }
435  } else {
436  uint8_t vector;
437  if (bytestream2_get_bytes_left(&vector_segment) <= 0) {
438  av_log(s->avctx, AV_LOG_ERROR, "vector_segment overread\n");
439  return AVERROR_INVALIDDATA;
440  }
441  /* run-based motion compensation from last frame */
442  vector = bytestream2_get_byte(&vector_segment);
443  motion_x = sign_extend(vector >> 4, 4);
444  motion_y = sign_extend(vector & 0xF, 4);
445 
446  /* copy a run of pixels from the previous frame */
447  xan_wc3_copy_pixel_run(s, frame, x, y, size, motion_x, motion_y);
448 
449  flag = 0;
450  }
451 
452  /* coordinate accounting */
453  total_pixels -= size;
454  y += (x + size) / width;
455  x = (x + size) % width;
456  }
457  return 0;
458 }
459 
460 #if RUNTIME_GAMMA
461 static inline unsigned mul(unsigned a, unsigned b)
462 {
463  return (a * b) >> 16;
464 }
465 
466 static inline unsigned pow4(unsigned a)
467 {
468  unsigned square = mul(a, a);
469  return mul(square, square);
470 }
471 
472 static inline unsigned pow5(unsigned a)
473 {
474  return mul(pow4(a), a);
475 }
476 
477 static uint8_t gamma_corr(uint8_t in) {
478  unsigned lo, hi = 0xff40, target;
479  int i = 15;
480  in = (in << 2) | (in >> 6);
481  /* equivalent float code:
482  if (in >= 252)
483  return 253;
484  return round(pow(in / 256.0, 0.8) * 256);
485  */
486  lo = target = in << 8;
487  do {
488  unsigned mid = (lo + hi) >> 1;
489  unsigned pow = pow5(mid);
490  if (pow > target) hi = mid;
491  else lo = mid;
492  } while (--i);
493  return (pow4((lo + hi) >> 1) + 0x80) >> 8;
494 }
495 #else
496 /**
497  * This is a gamma correction that xan3 applies to all palette entries.
498  *
499  * There is a peculiarity, namely that the values are clamped to 253 -
500  * it seems likely that this table was calculated by a buggy fixed-point
501  * implementation, the one above under RUNTIME_GAMMA behaves like this for
502  * example.
503  * The exponent value of 0.8 can be explained by this as well, since 0.8 = 4/5
504  * and thus pow(x, 0.8) is still easy to calculate.
505  * Also, the input values are first rotated to the left by 2.
506  */
507 static const uint8_t gamma_lookup[256] = {
508  0x00, 0x09, 0x10, 0x16, 0x1C, 0x21, 0x27, 0x2C,
509  0x31, 0x35, 0x3A, 0x3F, 0x43, 0x48, 0x4C, 0x50,
510  0x54, 0x59, 0x5D, 0x61, 0x65, 0x69, 0x6D, 0x71,
511  0x75, 0x79, 0x7D, 0x80, 0x84, 0x88, 0x8C, 0x8F,
512  0x93, 0x97, 0x9A, 0x9E, 0xA2, 0xA5, 0xA9, 0xAC,
513  0xB0, 0xB3, 0xB7, 0xBA, 0xBE, 0xC1, 0xC5, 0xC8,
514  0xCB, 0xCF, 0xD2, 0xD5, 0xD9, 0xDC, 0xDF, 0xE3,
515  0xE6, 0xE9, 0xED, 0xF0, 0xF3, 0xF6, 0xFA, 0xFD,
516  0x03, 0x0B, 0x12, 0x18, 0x1D, 0x23, 0x28, 0x2D,
517  0x32, 0x36, 0x3B, 0x40, 0x44, 0x49, 0x4D, 0x51,
518  0x56, 0x5A, 0x5E, 0x62, 0x66, 0x6A, 0x6E, 0x72,
519  0x76, 0x7A, 0x7D, 0x81, 0x85, 0x89, 0x8D, 0x90,
520  0x94, 0x98, 0x9B, 0x9F, 0xA2, 0xA6, 0xAA, 0xAD,
521  0xB1, 0xB4, 0xB8, 0xBB, 0xBF, 0xC2, 0xC5, 0xC9,
522  0xCC, 0xD0, 0xD3, 0xD6, 0xDA, 0xDD, 0xE0, 0xE4,
523  0xE7, 0xEA, 0xED, 0xF1, 0xF4, 0xF7, 0xFA, 0xFD,
524  0x05, 0x0D, 0x13, 0x19, 0x1F, 0x24, 0x29, 0x2E,
525  0x33, 0x38, 0x3C, 0x41, 0x45, 0x4A, 0x4E, 0x52,
526  0x57, 0x5B, 0x5F, 0x63, 0x67, 0x6B, 0x6F, 0x73,
527  0x77, 0x7B, 0x7E, 0x82, 0x86, 0x8A, 0x8D, 0x91,
528  0x95, 0x99, 0x9C, 0xA0, 0xA3, 0xA7, 0xAA, 0xAE,
529  0xB2, 0xB5, 0xB9, 0xBC, 0xBF, 0xC3, 0xC6, 0xCA,
530  0xCD, 0xD0, 0xD4, 0xD7, 0xDA, 0xDE, 0xE1, 0xE4,
531  0xE8, 0xEB, 0xEE, 0xF1, 0xF5, 0xF8, 0xFB, 0xFD,
532  0x07, 0x0E, 0x15, 0x1A, 0x20, 0x25, 0x2A, 0x2F,
533  0x34, 0x39, 0x3D, 0x42, 0x46, 0x4B, 0x4F, 0x53,
534  0x58, 0x5C, 0x60, 0x64, 0x68, 0x6C, 0x70, 0x74,
535  0x78, 0x7C, 0x7F, 0x83, 0x87, 0x8B, 0x8E, 0x92,
536  0x96, 0x99, 0x9D, 0xA1, 0xA4, 0xA8, 0xAB, 0xAF,
537  0xB2, 0xB6, 0xB9, 0xBD, 0xC0, 0xC4, 0xC7, 0xCB,
538  0xCE, 0xD1, 0xD5, 0xD8, 0xDB, 0xDF, 0xE2, 0xE5,
539  0xE9, 0xEC, 0xEF, 0xF2, 0xF6, 0xF9, 0xFC, 0xFD
540 };
541 #endif
542 
544  void *data, int *got_frame,
545  AVPacket *avpkt)
546 {
547  AVFrame *frame = data;
548  const uint8_t *buf = avpkt->data;
549  int ret, buf_size = avpkt->size;
550  XanContext *s = avctx->priv_data;
551  GetByteContext ctx;
552  int tag = 0;
553 
554  bytestream2_init(&ctx, buf, buf_size);
555  while (bytestream2_get_bytes_left(&ctx) > 8 && tag != VGA__TAG) {
556  unsigned *tmpptr;
557  uint32_t new_pal;
558  int size;
559  int i;
560  tag = bytestream2_get_le32(&ctx);
561  size = bytestream2_get_be32(&ctx);
562  if (size < 0) {
563  av_log(avctx, AV_LOG_ERROR, "Invalid tag size %d\n", size);
564  return AVERROR_INVALIDDATA;
565  }
566  size = FFMIN(size, bytestream2_get_bytes_left(&ctx));
567  switch (tag) {
568  case PALT_TAG:
569  if (size < PALETTE_SIZE)
570  return AVERROR_INVALIDDATA;
571  if (s->palettes_count >= PALETTES_MAX)
572  return AVERROR_INVALIDDATA;
573  tmpptr = av_realloc_array(s->palettes,
575  if (!tmpptr)
576  return AVERROR(ENOMEM);
577  s->palettes = tmpptr;
578  tmpptr += s->palettes_count * AVPALETTE_COUNT;
579  for (i = 0; i < PALETTE_COUNT; i++) {
580 #if RUNTIME_GAMMA
581  int r = gamma_corr(bytestream2_get_byteu(&ctx));
582  int g = gamma_corr(bytestream2_get_byteu(&ctx));
583  int b = gamma_corr(bytestream2_get_byteu(&ctx));
584 #else
585  int r = gamma_lookup[bytestream2_get_byteu(&ctx)];
586  int g = gamma_lookup[bytestream2_get_byteu(&ctx)];
587  int b = gamma_lookup[bytestream2_get_byteu(&ctx)];
588 #endif
589  *tmpptr++ = (0xFFU << 24) | (r << 16) | (g << 8) | b;
590  }
591  s->palettes_count++;
592  break;
593  case SHOT_TAG:
594  if (size < 4)
595  return AVERROR_INVALIDDATA;
596  new_pal = bytestream2_get_le32(&ctx);
597  if (new_pal < s->palettes_count) {
598  s->cur_palette = new_pal;
599  } else
600  av_log(avctx, AV_LOG_ERROR, "Invalid palette selected\n");
601  break;
602  case VGA__TAG:
603  break;
604  default:
605  bytestream2_skip(&ctx, size);
606  break;
607  }
608  }
609  buf_size = bytestream2_get_bytes_left(&ctx);
610 
611  if (s->palettes_count <= 0) {
612  av_log(s->avctx, AV_LOG_ERROR, "No palette found\n");
613  return AVERROR_INVALIDDATA;
614  }
615 
616  if ((ret = ff_get_buffer(avctx, frame, AV_GET_BUFFER_FLAG_REF)) < 0)
617  return ret;
618 
619  if (!s->frame_size)
620  s->frame_size = frame->linesize[0] * s->avctx->height;
621 
622  memcpy(frame->data[1],
624 
625  s->buf = ctx.buffer;
626  s->size = buf_size;
627 
628  if (xan_wc3_decode_frame(s, frame) < 0)
629  return AVERROR_INVALIDDATA;
630 
632  if ((ret = av_frame_ref(s->last_frame, frame)) < 0)
633  return ret;
634 
635  *got_frame = 1;
636 
637  /* always report that the buffer was completely consumed */
638  return buf_size;
639 }
640 
642  .name = "xan_wc3",
643  .long_name = NULL_IF_CONFIG_SMALL("Wing Commander III / Xan"),
644  .type = AVMEDIA_TYPE_VIDEO,
645  .id = AV_CODEC_ID_XAN_WC3,
646  .priv_data_size = sizeof(XanContext),
648  .close = xan_decode_end,
650  .capabilities = AV_CODEC_CAP_DR1,
651 };
static int xan_wc3_decode_frame(XanContext *s, AVFrame *frame)
Definition: xan.c:299
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:171
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:101
memory handling functions
int frame_size
Definition: xan.c:70
const char * g
Definition: vf_curves.c:108
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
#define avpriv_request_sample(...)
int size
Definition: avcodec.h:1434
const char * b
Definition: vf_curves.c:109
int palettes_count
Definition: xan.c:67
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1732
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
Definition: bytestream.h:133
#define AV_RL16
Definition: intreadwrite.h:42
static void xan_unpack(uint8_t *dest, int dest_len, const uint8_t *src, int src_len)
unpack simple compression
Definition: xan.c:157
static const uint8_t gamma_lookup[256]
This is a gamma correction that xan3 applies to all palette entries.
Definition: xan.c:507
AVCodec.
Definition: avcodec.h:3482
#define PALETTES_MAX
Definition: xan.c:50
uint8_t
#define av_cold
Definition: attributes.h:74
#define av_malloc(s)
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:135
uint8_t * buffer1
Definition: xan.c:61
8 bit with AV_PIX_FMT_RGB32 palette
Definition: pixfmt.h:78
#define AVPALETTE_SIZE
Definition: pixfmt.h:33
int buffer1_size
Definition: xan.c:62
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:366
AVCodec ff_xan_wc3_decoder
Definition: xan.c:641
static AVFrame * frame
uint8_t * data
Definition: avcodec.h:1433
const uint8_t * buffer
Definition: bytestream.h:34
#define FFMIN3(a, b, c)
Definition: common.h:93
uint32_t tag
Definition: movenc.c:1339
bitstream reader API header.
#define SHOT_TAG
Definition: xan.c:47
ptrdiff_t size
Definition: opengl_enc.c:101
const uint8_t * buf
Definition: xan.c:57
#define av_log(a,...)
#define PALT_TAG
Definition: xan.c:46
int flag
Definition: checkasm.c:76
#define U(x)
Definition: vp56_arith.h:37
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:594
static int xan_huffman_decode(uint8_t *dest, int dest_len, const uint8_t *src, int src_len)
Definition: xan.c:116
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
static av_cold int xan_decode_init(AVCodecContext *avctx)
Definition: xan.c:87
#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:148
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:178
const char * r
Definition: vf_curves.c:107
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:3489
static int square(int x)
Definition: roqvideoenc.c:113
GLsizei count
Definition: opengl_enc.c:109
Libavcodec external API header.
#define VGA__TAG
Definition: xan.c:45
return
int size
Definition: xan.c:58
#define FFMIN(a, b)
Definition: common.h:92
float y
int buffer2_size
Definition: xan.c:64
int width
picture width / height.
Definition: avcodec.h:1691
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:68
static void xan_wc3_output_pixel_run(XanContext *s, AVFrame *frame, const uint8_t *pixel_buffer, int x, int y, int pixel_count)
Definition: xan.c:211
int frame_size
Definition: mxfenc.c:1819
AVS_Value src
Definition: avisynth_c.h:482
static av_cold int xan_decode_end(AVCodecContext *avctx)
Definition: xan.c:74
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:199
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:446
main external API structure.
Definition: avcodec.h:1512
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: utils.c:1048
uint8_t pi<< 24) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8, uint8_t,(*(constuint8_t *) pi-0x80)*(1.0f/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8, uint8_t,(*(constuint8_t *) pi-0x80)*(1.0/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16, int16_t,(*(constint16_t *) pi >>8)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, int16_t,*(constint16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, int16_t,*(constint16_t *) pi *(1.0/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32, int32_t,(*(constint32_t *) pi >>24)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, int32_t,*(constint32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, int32_t,*(constint32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, float, av_clip_uint8(lrintf(*(constfloat *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, float, av_clip_int16(lrintf(*(constfloat *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, float, av_clipl_int32(llrintf(*(constfloat *) pi *(1U<< 31)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, double, av_clip_uint8(lrint(*(constdouble *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, double, av_clip_int16(lrint(*(constdouble *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, double, av_clipl_int32(llrint(*(constdouble *) pi *(1U<< 31))))#defineSET_CONV_FUNC_GROUP(ofmt, ifmt) staticvoidset_generic_function(AudioConvert *ac){}voidff_audio_convert_free(AudioConvert **ac){if(!*ac) return;ff_dither_free(&(*ac) ->dc);av_freep(ac);}AudioConvert *ff_audio_convert_alloc(AVAudioResampleContext *avr, enumAVSampleFormatout_fmt, enumAVSampleFormatin_fmt, intchannels, intsample_rate, intapply_map){AudioConvert *ac;intin_planar, out_planar;ac=av_mallocz(sizeof(*ac));if(!ac) returnNULL;ac->avr=avr;ac->out_fmt=out_fmt;ac->in_fmt=in_fmt;ac->channels=channels;ac->apply_map=apply_map;if(avr->dither_method!=AV_RESAMPLE_DITHER_NONE &&av_get_packed_sample_fmt(out_fmt)==AV_SAMPLE_FMT_S16 &&av_get_bytes_per_sample(in_fmt)>2){ac->dc=ff_dither_alloc(avr, out_fmt, in_fmt, channels, sample_rate, apply_map);if(!ac->dc){av_free(ac);returnNULL;}returnac;}in_planar=ff_sample_fmt_is_planar(in_fmt, channels);out_planar=ff_sample_fmt_is_planar(out_fmt, channels);if(in_planar==out_planar){ac->func_type=CONV_FUNC_TYPE_FLAT;ac->planes=in_planar?ac->channels:1;}elseif(in_planar) ac->func_type=CONV_FUNC_TYPE_INTERLEAVE;elseac->func_type=CONV_FUNC_TYPE_DEINTERLEAVE;set_generic_function(ac);if(ARCH_AARCH64) ff_audio_convert_init_aarch64(ac);if(ARCH_ARM) ff_audio_convert_init_arm(ac);if(ARCH_X86) ff_audio_convert_init_x86(ac);returnac;}intff_audio_convert(AudioConvert *ac, AudioData *out, AudioData *in){intuse_generic=1;intlen=in->nb_samples;intp;if(ac->dc){av_log(ac->avr, AV_LOG_TRACE,"%dsamples-audio_convert:%sto%s(dithered)\n", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt));returnff_convert_dither(ac-> in
void * buf
Definition: avisynth_c.h:553
Definition: xan.c:52
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:305
BYTE int const BYTE int int int height
Definition: avisynth_c.h:676
unsigned * palettes
Definition: xan.c:66
int index
Definition: gxfenc.c:89
#define AVPALETTE_COUNT
Definition: pixfmt.h:34
static av_const int sign_extend(int val, unsigned bits)
Definition: mathops.h:138
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:465
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:182
static int decode(AVCodecContext *avctx, void *data, int *got_sub, AVPacket *avpkt)
Definition: ccaption_dec.c:521
static void finish(void)
Definition: ffhash.c:62
common internal api header.
#define PALETTE_COUNT
Definition: xan.c:48
#define PALETTE_SIZE
Definition: xan.c:49
void * av_realloc_array(void *ptr, size_t nmemb, size_t size)
Definition: mem.c:208
void * priv_data
Definition: avcodec.h:1554
int cur_palette
Definition: xan.c:68
static int xan_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: xan.c:543
#define av_freep(p)
void av_memcpy_backptr(uint8_t *dst, int back, int cnt)
deliberately overlapping memcpy implementation
Definition: mem.c:442
static void xan_wc3_copy_pixel_run(XanContext *s, AVFrame *frame, int x, int y, int pixel_count, int motion_x, int motion_y)
Definition: xan.c:241
#define stride
This structure stores compressed data.
Definition: avcodec.h:1410
#define AV_GET_BUFFER_FLAG_REF
The decoder will keep a reference to the frame and may reuse it later.
Definition: avcodec.h:1216
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: avcodec.h:857
AVCodecContext * avctx
Definition: xan.c:54
AVFrame * last_frame
Definition: xan.c:55
static int width
uint8_t * buffer2
Definition: xan.c:63