FFmpeg
smacker.c
Go to the documentation of this file.
1 /*
2  * Smacker decoder
3  * Copyright (c) 2006 Konstantin Shishkov
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  * Smacker decoder
25  */
26 
27 /*
28  * Based on http://wiki.multimedia.cx/index.php?title=Smacker
29  */
30 
31 #include <stdio.h>
32 #include <stdlib.h>
33 
35 
36 #include "avcodec.h"
37 
38 #define SMKTREE_BITS 9
39 #define SMK_NODE 0x80000000
40 
41 #define SMKTREE_DECODE_MAX_RECURSION FFMIN(32, 3 * SMKTREE_BITS)
42 #define SMKTREE_DECODE_BIG_MAX_RECURSION 500
43 
44 /* The maximum possible unchecked overread happens in decode_header_trees:
45  * Decoding the MMAP tree can overread by 6 * SMKTREE_BITS + 1, followed by
46  * three get_bits1, followed by at most 2 + 3 * 16 read bits when reading
47  * the TYPE tree before the next check. 64 is because of 64 bit reads. */
48 #if (6 * SMKTREE_BITS + 1 + 3 + (2 + 3 * 16) + 64) <= 8 * AV_INPUT_BUFFER_PADDING_SIZE
49 #define UNCHECKED_BITSTREAM_READER 1
50 #endif
51 #define BITSTREAM_READER_LE
52 #include "bytestream.h"
53 #include "get_bits.h"
54 #include "internal.h"
55 #include "mathops.h"
56 
57 typedef struct SmackVContext {
60 
62  int mmap_last[3], mclr_last[3], full_last[3], type_last[3];
64 
65 typedef struct HuffEntry {
66  uint8_t value;
67  uint8_t length;
68 } HuffEntry;
69 
70 /**
71  * Context used for code reconstructing
72  */
73 typedef struct HuffContext {
74  int current;
76 } HuffContext;
77 
78 /* common parameters used for decode_bigtree */
79 typedef struct DBCtx {
81  int *values;
82  VLC *v1, *v2;
83  uint8_t vals[2];
84  int escapes[3];
85  int *last;
86 } DBCtx;
87 
88 /* possible runs of blocks */
89 static const int block_runs[64] = {
90  1, 2, 3, 4, 5, 6, 7, 8,
91  9, 10, 11, 12, 13, 14, 15, 16,
92  17, 18, 19, 20, 21, 22, 23, 24,
93  25, 26, 27, 28, 29, 30, 31, 32,
94  33, 34, 35, 36, 37, 38, 39, 40,
95  41, 42, 43, 44, 45, 46, 47, 48,
96  49, 50, 51, 52, 53, 54, 55, 56,
97  57, 58, 59, 128, 256, 512, 1024, 2048 };
98 
104 
105 /**
106  * Decode local frame tree
107  *
108  * Can read SMKTREE_DECODE_MAX_RECURSION before the first check;
109  * does not overread gb on success.
110  */
111 static int smacker_decode_tree(GetBitContext *gb, HuffContext *hc, int length)
112 {
113  if (length > SMKTREE_DECODE_MAX_RECURSION || length > 3 * SMKTREE_BITS) {
114  av_log(NULL, AV_LOG_ERROR, "Maximum tree recursion level exceeded.\n");
115  return AVERROR_INVALIDDATA;
116  }
117 
118  if(!get_bits1(gb)){ //Leaf
119  if (hc->current >= 256) {
120  av_log(NULL, AV_LOG_ERROR, "Tree size exceeded!\n");
121  return AVERROR_INVALIDDATA;
122  }
123  if (get_bits_left(gb) < 8)
124  return AVERROR_INVALIDDATA;
125  hc->entries[hc->current++] = (HuffEntry){ get_bits(gb, 8), length };
126  return 0;
127  } else { //Node
128  int r;
129  length++;
130  r = smacker_decode_tree(gb, hc, length);
131  if(r)
132  return r;
133  return smacker_decode_tree(gb, hc, length);
134  }
135 }
136 
137 /**
138  * Decode header tree
139  *
140  * Checks before the first read, can overread by 6 * SMKTREE_BITS on success.
141  */
142 static int smacker_decode_bigtree(GetBitContext *gb, DBCtx *ctx, int length)
143 {
144  // Larger length can cause segmentation faults due to too deep recursion.
145  if (length > SMKTREE_DECODE_BIG_MAX_RECURSION) {
146  av_log(NULL, AV_LOG_ERROR, "Maximum bigtree recursion level exceeded.\n");
147  return AVERROR_INVALIDDATA;
148  }
149 
150  if (ctx->current >= ctx->length) {
151  av_log(NULL, AV_LOG_ERROR, "Tree size exceeded!\n");
152  return AVERROR_INVALIDDATA;
153  }
154  if (get_bits_left(gb) <= 0)
155  return AVERROR_INVALIDDATA;
156  if(!get_bits1(gb)){ //Leaf
157  int val, i1, i2;
158  i1 = ctx->v1->table ? get_vlc2(gb, ctx->v1->table, SMKTREE_BITS, 3)
159  : ctx->vals[0];
160  i2 = ctx->v2->table ? get_vlc2(gb, ctx->v2->table, SMKTREE_BITS, 3)
161  : ctx->vals[1];
162  val = i1 | (i2 << 8);
163  if(val == ctx->escapes[0]) {
164  ctx->last[0] = ctx->current;
165  val = 0;
166  } else if(val == ctx->escapes[1]) {
167  ctx->last[1] = ctx->current;
168  val = 0;
169  } else if(val == ctx->escapes[2]) {
170  ctx->last[2] = ctx->current;
171  val = 0;
172  }
173 
174  ctx->values[ctx->current++] = val;
175  return 1;
176  } else { //Node
177  int r = 0, r_new, t;
178 
179  t = ctx->current++;
180  r = smacker_decode_bigtree(gb, ctx, length + 1);
181  if(r < 0)
182  return r;
183  ctx->values[t] = SMK_NODE | r;
184  r++;
185  r_new = smacker_decode_bigtree(gb, ctx, length + 1);
186  if (r_new < 0)
187  return r_new;
188  return r + r_new;
189  }
190 }
191 
192 /**
193  * Store large tree as FFmpeg's vlc codes
194  *
195  * Can read FFMAX(1 + SMKTREE_DECODE_MAX_RECURSION, 2 + 3 * 16) bits
196  * before the first check; can overread by 6 * SMKTREE_BITS + 1 on success.
197  */
198 static int smacker_decode_header_tree(SmackVContext *smk, GetBitContext *gb, int **recodes, int *last, int size)
199 {
200  VLC vlc[2] = { { 0 } };
201  int escapes[3];
202  DBCtx ctx;
203  int err;
204 
205  if(size >= UINT_MAX>>4){ // (((size + 3) >> 2) + 3) << 2 must not overflow
206  av_log(smk->avctx, AV_LOG_ERROR, "size too large\n");
207  return AVERROR_INVALIDDATA;
208  }
209 
210  for (int i = 0; i < 2; i++) {
211  HuffContext h;
212  h.current = 0;
213  if (!get_bits1(gb)) {
214  ctx.vals[i] = 0;
215  av_log(smk->avctx, AV_LOG_ERROR, "Skipping %s bytes tree\n",
216  i ? "high" : "low");
217  continue;
218  }
219  err = smacker_decode_tree(gb, &h, 0);
220  if (err < 0)
221  goto error;
222  skip_bits1(gb);
223  if (h.current > 1) {
224  err = ff_init_vlc_from_lengths(&vlc[i], SMKTREE_BITS, h.current,
225  &h.entries[0].length, sizeof(*h.entries),
226  &h.entries[0].value, sizeof(*h.entries), 1,
227  0, INIT_VLC_OUTPUT_LE, smk->avctx);
228  if (err < 0) {
229  av_log(smk->avctx, AV_LOG_ERROR, "Cannot build VLC table\n");
230  goto error;
231  }
232  } else
233  ctx.vals[i] = h.entries[0].value;
234  }
235 
236  escapes[0] = get_bits(gb, 16);
237  escapes[1] = get_bits(gb, 16);
238  escapes[2] = get_bits(gb, 16);
239 
240  last[0] = last[1] = last[2] = -1;
241 
242  ctx.escapes[0] = escapes[0];
243  ctx.escapes[1] = escapes[1];
244  ctx.escapes[2] = escapes[2];
245  ctx.v1 = &vlc[0];
246  ctx.v2 = &vlc[1];
247  ctx.last = last;
248  ctx.length = (size + 3) >> 2;
249  ctx.current = 0;
250  ctx.values = av_malloc_array(ctx.length + 3, sizeof(ctx.values[0]));
251  if (!ctx.values) {
252  err = AVERROR(ENOMEM);
253  goto error;
254  }
255  *recodes = ctx.values;
256 
257  err = smacker_decode_bigtree(gb, &ctx, 0);
258  if (err < 0)
259  goto error;
260  skip_bits1(gb);
261  if (ctx.last[0] == -1) ctx.last[0] = ctx.current++;
262  if (ctx.last[1] == -1) ctx.last[1] = ctx.current++;
263  if (ctx.last[2] == -1) ctx.last[2] = ctx.current++;
264 
265  err = 0;
266 error:
267  for (int i = 0; i < 2; i++) {
268  ff_free_vlc(&vlc[i]);
269  }
270 
271  return err;
272 }
273 
275  GetBitContext gb;
276  int mmap_size, mclr_size, full_size, type_size, ret;
277  int skip = 0;
278 
279  mmap_size = AV_RL32(smk->avctx->extradata);
280  mclr_size = AV_RL32(smk->avctx->extradata + 4);
281  full_size = AV_RL32(smk->avctx->extradata + 8);
282  type_size = AV_RL32(smk->avctx->extradata + 12);
283 
284  ret = init_get_bits8(&gb, smk->avctx->extradata + 16, smk->avctx->extradata_size - 16);
285  if (ret < 0)
286  return ret;
287 
288  if(!get_bits1(&gb)) {
289  skip ++;
290  av_log(smk->avctx, AV_LOG_INFO, "Skipping MMAP tree\n");
291  smk->mmap_tbl = av_malloc(sizeof(int) * 2);
292  if (!smk->mmap_tbl)
293  return AVERROR(ENOMEM);
294  smk->mmap_tbl[0] = 0;
295  smk->mmap_last[0] = smk->mmap_last[1] = smk->mmap_last[2] = 1;
296  } else {
297  ret = smacker_decode_header_tree(smk, &gb, &smk->mmap_tbl, smk->mmap_last, mmap_size);
298  if (ret < 0)
299  return ret;
300  }
301  if(!get_bits1(&gb)) {
302  skip ++;
303  av_log(smk->avctx, AV_LOG_INFO, "Skipping MCLR tree\n");
304  smk->mclr_tbl = av_malloc(sizeof(int) * 2);
305  if (!smk->mclr_tbl)
306  return AVERROR(ENOMEM);
307  smk->mclr_tbl[0] = 0;
308  smk->mclr_last[0] = smk->mclr_last[1] = smk->mclr_last[2] = 1;
309  } else {
310  ret = smacker_decode_header_tree(smk, &gb, &smk->mclr_tbl, smk->mclr_last, mclr_size);
311  if (ret < 0)
312  return ret;
313  }
314  if(!get_bits1(&gb)) {
315  skip ++;
316  av_log(smk->avctx, AV_LOG_INFO, "Skipping FULL tree\n");
317  smk->full_tbl = av_malloc(sizeof(int) * 2);
318  if (!smk->full_tbl)
319  return AVERROR(ENOMEM);
320  smk->full_tbl[0] = 0;
321  smk->full_last[0] = smk->full_last[1] = smk->full_last[2] = 1;
322  } else {
323  ret = smacker_decode_header_tree(smk, &gb, &smk->full_tbl, smk->full_last, full_size);
324  if (ret < 0)
325  return ret;
326  }
327  if(!get_bits1(&gb)) {
328  skip ++;
329  av_log(smk->avctx, AV_LOG_INFO, "Skipping TYPE tree\n");
330  smk->type_tbl = av_malloc(sizeof(int) * 2);
331  if (!smk->type_tbl)
332  return AVERROR(ENOMEM);
333  smk->type_tbl[0] = 0;
334  smk->type_last[0] = smk->type_last[1] = smk->type_last[2] = 1;
335  } else {
336  ret = smacker_decode_header_tree(smk, &gb, &smk->type_tbl, smk->type_last, type_size);
337  if (ret < 0)
338  return ret;
339  }
340  if (skip == 4 || get_bits_left(&gb) < 0)
341  return AVERROR_INVALIDDATA;
342 
343  return 0;
344 }
345 
346 static av_always_inline void last_reset(int *recode, int *last) {
347  recode[last[0]] = recode[last[1]] = recode[last[2]] = 0;
348 }
349 
350 /* Get code and update history.
351  * Checks before reading, does not overread. */
352 static av_always_inline int smk_get_code(GetBitContext *gb, int *recode, int *last) {
353  register int *table = recode;
354  int v;
355 
356  while(*table & SMK_NODE) {
357  if (get_bits_left(gb) < 1)
358  return AVERROR_INVALIDDATA;
359  if(get_bits1(gb))
360  table += (*table) & (~SMK_NODE);
361  table++;
362  }
363  v = *table;
364 
365  if(v != recode[last[0]]) {
366  recode[last[2]] = recode[last[1]];
367  recode[last[1]] = recode[last[0]];
368  recode[last[0]] = v;
369  }
370  return v;
371 }
372 
373 static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
374  AVPacket *avpkt)
375 {
376  SmackVContext * const smk = avctx->priv_data;
377  uint8_t *out;
378  uint32_t *pal;
379  GetByteContext gb2;
380  GetBitContext gb;
381  int blocks, blk, bw, bh;
382  int i, ret;
383  int stride;
384  int flags;
385 
386  if (avpkt->size <= 769)
387  return AVERROR_INVALIDDATA;
388 
389  if ((ret = ff_reget_buffer(avctx, smk->pic, 0)) < 0)
390  return ret;
391 
392  /* make the palette available on the way out */
393  pal = (uint32_t*)smk->pic->data[1];
394  bytestream2_init(&gb2, avpkt->data, avpkt->size);
395  flags = bytestream2_get_byteu(&gb2);
396  smk->pic->palette_has_changed = flags & 1;
397  smk->pic->key_frame = !!(flags & 2);
398  if (smk->pic->key_frame)
400  else
402 
403  for(i = 0; i < 256; i++)
404  *pal++ = 0xFFU << 24 | bytestream2_get_be24u(&gb2);
405 
406  last_reset(smk->mmap_tbl, smk->mmap_last);
407  last_reset(smk->mclr_tbl, smk->mclr_last);
408  last_reset(smk->full_tbl, smk->full_last);
409  last_reset(smk->type_tbl, smk->type_last);
410  if ((ret = init_get_bits8(&gb, avpkt->data + 769, avpkt->size - 769)) < 0)
411  return ret;
412 
413  blk = 0;
414  bw = avctx->width >> 2;
415  bh = avctx->height >> 2;
416  blocks = bw * bh;
417  stride = smk->pic->linesize[0];
418  while(blk < blocks) {
419  int type, run, mode;
420  uint16_t pix;
421 
422  type = smk_get_code(&gb, smk->type_tbl, smk->type_last);
423  if (type < 0)
424  return type;
425  run = block_runs[(type >> 2) & 0x3F];
426  switch(type & 3){
427  case SMK_BLK_MONO:
428  while(run-- && blk < blocks){
429  int clr, map;
430  int hi, lo;
431  clr = smk_get_code(&gb, smk->mclr_tbl, smk->mclr_last);
432  map = smk_get_code(&gb, smk->mmap_tbl, smk->mmap_last);
433  out = smk->pic->data[0] + (blk / bw) * (stride * 4) + (blk % bw) * 4;
434  hi = clr >> 8;
435  lo = clr & 0xFF;
436  for(i = 0; i < 4; i++) {
437  if(map & 1) out[0] = hi; else out[0] = lo;
438  if(map & 2) out[1] = hi; else out[1] = lo;
439  if(map & 4) out[2] = hi; else out[2] = lo;
440  if(map & 8) out[3] = hi; else out[3] = lo;
441  map >>= 4;
442  out += stride;
443  }
444  blk++;
445  }
446  break;
447  case SMK_BLK_FULL:
448  mode = 0;
449  if(avctx->codec_tag == MKTAG('S', 'M', 'K', '4')) { // In case of Smacker v4 we have three modes
450  if (get_bits_left(&gb) < 1)
451  return AVERROR_INVALIDDATA;
452  if(get_bits1(&gb)) mode = 1;
453  else if(get_bits1(&gb)) mode = 2;
454  }
455  while(run-- && blk < blocks){
456  out = smk->pic->data[0] + (blk / bw) * (stride * 4) + (blk % bw) * 4;
457  switch(mode){
458  case 0:
459  for(i = 0; i < 4; i++) {
460  pix = smk_get_code(&gb, smk->full_tbl, smk->full_last);
461  AV_WL16(out+2,pix);
462  pix = smk_get_code(&gb, smk->full_tbl, smk->full_last);
463  AV_WL16(out,pix);
464  out += stride;
465  }
466  break;
467  case 1:
468  pix = smk_get_code(&gb, smk->full_tbl, smk->full_last);
469  out[0] = out[1] = pix & 0xFF;
470  out[2] = out[3] = pix >> 8;
471  out += stride;
472  out[0] = out[1] = pix & 0xFF;
473  out[2] = out[3] = pix >> 8;
474  out += stride;
475  pix = smk_get_code(&gb, smk->full_tbl, smk->full_last);
476  out[0] = out[1] = pix & 0xFF;
477  out[2] = out[3] = pix >> 8;
478  out += stride;
479  out[0] = out[1] = pix & 0xFF;
480  out[2] = out[3] = pix >> 8;
481  break;
482  case 2:
483  for(i = 0; i < 2; i++) {
484  uint16_t pix1, pix2;
485  pix2 = smk_get_code(&gb, smk->full_tbl, smk->full_last);
486  pix1 = smk_get_code(&gb, smk->full_tbl, smk->full_last);
487  AV_WL16(out,pix1);
488  AV_WL16(out+2,pix2);
489  out += stride;
490  AV_WL16(out,pix1);
491  AV_WL16(out+2,pix2);
492  out += stride;
493  }
494  break;
495  }
496  blk++;
497  }
498  break;
499  case SMK_BLK_SKIP:
500  while(run-- && blk < blocks)
501  blk++;
502  break;
503  case SMK_BLK_FILL:
504  mode = type >> 8;
505  while(run-- && blk < blocks){
506  uint32_t col;
507  out = smk->pic->data[0] + (blk / bw) * (stride * 4) + (blk % bw) * 4;
508  col = mode * 0x01010101U;
509  for(i = 0; i < 4; i++) {
510  *((uint32_t*)out) = col;
511  out += stride;
512  }
513  blk++;
514  }
515  break;
516  }
517 
518  }
519 
520  if ((ret = av_frame_ref(data, smk->pic)) < 0)
521  return ret;
522 
523  *got_frame = 1;
524 
525  /* always report that the buffer was completely consumed */
526  return avpkt->size;
527 }
528 
529 
531 {
532  SmackVContext * const smk = avctx->priv_data;
533 
534  av_freep(&smk->mmap_tbl);
535  av_freep(&smk->mclr_tbl);
536  av_freep(&smk->full_tbl);
537  av_freep(&smk->type_tbl);
538 
539  av_frame_free(&smk->pic);
540 
541  return 0;
542 }
543 
544 
546 {
547  SmackVContext * const c = avctx->priv_data;
548  int ret;
549 
550  c->avctx = avctx;
551 
552  avctx->pix_fmt = AV_PIX_FMT_PAL8;
553 
554  c->pic = av_frame_alloc();
555  if (!c->pic)
556  return AVERROR(ENOMEM);
557 
558  /* decode huffman trees from extradata */
559  if (avctx->extradata_size <= 16){
560  av_log(avctx, AV_LOG_ERROR, "Extradata missing!\n");
561  return AVERROR(EINVAL);
562  }
563 
565  if (ret < 0) {
566  return ret;
567  }
568 
569  return 0;
570 }
571 
572 
574 {
575  if (avctx->channels < 1 || avctx->channels > 2) {
576  av_log(avctx, AV_LOG_ERROR, "invalid number of channels\n");
577  return AVERROR_INVALIDDATA;
578  }
581 
582  return 0;
583 }
584 
585 /**
586  * Decode Smacker audio data
587  */
588 static int smka_decode_frame(AVCodecContext *avctx, void *data,
589  int *got_frame_ptr, AVPacket *avpkt)
590 {
591  AVFrame *frame = data;
592  const uint8_t *buf = avpkt->data;
593  int buf_size = avpkt->size;
594  GetBitContext gb;
595  VLC vlc[4] = { { 0 } };
596  int16_t *samples;
597  uint8_t *samples8;
598  uint8_t values[4];
599  int i, res, ret;
600  int unp_size;
601  int bits, stereo;
602  unsigned pred[2], val;
603 
604  if (buf_size <= 4) {
605  av_log(avctx, AV_LOG_ERROR, "packet is too small\n");
606  return AVERROR_INVALIDDATA;
607  }
608 
609  unp_size = AV_RL32(buf);
610 
611  if (unp_size > (1U<<24)) {
612  av_log(avctx, AV_LOG_ERROR, "packet is too big\n");
613  return AVERROR_INVALIDDATA;
614  }
615 
616  if ((ret = init_get_bits8(&gb, buf + 4, buf_size - 4)) < 0)
617  return ret;
618 
619  if(!get_bits1(&gb)){
620  av_log(avctx, AV_LOG_INFO, "Sound: no data\n");
621  *got_frame_ptr = 0;
622  return 1;
623  }
624  stereo = get_bits1(&gb);
625  bits = get_bits1(&gb);
626  if (stereo ^ (avctx->channels != 1)) {
627  av_log(avctx, AV_LOG_ERROR, "channels mismatch\n");
628  return AVERROR_INVALIDDATA;
629  }
630  if (bits == (avctx->sample_fmt == AV_SAMPLE_FMT_U8)) {
631  av_log(avctx, AV_LOG_ERROR, "sample format mismatch\n");
632  return AVERROR_INVALIDDATA;
633  }
634 
635  /* get output buffer */
636  frame->nb_samples = unp_size / (avctx->channels * (bits + 1));
637  if (unp_size % (avctx->channels * (bits + 1))) {
638  av_log(avctx, AV_LOG_ERROR,
639  "The buffer does not contain an integer number of samples\n");
640  return AVERROR_INVALIDDATA;
641  }
642  if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
643  return ret;
644  samples = (int16_t *)frame->data[0];
645  samples8 = frame->data[0];
646 
647  // Initialize
648  for(i = 0; i < (1 << (bits + stereo)); i++) {
649  HuffContext h;
650  h.current = 0;
651  skip_bits1(&gb);
652  if ((ret = smacker_decode_tree(&gb, &h, 0)) < 0)
653  goto error;
654  skip_bits1(&gb);
655  if (h.current > 1) {
656  ret = ff_init_vlc_from_lengths(&vlc[i], SMKTREE_BITS, h.current,
657  &h.entries[0].length, sizeof(*h.entries),
658  &h.entries[0].value, sizeof(*h.entries), 1,
659  0, INIT_VLC_OUTPUT_LE, avctx);
660  if (ret < 0) {
661  av_log(avctx, AV_LOG_ERROR, "Cannot build VLC table\n");
662  goto error;
663  }
664  } else
665  values[i] = h.entries[0].value;
666  }
667  /* this codec relies on wraparound instead of clipping audio */
668  if(bits) { //decode 16-bit data
669  for(i = stereo; i >= 0; i--)
670  pred[i] = av_bswap16(get_bits(&gb, 16));
671  for(i = 0; i <= stereo; i++)
672  *samples++ = pred[i];
673  for(; i < unp_size / 2; i++) {
674  unsigned idx = 2 * (i & stereo);
675  if (get_bits_left(&gb) < 0) {
677  goto error;
678  }
679  if (vlc[idx].table)
680  res = get_vlc2(&gb, vlc[idx].table, SMKTREE_BITS, 3);
681  else
682  res = values[idx];
683  val = res;
684  if (vlc[++idx].table)
685  res = get_vlc2(&gb, vlc[idx].table, SMKTREE_BITS, 3);
686  else
687  res = values[idx];
688  val |= res << 8;
689  pred[idx / 2] += val;
690  *samples++ = pred[idx / 2];
691  }
692  } else { //8-bit data
693  for(i = stereo; i >= 0; i--)
694  pred[i] = get_bits(&gb, 8);
695  for(i = 0; i <= stereo; i++)
696  *samples8++ = pred[i];
697  for(; i < unp_size; i++) {
698  unsigned idx = i & stereo;
699  if (get_bits_left(&gb) < 0) {
701  goto error;
702  }
703  if (vlc[idx].table)
704  val = get_vlc2(&gb, vlc[idx].table, SMKTREE_BITS, 3);
705  else
706  val = values[idx];
707  pred[idx] += val;
708  *samples8++ = pred[idx];
709  }
710  }
711 
712  *got_frame_ptr = 1;
713  ret = buf_size;
714 
715 error:
716  for(i = 0; i < 4; i++) {
717  ff_free_vlc(&vlc[i]);
718  }
719 
720  return ret;
721 }
722 
724  .name = "smackvid",
725  .long_name = NULL_IF_CONFIG_SMALL("Smacker video"),
726  .type = AVMEDIA_TYPE_VIDEO,
728  .priv_data_size = sizeof(SmackVContext),
729  .init = decode_init,
730  .close = decode_end,
731  .decode = decode_frame,
732  .capabilities = AV_CODEC_CAP_DR1,
734 };
735 
737  .name = "smackaud",
738  .long_name = NULL_IF_CONFIG_SMALL("Smacker audio"),
739  .type = AVMEDIA_TYPE_AUDIO,
741  .init = smka_decode_init,
742  .decode = smka_decode_frame,
743  .capabilities = AV_CODEC_CAP_DR1,
744  .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE,
745 };
error
static void error(const char *err)
Definition: target_bsf_fuzzer.c:30
AVCodec
AVCodec.
Definition: codec.h:197
stride
int stride
Definition: mace.c:144
FF_CODEC_CAP_INIT_THREADSAFE
#define FF_CODEC_CAP_INIT_THREADSAFE
The codec does not modify any global variables in the init function, allowing to call the init functi...
Definition: internal.h:41
init
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:31
get_bits_left
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:849
r
const char * r
Definition: vf_curves.c:116
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
SMK_BLK_FULL
@ SMK_BLK_FULL
Definition: smacker.c:101
AVCodecContext::channel_layout
uint64_t channel_layout
Audio channel layout.
Definition: avcodec.h:1149
HuffContext
Context used for code reconstructing.
Definition: smacker.c:73
out
FILE * out
Definition: movenc.c:54
INIT_VLC_OUTPUT_LE
#define INIT_VLC_OUTPUT_LE
Definition: vlc.h:93
GetByteContext
Definition: bytestream.h:33
SmackVContext::full_last
int full_last[3]
Definition: smacker.c:62
MKTAG
#define MKTAG(a, b, c, d)
Definition: common.h:478
AV_CH_LAYOUT_MONO
#define AV_CH_LAYOUT_MONO
Definition: channel_layout.h:90
SMK_BLK_SKIP
@ SMK_BLK_SKIP
Definition: smacker.c:102
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:111
smacker_decode_tree
static int smacker_decode_tree(GetBitContext *gb, HuffContext *hc, int length)
Decode local frame tree.
Definition: smacker.c:111
block_runs
static const int block_runs[64]
Definition: smacker.c:89
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:303
internal.h
AVPacket::data
uint8_t * data
Definition: packet.h:365
table
static const uint16_t table[]
Definition: prosumer.c:206
data
const char data[16]
Definition: mxf.c:142
get_vlc2
static av_always_inline int get_vlc2(GetBitContext *s, VLC_TYPE(*table)[2], int bits, int max_depth)
Parse a vlc code.
Definition: get_bits.h:797
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:317
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:31
HuffEntry::value
uint8_t value
Definition: smacker.c:66
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:379
DBCtx::length
int length
Definition: smacker.c:80
U
#define U(x)
Definition: vp56_arith.h:37
SmackVContext
Definition: smacker.c:57
GetBitContext
Definition: get_bits.h:61
AV_CODEC_ID_SMACKAUDIO
@ AV_CODEC_ID_SMACKAUDIO
Definition: codec_id.h:444
SMKTREE_DECODE_BIG_MAX_RECURSION
#define SMKTREE_DECODE_BIG_MAX_RECURSION
Definition: smacker.c:42
AVFrame::key_frame
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:381
val
static double val(void *priv, double ch)
Definition: aeval.c:76
type
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf type
Definition: writing_filters.txt:86
AV_CH_LAYOUT_STEREO
#define AV_CH_LAYOUT_STEREO
Definition: channel_layout.h:91
SmackVContext::mclr_last
int mclr_last[3]
Definition: smacker.c:62
ff_init_vlc_from_lengths
int ff_init_vlc_from_lengths(VLC *vlc_arg, int nb_bits, int nb_codes, const int8_t *lens, int lens_wrap, const void *symbols, int symbols_wrap, int symbols_size, int offset, int flags, void *logctx)
Build VLC decoding tables suitable for use with get_vlc2()
Definition: bitstream.c:370
av_frame_alloc
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:98
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:181
av_cold
#define av_cold
Definition: attributes.h:90
init_get_bits8
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:677
decode_init
static av_cold int decode_init(AVCodecContext *avctx)
Definition: smacker.c:545
decode
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:71
AVCodecContext::extradata_size
int extradata_size
Definition: avcodec.h:603
smka_decode_init
static av_cold int smka_decode_init(AVCodecContext *avctx)
Definition: smacker.c:573
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
bits
uint8_t bits
Definition: vp3data.h:141
ctx
AVFormatContext * ctx
Definition: movenc.c:48
get_bits.h
smka_decode_frame
static int smka_decode_frame(AVCodecContext *avctx, void *data, int *got_frame_ptr, AVPacket *avpkt)
Decode Smacker audio data.
Definition: smacker.c:588
ff_free_vlc
void ff_free_vlc(VLC *vlc)
Definition: bitstream.c:420
blk
#define blk(i)
Definition: sha.c:185
SmackVContext::type_last
int type_last[3]
Definition: smacker.c:62
HuffContext::entries
HuffEntry entries[256]
Definition: smacker.c:75
DBCtx::escapes
int escapes[3]
Definition: smacker.c:84
ff_smackaud_decoder
const AVCodec ff_smackaud_decoder
Definition: smacker.c:736
NULL
#define NULL
Definition: coverity.c:32
run
uint8_t run
Definition: svq3.c:203
SmkBlockTypes
SmkBlockTypes
Definition: smacker.c:99
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:274
get_bits1
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:498
mathops.h
HuffEntry::length
uint8_t length
Definition: smacker.c:67
c
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
SMKTREE_DECODE_MAX_RECURSION
#define SMKTREE_DECODE_MAX_RECURSION
Definition: smacker.c:41
smacker_decode_bigtree
static int smacker_decode_bigtree(GetBitContext *gb, DBCtx *ctx, int length)
Decode header tree.
Definition: smacker.c:142
smacker_decode_header_tree
static int smacker_decode_header_tree(SmackVContext *smk, GetBitContext *gb, int **recodes, int *last, int size)
Store large tree as FFmpeg's vlc codes.
Definition: smacker.c:198
ff_get_buffer
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1638
AVFrame::pict_type
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:386
AV_CODEC_CAP_DR1
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:52
AVPacket::size
int size
Definition: packet.h:366
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:117
av_frame_ref
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:326
decode_end
static av_cold int decode_end(AVCodecContext *avctx)
Definition: smacker.c:530
AVCodecContext::sample_fmt
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:1106
size
int size
Definition: twinvq_data.h:10344
SMK_BLK_FILL
@ SMK_BLK_FILL
Definition: smacker.c:103
SmackVContext::avctx
AVCodecContext * avctx
Definition: smacker.c:58
DBCtx::v1
VLC * v1
Definition: smacker.c:82
AV_WL16
#define AV_WL16(p, v)
Definition: intreadwrite.h:412
av_bswap16
#define av_bswap16
Definition: bswap.h:31
skip_bits1
static void skip_bits1(GetBitContext *s)
Definition: get_bits.h:538
AV_LOG_INFO
#define AV_LOG_INFO
Standard information.
Definition: log.h:192
AVCodecContext::channels
int channels
number of audio channels
Definition: avcodec.h:1099
SmackVContext::mmap_tbl
int * mmap_tbl
Definition: smacker.c:61
AVCodecContext::bits_per_coded_sample
int bits_per_coded_sample
bits per sample/pixel from the demuxer (needed for huffyuv).
Definition: avcodec.h:1524
i
int i
Definition: input.c:407
AVCodecContext::extradata
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:602
FF_CODEC_CAP_INIT_CLEANUP
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
Definition: internal.h:49
AV_SAMPLE_FMT_U8
@ AV_SAMPLE_FMT_U8
unsigned 8 bits
Definition: samplefmt.h:60
av_malloc_array
#define av_malloc_array(a, b)
Definition: tableprint_vlc.h:32
av_always_inline
#define av_always_inline
Definition: attributes.h:49
AV_SAMPLE_FMT_S16
@ AV_SAMPLE_FMT_S16
signed 16 bits
Definition: samplefmt.h:61
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:204
DBCtx::values
int * values
Definition: smacker.c:81
AVCodecContext::height
int height
Definition: avcodec.h:674
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:711
avcodec.h
AV_PIX_FMT_PAL8
@ AV_PIX_FMT_PAL8
8 bits with AV_PIX_FMT_RGB32 palette
Definition: pixfmt.h:77
AV_CODEC_ID_SMACKVIDEO
@ AV_CODEC_ID_SMACKVIDEO
Definition: codec_id.h:132
ff_reget_buffer
int ff_reget_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Identical in function to ff_get_buffer(), except it reuses the existing buffer if available.
Definition: decode.c:1745
ret
ret
Definition: filter_design.txt:187
pred
static const float pred[4]
Definition: siprdata.h:259
frame
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
Definition: filter_design.txt:264
DBCtx::v2
VLC * v2
Definition: smacker.c:82
last_reset
static av_always_inline void last_reset(int *recode, int *last)
Definition: smacker.c:346
DBCtx::vals
uint8_t vals[2]
Definition: smacker.c:83
SmackVContext::type_tbl
int * type_tbl
Definition: smacker.c:61
AV_RL32
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:92
AVCodecContext
main external API structure.
Definition: avcodec.h:501
SMKTREE_BITS
#define SMKTREE_BITS
Definition: smacker.c:38
SmackVContext::mclr_tbl
int * mclr_tbl
Definition: smacker.c:61
channel_layout.h
SmackVContext::mmap_last
int mmap_last[3]
Definition: smacker.c:62
AVFrame::palette_has_changed
int palette_has_changed
Tell user application that palette has changed from previous frame.
Definition: frame.h:443
mode
mode
Definition: ebur128.h:83
VLC
Definition: vlc.h:26
SmackVContext::full_tbl
int * full_tbl
Definition: smacker.c:61
HuffContext::current
int current
Definition: smacker.c:74
SmackVContext::pic
AVFrame * pic
Definition: smacker.c:59
DBCtx::last
int * last
Definition: smacker.c:85
HuffEntry
Definition: exr.c:93
values
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return values
Definition: filter_design.txt:263
DBCtx
Definition: smacker.c:79
SMK_BLK_MONO
@ SMK_BLK_MONO
Definition: smacker.c:100
samples
Filter the word “frame” indicates either a video frame or a group of audio samples
Definition: filter_design.txt:8
DBCtx::current
int current
Definition: smacker.c:80
AV_PICTURE_TYPE_P
@ AV_PICTURE_TYPE_P
Predicted.
Definition: avutil.h:275
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
SMK_NODE
#define SMK_NODE
Definition: smacker.c:39
decode_frame
static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: smacker.c:373
map
const VDPAUPixFmtMap * map
Definition: hwcontext_vdpau.c:71
AVCodecContext::codec_tag
unsigned int codec_tag
fourcc (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A').
Definition: avcodec.h:526
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:528
AVPacket
This structure stores compressed data.
Definition: packet.h:342
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
decode_header_trees
static int decode_header_trees(SmackVContext *smk)
Definition: smacker.c:274
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:674
bytestream.h
bytestream2_init
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
Definition: bytestream.h:137
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:561
AVFrame::linesize
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:334
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
ff_smacker_decoder
const AVCodec ff_smacker_decoder
Definition: smacker.c:723
h
h
Definition: vp9dsp_template.c:2038
smk_get_code
static av_always_inline int smk_get_code(GetBitContext *gb, int *recode, int *last)
Definition: smacker.c:352