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 "codec_internal.h"
54 #include "get_bits.h"
55 #include "internal.h"
56 #include "mathops.h"
57 
58 typedef struct SmackVContext {
61 
63  int mmap_last[3], mclr_last[3], full_last[3], type_last[3];
65 
66 typedef struct HuffEntry {
67  uint8_t value;
68  uint8_t length;
69 } HuffEntry;
70 
71 /**
72  * Context used for code reconstructing
73  */
74 typedef struct HuffContext {
75  int current;
77 } HuffContext;
78 
79 /* common parameters used for decode_bigtree */
80 typedef struct DBCtx {
82  int *values;
83  VLC *v1, *v2;
84  uint8_t vals[2];
85  int escapes[3];
86  int *last;
87 } DBCtx;
88 
89 /* possible runs of blocks */
90 static const int block_runs[64] = {
91  1, 2, 3, 4, 5, 6, 7, 8,
92  9, 10, 11, 12, 13, 14, 15, 16,
93  17, 18, 19, 20, 21, 22, 23, 24,
94  25, 26, 27, 28, 29, 30, 31, 32,
95  33, 34, 35, 36, 37, 38, 39, 40,
96  41, 42, 43, 44, 45, 46, 47, 48,
97  49, 50, 51, 52, 53, 54, 55, 56,
98  57, 58, 59, 128, 256, 512, 1024, 2048 };
99 
105 
106 /**
107  * Decode local frame tree
108  *
109  * Can read SMKTREE_DECODE_MAX_RECURSION before the first check;
110  * does not overread gb on success.
111  */
112 static int smacker_decode_tree(GetBitContext *gb, HuffContext *hc, int length)
113 {
114  if (length > SMKTREE_DECODE_MAX_RECURSION || length > 3 * SMKTREE_BITS) {
115  av_log(NULL, AV_LOG_ERROR, "Maximum tree recursion level exceeded.\n");
116  return AVERROR_INVALIDDATA;
117  }
118 
119  if(!get_bits1(gb)){ //Leaf
120  if (hc->current >= 256) {
121  av_log(NULL, AV_LOG_ERROR, "Tree size exceeded!\n");
122  return AVERROR_INVALIDDATA;
123  }
124  if (get_bits_left(gb) < 8)
125  return AVERROR_INVALIDDATA;
126  hc->entries[hc->current++] = (HuffEntry){ get_bits(gb, 8), length };
127  return 0;
128  } else { //Node
129  int r;
130  length++;
131  r = smacker_decode_tree(gb, hc, length);
132  if(r)
133  return r;
134  return smacker_decode_tree(gb, hc, length);
135  }
136 }
137 
138 /**
139  * Decode header tree
140  *
141  * Checks before the first read, can overread by 6 * SMKTREE_BITS on success.
142  */
143 static int smacker_decode_bigtree(GetBitContext *gb, DBCtx *ctx, int length)
144 {
145  // Larger length can cause segmentation faults due to too deep recursion.
146  if (length > SMKTREE_DECODE_BIG_MAX_RECURSION) {
147  av_log(NULL, AV_LOG_ERROR, "Maximum bigtree recursion level exceeded.\n");
148  return AVERROR_INVALIDDATA;
149  }
150 
151  if (ctx->current >= ctx->length) {
152  av_log(NULL, AV_LOG_ERROR, "Tree size exceeded!\n");
153  return AVERROR_INVALIDDATA;
154  }
155  if (get_bits_left(gb) <= 0)
156  return AVERROR_INVALIDDATA;
157  if(!get_bits1(gb)){ //Leaf
158  int val, i1, i2;
159  i1 = ctx->v1->table ? get_vlc2(gb, ctx->v1->table, SMKTREE_BITS, 3)
160  : ctx->vals[0];
161  i2 = ctx->v2->table ? get_vlc2(gb, ctx->v2->table, SMKTREE_BITS, 3)
162  : ctx->vals[1];
163  val = i1 | (i2 << 8);
164  if(val == ctx->escapes[0]) {
165  ctx->last[0] = ctx->current;
166  val = 0;
167  } else if(val == ctx->escapes[1]) {
168  ctx->last[1] = ctx->current;
169  val = 0;
170  } else if(val == ctx->escapes[2]) {
171  ctx->last[2] = ctx->current;
172  val = 0;
173  }
174 
175  ctx->values[ctx->current++] = val;
176  return 1;
177  } else { //Node
178  int r = 0, r_new, t;
179 
180  t = ctx->current++;
181  r = smacker_decode_bigtree(gb, ctx, length + 1);
182  if(r < 0)
183  return r;
184  ctx->values[t] = SMK_NODE | r;
185  r++;
186  r_new = smacker_decode_bigtree(gb, ctx, length + 1);
187  if (r_new < 0)
188  return r_new;
189  return r + r_new;
190  }
191 }
192 
193 /**
194  * Store large tree as FFmpeg's vlc codes
195  *
196  * Can read FFMAX(1 + SMKTREE_DECODE_MAX_RECURSION, 2 + 3 * 16) bits
197  * before the first check; can overread by 6 * SMKTREE_BITS + 1 on success.
198  */
199 static int smacker_decode_header_tree(SmackVContext *smk, GetBitContext *gb, int **recodes, int *last, int size)
200 {
201  VLC vlc[2] = { { 0 } };
202  int escapes[3];
203  DBCtx ctx;
204  int err;
205 
206  if(size >= UINT_MAX>>4){ // (((size + 3) >> 2) + 3) << 2 must not overflow
207  av_log(smk->avctx, AV_LOG_ERROR, "size too large\n");
208  return AVERROR_INVALIDDATA;
209  }
210 
211  for (int i = 0; i < 2; i++) {
212  HuffContext h;
213  h.current = 0;
214  if (!get_bits1(gb)) {
215  ctx.vals[i] = 0;
216  av_log(smk->avctx, AV_LOG_ERROR, "Skipping %s bytes tree\n",
217  i ? "high" : "low");
218  continue;
219  }
220  err = smacker_decode_tree(gb, &h, 0);
221  if (err < 0)
222  goto error;
223  skip_bits1(gb);
224  if (h.current > 1) {
225  err = ff_init_vlc_from_lengths(&vlc[i], SMKTREE_BITS, h.current,
226  &h.entries[0].length, sizeof(*h.entries),
227  &h.entries[0].value, sizeof(*h.entries), 1,
228  0, INIT_VLC_OUTPUT_LE, smk->avctx);
229  if (err < 0) {
230  av_log(smk->avctx, AV_LOG_ERROR, "Cannot build VLC table\n");
231  goto error;
232  }
233  } else
234  ctx.vals[i] = h.entries[0].value;
235  }
236 
237  escapes[0] = get_bits(gb, 16);
238  escapes[1] = get_bits(gb, 16);
239  escapes[2] = get_bits(gb, 16);
240 
241  last[0] = last[1] = last[2] = -1;
242 
243  ctx.escapes[0] = escapes[0];
244  ctx.escapes[1] = escapes[1];
245  ctx.escapes[2] = escapes[2];
246  ctx.v1 = &vlc[0];
247  ctx.v2 = &vlc[1];
248  ctx.last = last;
249  ctx.length = (size + 3) >> 2;
250  ctx.current = 0;
251  ctx.values = av_malloc_array(ctx.length + 3, sizeof(ctx.values[0]));
252  if (!ctx.values) {
253  err = AVERROR(ENOMEM);
254  goto error;
255  }
256  *recodes = ctx.values;
257 
258  err = smacker_decode_bigtree(gb, &ctx, 0);
259  if (err < 0)
260  goto error;
261  skip_bits1(gb);
262  if (ctx.last[0] == -1) ctx.last[0] = ctx.current++;
263  if (ctx.last[1] == -1) ctx.last[1] = ctx.current++;
264  if (ctx.last[2] == -1) ctx.last[2] = ctx.current++;
265 
266  err = 0;
267 error:
268  for (int i = 0; i < 2; i++) {
269  ff_free_vlc(&vlc[i]);
270  }
271 
272  return err;
273 }
274 
276  GetBitContext gb;
277  int mmap_size, mclr_size, full_size, type_size, ret;
278  int skip = 0;
279 
280  mmap_size = AV_RL32(smk->avctx->extradata);
281  mclr_size = AV_RL32(smk->avctx->extradata + 4);
282  full_size = AV_RL32(smk->avctx->extradata + 8);
283  type_size = AV_RL32(smk->avctx->extradata + 12);
284 
285  ret = init_get_bits8(&gb, smk->avctx->extradata + 16, smk->avctx->extradata_size - 16);
286  if (ret < 0)
287  return ret;
288 
289  if(!get_bits1(&gb)) {
290  skip ++;
291  av_log(smk->avctx, AV_LOG_INFO, "Skipping MMAP tree\n");
292  smk->mmap_tbl = av_malloc(sizeof(int) * 2);
293  if (!smk->mmap_tbl)
294  return AVERROR(ENOMEM);
295  smk->mmap_tbl[0] = 0;
296  smk->mmap_last[0] = smk->mmap_last[1] = smk->mmap_last[2] = 1;
297  } else {
298  ret = smacker_decode_header_tree(smk, &gb, &smk->mmap_tbl, smk->mmap_last, mmap_size);
299  if (ret < 0)
300  return ret;
301  }
302  if(!get_bits1(&gb)) {
303  skip ++;
304  av_log(smk->avctx, AV_LOG_INFO, "Skipping MCLR tree\n");
305  smk->mclr_tbl = av_malloc(sizeof(int) * 2);
306  if (!smk->mclr_tbl)
307  return AVERROR(ENOMEM);
308  smk->mclr_tbl[0] = 0;
309  smk->mclr_last[0] = smk->mclr_last[1] = smk->mclr_last[2] = 1;
310  } else {
311  ret = smacker_decode_header_tree(smk, &gb, &smk->mclr_tbl, smk->mclr_last, mclr_size);
312  if (ret < 0)
313  return ret;
314  }
315  if(!get_bits1(&gb)) {
316  skip ++;
317  av_log(smk->avctx, AV_LOG_INFO, "Skipping FULL tree\n");
318  smk->full_tbl = av_malloc(sizeof(int) * 2);
319  if (!smk->full_tbl)
320  return AVERROR(ENOMEM);
321  smk->full_tbl[0] = 0;
322  smk->full_last[0] = smk->full_last[1] = smk->full_last[2] = 1;
323  } else {
324  ret = smacker_decode_header_tree(smk, &gb, &smk->full_tbl, smk->full_last, full_size);
325  if (ret < 0)
326  return ret;
327  }
328  if(!get_bits1(&gb)) {
329  skip ++;
330  av_log(smk->avctx, AV_LOG_INFO, "Skipping TYPE tree\n");
331  smk->type_tbl = av_malloc(sizeof(int) * 2);
332  if (!smk->type_tbl)
333  return AVERROR(ENOMEM);
334  smk->type_tbl[0] = 0;
335  smk->type_last[0] = smk->type_last[1] = smk->type_last[2] = 1;
336  } else {
337  ret = smacker_decode_header_tree(smk, &gb, &smk->type_tbl, smk->type_last, type_size);
338  if (ret < 0)
339  return ret;
340  }
341  if (skip == 4 || get_bits_left(&gb) < 0)
342  return AVERROR_INVALIDDATA;
343 
344  return 0;
345 }
346 
347 static av_always_inline void last_reset(int *recode, int *last) {
348  recode[last[0]] = recode[last[1]] = recode[last[2]] = 0;
349 }
350 
351 /* Get code and update history.
352  * Checks before reading, does not overread. */
353 static av_always_inline int smk_get_code(GetBitContext *gb, int *recode, int *last) {
354  register int *table = recode;
355  int v;
356 
357  while(*table & SMK_NODE) {
358  if (get_bits_left(gb) < 1)
359  return AVERROR_INVALIDDATA;
360  if(get_bits1(gb))
361  table += (*table) & (~SMK_NODE);
362  table++;
363  }
364  v = *table;
365 
366  if(v != recode[last[0]]) {
367  recode[last[2]] = recode[last[1]];
368  recode[last[1]] = recode[last[0]];
369  recode[last[0]] = v;
370  }
371  return v;
372 }
373 
374 static int decode_frame(AVCodecContext *avctx, AVFrame *rframe,
375  int *got_frame, AVPacket *avpkt)
376 {
377  SmackVContext * const smk = avctx->priv_data;
378  uint8_t *out;
379  uint32_t *pal;
380  GetByteContext gb2;
381  GetBitContext gb;
382  int blocks, blk, bw, bh;
383  int i, ret;
384  int stride;
385  int flags;
386 
387  if (avpkt->size <= 769)
388  return AVERROR_INVALIDDATA;
389 
390  if ((ret = ff_reget_buffer(avctx, smk->pic, 0)) < 0)
391  return ret;
392 
393  /* make the palette available on the way out */
394  pal = (uint32_t*)smk->pic->data[1];
395  bytestream2_init(&gb2, avpkt->data, avpkt->size);
396  flags = bytestream2_get_byteu(&gb2);
397  smk->pic->palette_has_changed = flags & 1;
398  smk->pic->key_frame = !!(flags & 2);
399  if (smk->pic->key_frame)
401  else
403 
404  for(i = 0; i < 256; i++)
405  *pal++ = 0xFFU << 24 | bytestream2_get_be24u(&gb2);
406 
407  last_reset(smk->mmap_tbl, smk->mmap_last);
408  last_reset(smk->mclr_tbl, smk->mclr_last);
409  last_reset(smk->full_tbl, smk->full_last);
410  last_reset(smk->type_tbl, smk->type_last);
411  if ((ret = init_get_bits8(&gb, avpkt->data + 769, avpkt->size - 769)) < 0)
412  return ret;
413 
414  blk = 0;
415  bw = avctx->width >> 2;
416  bh = avctx->height >> 2;
417  blocks = bw * bh;
418  stride = smk->pic->linesize[0];
419  while(blk < blocks) {
420  int type, run, mode;
421  uint16_t pix;
422 
423  type = smk_get_code(&gb, smk->type_tbl, smk->type_last);
424  if (type < 0)
425  return type;
426  run = block_runs[(type >> 2) & 0x3F];
427  switch(type & 3){
428  case SMK_BLK_MONO:
429  while(run-- && blk < blocks){
430  int clr, map;
431  int hi, lo;
432  clr = smk_get_code(&gb, smk->mclr_tbl, smk->mclr_last);
433  map = smk_get_code(&gb, smk->mmap_tbl, smk->mmap_last);
434  out = smk->pic->data[0] + (blk / bw) * (stride * 4) + (blk % bw) * 4;
435  hi = clr >> 8;
436  lo = clr & 0xFF;
437  for(i = 0; i < 4; i++) {
438  if(map & 1) out[0] = hi; else out[0] = lo;
439  if(map & 2) out[1] = hi; else out[1] = lo;
440  if(map & 4) out[2] = hi; else out[2] = lo;
441  if(map & 8) out[3] = hi; else out[3] = lo;
442  map >>= 4;
443  out += stride;
444  }
445  blk++;
446  }
447  break;
448  case SMK_BLK_FULL:
449  mode = 0;
450  if(avctx->codec_tag == MKTAG('S', 'M', 'K', '4')) { // In case of Smacker v4 we have three modes
451  if (get_bits_left(&gb) < 1)
452  return AVERROR_INVALIDDATA;
453  if(get_bits1(&gb)) mode = 1;
454  else if(get_bits1(&gb)) mode = 2;
455  }
456  while(run-- && blk < blocks){
457  out = smk->pic->data[0] + (blk / bw) * (stride * 4) + (blk % bw) * 4;
458  switch(mode){
459  case 0:
460  for(i = 0; i < 4; i++) {
461  pix = smk_get_code(&gb, smk->full_tbl, smk->full_last);
462  AV_WL16(out+2,pix);
463  pix = smk_get_code(&gb, smk->full_tbl, smk->full_last);
464  AV_WL16(out,pix);
465  out += stride;
466  }
467  break;
468  case 1:
469  pix = smk_get_code(&gb, smk->full_tbl, smk->full_last);
470  out[0] = out[1] = pix & 0xFF;
471  out[2] = out[3] = pix >> 8;
472  out += stride;
473  out[0] = out[1] = pix & 0xFF;
474  out[2] = out[3] = pix >> 8;
475  out += stride;
476  pix = smk_get_code(&gb, smk->full_tbl, smk->full_last);
477  out[0] = out[1] = pix & 0xFF;
478  out[2] = out[3] = pix >> 8;
479  out += stride;
480  out[0] = out[1] = pix & 0xFF;
481  out[2] = out[3] = pix >> 8;
482  break;
483  case 2:
484  for(i = 0; i < 2; i++) {
485  uint16_t pix1, pix2;
486  pix2 = smk_get_code(&gb, smk->full_tbl, smk->full_last);
487  pix1 = smk_get_code(&gb, smk->full_tbl, smk->full_last);
488  AV_WL16(out,pix1);
489  AV_WL16(out+2,pix2);
490  out += stride;
491  AV_WL16(out,pix1);
492  AV_WL16(out+2,pix2);
493  out += stride;
494  }
495  break;
496  }
497  blk++;
498  }
499  break;
500  case SMK_BLK_SKIP:
501  while(run-- && blk < blocks)
502  blk++;
503  break;
504  case SMK_BLK_FILL:
505  mode = type >> 8;
506  while(run-- && blk < blocks){
507  uint32_t col;
508  out = smk->pic->data[0] + (blk / bw) * (stride * 4) + (blk % bw) * 4;
509  col = mode * 0x01010101U;
510  for(i = 0; i < 4; i++) {
511  *((uint32_t*)out) = col;
512  out += stride;
513  }
514  blk++;
515  }
516  break;
517  }
518 
519  }
520 
521  if ((ret = av_frame_ref(rframe, smk->pic)) < 0)
522  return ret;
523 
524  *got_frame = 1;
525 
526  /* always report that the buffer was completely consumed */
527  return avpkt->size;
528 }
529 
530 
532 {
533  SmackVContext * const smk = avctx->priv_data;
534 
535  av_freep(&smk->mmap_tbl);
536  av_freep(&smk->mclr_tbl);
537  av_freep(&smk->full_tbl);
538  av_freep(&smk->type_tbl);
539 
540  av_frame_free(&smk->pic);
541 
542  return 0;
543 }
544 
545 
547 {
548  SmackVContext * const c = avctx->priv_data;
549  int ret;
550 
551  c->avctx = avctx;
552 
553  avctx->pix_fmt = AV_PIX_FMT_PAL8;
554 
555  c->pic = av_frame_alloc();
556  if (!c->pic)
557  return AVERROR(ENOMEM);
558 
559  /* decode huffman trees from extradata */
560  if (avctx->extradata_size <= 16){
561  av_log(avctx, AV_LOG_ERROR, "Extradata missing!\n");
562  return AVERROR(EINVAL);
563  }
564 
566  if (ret < 0) {
567  return ret;
568  }
569 
570  return 0;
571 }
572 
573 
575 {
576  int channels = avctx->ch_layout.nb_channels;
578  av_log(avctx, AV_LOG_ERROR, "invalid number of channels\n");
579  return AVERROR_INVALIDDATA;
580  }
584 
585  return 0;
586 }
587 
588 /**
589  * Decode Smacker audio data
590  */
592  int *got_frame_ptr, AVPacket *avpkt)
593 {
594  const uint8_t *buf = avpkt->data;
595  int buf_size = avpkt->size;
596  GetBitContext gb;
597  VLC vlc[4] = { { 0 } };
598  int16_t *samples;
599  uint8_t *samples8;
600  uint8_t values[4];
601  int i, res, ret;
602  int unp_size;
603  int bits, stereo;
604  unsigned pred[2], val, val2;
605 
606  if (buf_size <= 4) {
607  av_log(avctx, AV_LOG_ERROR, "packet is too small\n");
608  return AVERROR_INVALIDDATA;
609  }
610 
611  unp_size = AV_RL32(buf);
612 
613  if (unp_size > (1U<<24)) {
614  av_log(avctx, AV_LOG_ERROR, "packet is too big\n");
615  return AVERROR_INVALIDDATA;
616  }
617 
618  if ((ret = init_get_bits8(&gb, buf + 4, buf_size - 4)) < 0)
619  return ret;
620 
621  if(!get_bits1(&gb)){
622  av_log(avctx, AV_LOG_INFO, "Sound: no data\n");
623  *got_frame_ptr = 0;
624  return 1;
625  }
626  stereo = get_bits1(&gb);
627  bits = get_bits1(&gb);
628  if (stereo ^ (avctx->ch_layout.nb_channels != 1)) {
629  av_log(avctx, AV_LOG_ERROR, "channels mismatch\n");
630  return AVERROR_INVALIDDATA;
631  }
632  if (bits == (avctx->sample_fmt == AV_SAMPLE_FMT_U8)) {
633  av_log(avctx, AV_LOG_ERROR, "sample format mismatch\n");
634  return AVERROR_INVALIDDATA;
635  }
636 
637  /* get output buffer */
638  frame->nb_samples = unp_size / (avctx->ch_layout.nb_channels * (bits + 1));
639  if (unp_size % (avctx->ch_layout.nb_channels * (bits + 1))) {
640  av_log(avctx, AV_LOG_ERROR,
641  "The buffer does not contain an integer number of samples\n");
642  return AVERROR_INVALIDDATA;
643  }
644  if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
645  return ret;
646  samples = (int16_t *)frame->data[0];
647  samples8 = frame->data[0];
648 
649  // Initialize
650  for(i = 0; i < (1 << (bits + stereo)); i++) {
651  HuffContext h;
652  h.current = 0;
653  skip_bits1(&gb);
654  if ((ret = smacker_decode_tree(&gb, &h, 0)) < 0)
655  goto error;
656  skip_bits1(&gb);
657  if (h.current > 1) {
658  ret = ff_init_vlc_from_lengths(&vlc[i], SMKTREE_BITS, h.current,
659  &h.entries[0].length, sizeof(*h.entries),
660  &h.entries[0].value, sizeof(*h.entries), 1,
661  0, INIT_VLC_OUTPUT_LE, avctx);
662  if (ret < 0) {
663  av_log(avctx, AV_LOG_ERROR, "Cannot build VLC table\n");
664  goto error;
665  }
666  } else
667  values[i] = h.entries[0].value;
668  }
669  /* this codec relies on wraparound instead of clipping audio */
670  if(bits) { //decode 16-bit data
671  for(i = stereo; i >= 0; i--)
672  pred[i] = av_bswap16(get_bits(&gb, 16));
673  for(i = 0; i <= stereo; i++)
674  *samples++ = pred[i];
675  unp_size /= 2;
676 
677  if (vlc[0 ].table || vlc[ 1].table ||
678  vlc[2*stereo].table || vlc[2*stereo+1].table) {
679  for(; i < unp_size ; i++) {
680  unsigned idx = 2 * (i & stereo);
681  if (get_bits_left(&gb) < 0) {
683  goto error;
684  }
685  if (vlc[idx].table)
686  res = get_vlc2(&gb, vlc[idx].table, SMKTREE_BITS, 3);
687  else
688  res = values[idx];
689  val = res;
690  if (vlc[++idx].table)
691  res = get_vlc2(&gb, vlc[idx].table, SMKTREE_BITS, 3);
692  else
693  res = values[idx];
694  val |= res << 8;
695  pred[idx / 2] += val;
696  *samples++ = pred[idx / 2];
697  }
698  } else if (stereo) {
699  val = 256*values[1] + values[0];
700  val2 = 256*values[3] + values[2];
701  for(; i < unp_size; i+=2) {
702  pred[0] += val;
703  pred[1] += val2;
704  *samples++ = pred[0];
705  *samples++ = pred[1];
706  }
707  } else {
708  val = 256*values[1] + values[0];
709  for(; i < unp_size; i++) {
710  pred[0] += val;
711  *samples++ = pred[0];
712  }
713  }
714  } else { //8-bit data
715  for(i = stereo; i >= 0; i--)
716  pred[i] = get_bits(&gb, 8);
717  for(i = 0; i <= stereo; i++)
718  *samples8++ = pred[i];
719  for(; i < unp_size; i++) {
720  unsigned idx = i & stereo;
721  if (get_bits_left(&gb) < 0) {
723  goto error;
724  }
725  if (vlc[idx].table)
726  val = get_vlc2(&gb, vlc[idx].table, SMKTREE_BITS, 3);
727  else
728  val = values[idx];
729  pred[idx] += val;
730  *samples8++ = pred[idx];
731  }
732  }
733 
734  *got_frame_ptr = 1;
735  ret = buf_size;
736 
737 error:
738  for(i = 0; i < 4; i++) {
739  ff_free_vlc(&vlc[i]);
740  }
741 
742  return ret;
743 }
744 
746  .p.name = "smackvid",
747  .p.long_name = NULL_IF_CONFIG_SMALL("Smacker video"),
748  .p.type = AVMEDIA_TYPE_VIDEO,
749  .p.id = AV_CODEC_ID_SMACKVIDEO,
750  .priv_data_size = sizeof(SmackVContext),
751  .init = decode_init,
752  .close = decode_end,
754  .p.capabilities = AV_CODEC_CAP_DR1,
755  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
756 };
757 
759  .p.name = "smackaud",
760  .p.long_name = NULL_IF_CONFIG_SMALL("Smacker audio"),
761  .p.type = AVMEDIA_TYPE_AUDIO,
762  .p.id = AV_CODEC_ID_SMACKAUDIO,
763  .init = smka_decode_init,
765  .p.capabilities = AV_CODEC_CAP_DR1,
766 };
error
static void error(const char *err)
Definition: target_bsf_fuzzer.c:31
ff_smacker_decoder
const FFCodec ff_smacker_decoder
Definition: smacker.c:745
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: codec_internal.h:41
get_bits_left
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:839
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:102
HuffContext
Context used for code reconstructing.
Definition: smacker.c:74
out
FILE * out
Definition: movenc.c:54
INIT_VLC_OUTPUT_LE
#define INIT_VLC_OUTPUT_LE
Definition: vlc.h:98
GetByteContext
Definition: bytestream.h:33
SmackVContext::full_last
int full_last[3]
Definition: smacker.c:63
SMK_BLK_SKIP
@ SMK_BLK_SKIP
Definition: smacker.c:103
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:116
smacker_decode_tree
static int smacker_decode_tree(GetBitContext *gb, HuffContext *hc, int length)
Decode local frame tree.
Definition: smacker.c:112
block_runs
static const int block_runs[64]
Definition: smacker.c:90
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:325
internal.h
AVPacket::data
uint8_t * data
Definition: packet.h:374
table
static const uint16_t table[]
Definition: prosumer.c:206
FFCodec
Definition: codec_internal.h:118
AVChannelLayout::nb_channels
int nb_channels
Number of channels in this layout.
Definition: channel_layout.h:300
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:346
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:30
HuffEntry::value
uint8_t value
Definition: smacker.c:67
init
static int init
Definition: av_tx.c:47
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:379
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:122
DBCtx::length
int length
Definition: smacker.c:81
ff_smackaud_decoder
const FFCodec ff_smackaud_decoder
Definition: smacker.c:758
AVCodecContext::ch_layout
AVChannelLayout ch_layout
Audio channel layout.
Definition: avcodec.h:2065
SmackVContext
Definition: smacker.c:58
GetBitContext
Definition: get_bits.h:61
AV_CODEC_ID_SMACKAUDIO
@ AV_CODEC_ID_SMACKAUDIO
Definition: codec_id.h:452
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:417
val
static double val(void *priv, double ch)
Definition: aeval.c:77
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
SmackVContext::mclr_last
int mclr_last[3]
Definition: smacker.c:63
av_frame_alloc
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:104
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
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:667
decode_init
static av_cold int decode_init(AVCodecContext *avctx)
Definition: smacker.c:546
AVCodecContext::extradata_size
int extradata_size
Definition: avcodec.h:500
FF_CODEC_DECODE_CB
#define FF_CODEC_DECODE_CB(func)
Definition: codec_internal.h:260
smka_decode_init
static av_cold int smka_decode_init(AVCodecContext *avctx)
Definition: smacker.c:574
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
channels
channels
Definition: aptx.h:32
get_bits.h
blk
#define blk(i)
Definition: sha.c:186
SmackVContext::type_last
int type_last[3]
Definition: smacker.c:63
HuffContext::entries
HuffEntry entries[256]
Definition: smacker.c:76
DBCtx::escapes
int escapes[3]
Definition: smacker.c:85
smka_decode_frame
static int smka_decode_frame(AVCodecContext *avctx, AVFrame *frame, int *got_frame_ptr, AVPacket *avpkt)
Decode Smacker audio data.
Definition: smacker.c:591
NULL
#define NULL
Definition: coverity.c:32
run
uint8_t run
Definition: svq3.c:205
SmkBlockTypes
SmkBlockTypes
Definition: smacker.c:100
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
ff_init_vlc_from_lengths
int ff_init_vlc_from_lengths(VLC *vlc, 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: vlc.c:328
mathops.h
HuffEntry::length
uint8_t length
Definition: smacker.c:68
av_channel_layout_default
void av_channel_layout_default(AVChannelLayout *ch_layout, int nb_channels)
Get the default channel layout for a given number of channels.
Definition: channel_layout.c:960
decode_frame
static int decode_frame(AVCodecContext *avctx, AVFrame *rframe, int *got_frame, AVPacket *avpkt)
Definition: smacker.c:374
get_vlc2
static av_always_inline int get_vlc2(GetBitContext *s, const VLCElem *table, int bits, int max_depth)
Parse a vlc code.
Definition: get_bits.h:787
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
av_channel_layout_uninit
void av_channel_layout_uninit(AVChannelLayout *channel_layout)
Free any allocated data in the channel layout and reset the channel count to 0.
Definition: channel_layout.c:630
smacker_decode_bigtree
static int smacker_decode_bigtree(GetBitContext *gb, DBCtx *ctx, int length)
Decode header tree.
Definition: smacker.c:143
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:199
ff_get_buffer
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1462
AVFrame::pict_type
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:422
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:375
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:353
codec_internal.h
decode_end
static av_cold int decode_end(AVCodecContext *avctx)
Definition: smacker.c:531
AVCodecContext::sample_fmt
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:1023
size
int size
Definition: twinvq_data.h:10344
SMK_BLK_FILL
@ SMK_BLK_FILL
Definition: smacker.c:104
SmackVContext::avctx
AVCodecContext * avctx
Definition: smacker.c:59
DBCtx::v1
VLC * v1
Definition: smacker.c:83
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:191
SmackVContext::mmap_tbl
int * mmap_tbl
Definition: smacker.c:62
AVCodecContext::bits_per_coded_sample
int bits_per_coded_sample
bits per sample/pixel from the demuxer (needed for huffyuv).
Definition: avcodec.h:1450
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
AVCodecContext::extradata
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:499
AV_SAMPLE_FMT_U8
@ AV_SAMPLE_FMT_U8
unsigned 8 bits
Definition: samplefmt.h:57
av_malloc_array
#define av_malloc_array(a, b)
Definition: tableprint_vlc.h:31
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:58
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:211
DBCtx::values
int * values
Definition: smacker.c:82
AVCodecContext::height
int height
Definition: avcodec.h:571
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:608
ff_free_vlc
void ff_free_vlc(VLC *vlc)
Definition: vlc.c:375
avcodec.h
stride
#define stride
Definition: h264pred_template.c:537
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:133
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:1580
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:83
last_reset
static av_always_inline void last_reset(int *recode, int *last)
Definition: smacker.c:347
DBCtx::vals
uint8_t vals[2]
Definition: smacker.c:84
SmackVContext::type_tbl
int * type_tbl
Definition: smacker.c:62
AV_RL32
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:92
U
#define U(x)
Definition: vpx_arith.h:37
AVCodecContext
main external API structure.
Definition: avcodec.h:398
SMKTREE_BITS
#define SMKTREE_BITS
Definition: smacker.c:38
SmackVContext::mclr_tbl
int * mclr_tbl
Definition: smacker.c:62
channel_layout.h
SmackVContext::mmap_last
int mmap_last[3]
Definition: smacker.c:63
AVFrame::palette_has_changed
int palette_has_changed
Tell user application that palette has changed from previous frame.
Definition: frame.h:487
mode
mode
Definition: ebur128.h:83
VLC
Definition: vlc.h:31
SmackVContext::full_tbl
int * full_tbl
Definition: smacker.c:62
HuffContext::current
int current
Definition: smacker.c:75
SmackVContext::pic
AVFrame * pic
Definition: smacker.c:60
DBCtx::last
int * last
Definition: smacker.c:86
HuffEntry
Definition: exr.c:94
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:80
SMK_BLK_MONO
@ SMK_BLK_MONO
Definition: smacker.c:101
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:81
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
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:423
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:425
AVPacket
This structure stores compressed data.
Definition: packet.h:351
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
decode_header_trees
static int decode_header_trees(SmackVContext *smk)
Definition: smacker.c:275
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:571
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, a positive or negative value, which is typically indicating the size in bytes of each pict...
Definition: frame.h:370
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
MKTAG
#define MKTAG(a, b, c, d)
Definition: macros.h:55
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:353