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