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 #define BITSTREAM_READER_LE
37 #include "avcodec.h"
38 #include "bytestream.h"
39 #include "get_bits.h"
40 #include "internal.h"
41 #include "mathops.h"
42 
43 #define SMKTREE_BITS 9
44 #define SMK_NODE 0x80000000
45 
46 #define SMKTREE_DECODE_MAX_RECURSION 32
47 #define SMKTREE_DECODE_BIG_MAX_RECURSION 500
48 
49 typedef struct SmackVContext {
52 
54  int mmap_last[3], mclr_last[3], full_last[3], type_last[3];
56 
57 /**
58  * Context used for code reconstructing
59  */
60 typedef struct HuffContext {
61  int length;
62  int maxlength;
63  int current;
64  uint32_t *bits;
65  int *lengths;
66  int *values;
67 } HuffContext;
68 
69 /* common parameters used for decode_bigtree */
70 typedef struct DBCtx {
71  VLC *v1, *v2;
72  int *recode1, *recode2;
73  int escapes[3];
74  int *last;
75  int lcur;
76 } DBCtx;
77 
78 /* possible runs of blocks */
79 static const int block_runs[64] = {
80  1, 2, 3, 4, 5, 6, 7, 8,
81  9, 10, 11, 12, 13, 14, 15, 16,
82  17, 18, 19, 20, 21, 22, 23, 24,
83  25, 26, 27, 28, 29, 30, 31, 32,
84  33, 34, 35, 36, 37, 38, 39, 40,
85  41, 42, 43, 44, 45, 46, 47, 48,
86  49, 50, 51, 52, 53, 54, 55, 56,
87  57, 58, 59, 128, 256, 512, 1024, 2048 };
88 
93  SMK_BLK_FILL = 3 };
94 
95 /**
96  * Decode local frame tree
97  */
98 static int smacker_decode_tree(GetBitContext *gb, HuffContext *hc, uint32_t prefix, int length)
99 {
100  if (length > SMKTREE_DECODE_MAX_RECURSION || length > 3 * SMKTREE_BITS) {
101  av_log(NULL, AV_LOG_ERROR, "Maximum tree recursion level exceeded.\n");
102  return AVERROR_INVALIDDATA;
103  }
104 
105  if(!get_bits1(gb)){ //Leaf
106  if(hc->current >= hc->length){
107  av_log(NULL, AV_LOG_ERROR, "Tree size exceeded!\n");
108  return AVERROR_INVALIDDATA;
109  }
110  if(length){
111  hc->bits[hc->current] = prefix;
112  hc->lengths[hc->current] = length;
113  } else {
114  hc->bits[hc->current] = 0;
115  hc->lengths[hc->current] = 0;
116  }
117  hc->values[hc->current] = get_bits(gb, 8);
118  hc->current++;
119  if(hc->maxlength < length)
120  hc->maxlength = length;
121  return 0;
122  } else { //Node
123  int r;
124  length++;
125  r = smacker_decode_tree(gb, hc, prefix, length);
126  if(r)
127  return r;
128  return smacker_decode_tree(gb, hc, prefix | (1 << (length - 1)), length);
129  }
130 }
131 
132 /**
133  * Decode header tree
134  */
136  DBCtx *ctx, int length)
137 {
138  // Larger length can cause segmentation faults due to too deep recursion.
139  if (length > SMKTREE_DECODE_BIG_MAX_RECURSION) {
140  av_log(NULL, AV_LOG_ERROR, "Maximum bigtree recursion level exceeded.\n");
141  return AVERROR_INVALIDDATA;
142  }
143 
144  if (hc->current + 1 >= hc->length) {
145  av_log(NULL, AV_LOG_ERROR, "Tree size exceeded!\n");
146  return AVERROR_INVALIDDATA;
147  }
148  if(!get_bits1(gb)){ //Leaf
149  int val, i1, i2;
150  i1 = ctx->v1->table ? get_vlc2(gb, ctx->v1->table, SMKTREE_BITS, 3) : 0;
151  i2 = ctx->v2->table ? get_vlc2(gb, ctx->v2->table, SMKTREE_BITS, 3) : 0;
152  if (i1 < 0 || i2 < 0)
153  return AVERROR_INVALIDDATA;
154  val = ctx->recode1[i1] | (ctx->recode2[i2] << 8);
155  if(val == ctx->escapes[0]) {
156  ctx->last[0] = hc->current;
157  val = 0;
158  } else if(val == ctx->escapes[1]) {
159  ctx->last[1] = hc->current;
160  val = 0;
161  } else if(val == ctx->escapes[2]) {
162  ctx->last[2] = hc->current;
163  val = 0;
164  }
165 
166  hc->values[hc->current++] = val;
167  return 1;
168  } else { //Node
169  int r = 0, r_new, t;
170 
171  t = hc->current++;
172  r = smacker_decode_bigtree(gb, hc, ctx, length + 1);
173  if(r < 0)
174  return r;
175  hc->values[t] = SMK_NODE | r;
176  r++;
177  r_new = smacker_decode_bigtree(gb, hc, ctx, length + 1);
178  if (r_new < 0)
179  return r_new;
180  return r + r_new;
181  }
182 }
183 
184 /**
185  * Store large tree as FFmpeg's vlc codes
186  */
187 static int smacker_decode_header_tree(SmackVContext *smk, GetBitContext *gb, int **recodes, int *last, int size)
188 {
189  int res;
190  HuffContext huff;
191  HuffContext tmp1, tmp2;
192  VLC vlc[2] = { { 0 } };
193  int escapes[3];
194  DBCtx ctx;
195  int err = 0;
196 
197  if(size >= UINT_MAX>>4){ // (((size + 3) >> 2) + 3) << 2 must not overflow
198  av_log(smk->avctx, AV_LOG_ERROR, "size too large\n");
199  return AVERROR_INVALIDDATA;
200  }
201 
202  tmp1.length = 256;
203  tmp1.maxlength = 0;
204  tmp1.current = 0;
205  tmp1.bits = av_mallocz(256 * 4);
206  tmp1.lengths = av_mallocz(256 * sizeof(int));
207  tmp1.values = av_mallocz(256 * sizeof(int));
208 
209  tmp2.length = 256;
210  tmp2.maxlength = 0;
211  tmp2.current = 0;
212  tmp2.bits = av_mallocz(256 * 4);
213  tmp2.lengths = av_mallocz(256 * sizeof(int));
214  tmp2.values = av_mallocz(256 * sizeof(int));
215  if (!tmp1.bits || !tmp1.lengths || !tmp1.values ||
216  !tmp2.bits || !tmp2.lengths || !tmp2.values) {
217  err = AVERROR(ENOMEM);
218  goto error;
219  }
220 
221  if(get_bits1(gb)) {
222  res = smacker_decode_tree(gb, &tmp1, 0, 0);
223  if (res < 0) {
224  err = res;
225  goto error;
226  }
227  skip_bits1(gb);
228  if(tmp1.current > 1) {
229  res = init_vlc(&vlc[0], SMKTREE_BITS, tmp1.length,
230  tmp1.lengths, sizeof(int), sizeof(int),
231  tmp1.bits, sizeof(uint32_t), sizeof(uint32_t), INIT_VLC_LE);
232  if(res < 0) {
233  av_log(smk->avctx, AV_LOG_ERROR, "Cannot build VLC table\n");
234  err = res;
235  goto error;
236  }
237  }
238  }
239  if (!vlc[0].table) {
240  av_log(smk->avctx, AV_LOG_ERROR, "Skipping low bytes tree\n");
241  }
242  if(get_bits1(gb)){
243  res = smacker_decode_tree(gb, &tmp2, 0, 0);
244  if (res < 0) {
245  err = res;
246  goto error;
247  }
248  skip_bits1(gb);
249  if(tmp2.current > 1) {
250  res = init_vlc(&vlc[1], SMKTREE_BITS, tmp2.length,
251  tmp2.lengths, sizeof(int), sizeof(int),
252  tmp2.bits, sizeof(uint32_t), sizeof(uint32_t), INIT_VLC_LE);
253  if(res < 0) {
254  av_log(smk->avctx, AV_LOG_ERROR, "Cannot build VLC table\n");
255  err = res;
256  goto error;
257  }
258  }
259  }
260  if (!vlc[1].table) {
261  av_log(smk->avctx, AV_LOG_ERROR, "Skipping high bytes tree\n");
262  }
263 
264  escapes[0] = get_bits(gb, 16);
265  escapes[1] = get_bits(gb, 16);
266  escapes[2] = get_bits(gb, 16);
267 
268  last[0] = last[1] = last[2] = -1;
269 
270  ctx.escapes[0] = escapes[0];
271  ctx.escapes[1] = escapes[1];
272  ctx.escapes[2] = escapes[2];
273  ctx.v1 = &vlc[0];
274  ctx.v2 = &vlc[1];
275  ctx.recode1 = tmp1.values;
276  ctx.recode2 = tmp2.values;
277  ctx.last = last;
278 
279  huff.length = ((size + 3) >> 2) + 4;
280  huff.maxlength = 0;
281  huff.current = 0;
282  huff.values = av_mallocz_array(huff.length, sizeof(int));
283  if (!huff.values) {
284  err = AVERROR(ENOMEM);
285  goto error;
286  }
287 
288  res = smacker_decode_bigtree(gb, &huff, &ctx, 0);
289  if (res < 0)
290  err = res;
291  skip_bits1(gb);
292  if(ctx.last[0] == -1) ctx.last[0] = huff.current++;
293  if(ctx.last[1] == -1) ctx.last[1] = huff.current++;
294  if(ctx.last[2] == -1) ctx.last[2] = huff.current++;
295  if (ctx.last[0] >= huff.length ||
296  ctx.last[1] >= huff.length ||
297  ctx.last[2] >= huff.length) {
298  av_log(smk->avctx, AV_LOG_ERROR, "Huffman codes out of range\n");
299  err = AVERROR_INVALIDDATA;
300  }
301 
302  *recodes = huff.values;
303 
304 error:
305  if(vlc[0].table)
306  ff_free_vlc(&vlc[0]);
307  if(vlc[1].table)
308  ff_free_vlc(&vlc[1]);
309  av_free(tmp1.bits);
310  av_free(tmp1.lengths);
311  av_free(tmp1.values);
312  av_free(tmp2.bits);
313  av_free(tmp2.lengths);
314  av_free(tmp2.values);
315 
316  return err;
317 }
318 
320  GetBitContext gb;
321  int mmap_size, mclr_size, full_size, type_size, ret;
322  int skip = 0;
323 
324  mmap_size = AV_RL32(smk->avctx->extradata);
325  mclr_size = AV_RL32(smk->avctx->extradata + 4);
326  full_size = AV_RL32(smk->avctx->extradata + 8);
327  type_size = AV_RL32(smk->avctx->extradata + 12);
328 
329  ret = init_get_bits8(&gb, smk->avctx->extradata + 16, smk->avctx->extradata_size - 16);
330  if (ret < 0)
331  return ret;
332 
333  if(!get_bits1(&gb)) {
334  skip ++;
335  av_log(smk->avctx, AV_LOG_INFO, "Skipping MMAP tree\n");
336  smk->mmap_tbl = av_malloc(sizeof(int) * 2);
337  if (!smk->mmap_tbl)
338  return AVERROR(ENOMEM);
339  smk->mmap_tbl[0] = 0;
340  smk->mmap_last[0] = smk->mmap_last[1] = smk->mmap_last[2] = 1;
341  } else {
342  ret = smacker_decode_header_tree(smk, &gb, &smk->mmap_tbl, smk->mmap_last, mmap_size);
343  if (ret < 0)
344  return ret;
345  }
346  if(!get_bits1(&gb)) {
347  skip ++;
348  av_log(smk->avctx, AV_LOG_INFO, "Skipping MCLR tree\n");
349  smk->mclr_tbl = av_malloc(sizeof(int) * 2);
350  if (!smk->mclr_tbl)
351  return AVERROR(ENOMEM);
352  smk->mclr_tbl[0] = 0;
353  smk->mclr_last[0] = smk->mclr_last[1] = smk->mclr_last[2] = 1;
354  } else {
355  ret = smacker_decode_header_tree(smk, &gb, &smk->mclr_tbl, smk->mclr_last, mclr_size);
356  if (ret < 0)
357  return ret;
358  }
359  if(!get_bits1(&gb)) {
360  skip ++;
361  av_log(smk->avctx, AV_LOG_INFO, "Skipping FULL tree\n");
362  smk->full_tbl = av_malloc(sizeof(int) * 2);
363  if (!smk->full_tbl)
364  return AVERROR(ENOMEM);
365  smk->full_tbl[0] = 0;
366  smk->full_last[0] = smk->full_last[1] = smk->full_last[2] = 1;
367  } else {
368  ret = smacker_decode_header_tree(smk, &gb, &smk->full_tbl, smk->full_last, full_size);
369  if (ret < 0)
370  return ret;
371  }
372  if(!get_bits1(&gb)) {
373  skip ++;
374  av_log(smk->avctx, AV_LOG_INFO, "Skipping TYPE tree\n");
375  smk->type_tbl = av_malloc(sizeof(int) * 2);
376  if (!smk->type_tbl)
377  return AVERROR(ENOMEM);
378  smk->type_tbl[0] = 0;
379  smk->type_last[0] = smk->type_last[1] = smk->type_last[2] = 1;
380  } else {
381  ret = smacker_decode_header_tree(smk, &gb, &smk->type_tbl, smk->type_last, type_size);
382  if (ret < 0)
383  return ret;
384  }
385  if (skip == 4)
386  return AVERROR_INVALIDDATA;
387 
388  return 0;
389 }
390 
391 static av_always_inline void last_reset(int *recode, int *last) {
392  recode[last[0]] = recode[last[1]] = recode[last[2]] = 0;
393 }
394 
395 /* get code and update history */
396 static av_always_inline int smk_get_code(GetBitContext *gb, int *recode, int *last) {
397  register int *table = recode;
398  int v;
399 
400  while(*table & SMK_NODE) {
401  if(get_bits1(gb))
402  table += (*table) & (~SMK_NODE);
403  table++;
404  }
405  v = *table;
406 
407  if(v != recode[last[0]]) {
408  recode[last[2]] = recode[last[1]];
409  recode[last[1]] = recode[last[0]];
410  recode[last[0]] = v;
411  }
412  return v;
413 }
414 
415 static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
416  AVPacket *avpkt)
417 {
418  SmackVContext * const smk = avctx->priv_data;
419  uint8_t *out;
420  uint32_t *pal;
421  GetByteContext gb2;
422  GetBitContext gb;
423  int blocks, blk, bw, bh;
424  int i, ret;
425  int stride;
426  int flags;
427 
428  if (avpkt->size <= 769)
429  return AVERROR_INVALIDDATA;
430 
431  if ((ret = ff_reget_buffer(avctx, smk->pic, 0)) < 0)
432  return ret;
433 
434  /* make the palette available on the way out */
435  pal = (uint32_t*)smk->pic->data[1];
436  bytestream2_init(&gb2, avpkt->data, avpkt->size);
437  flags = bytestream2_get_byteu(&gb2);
438  smk->pic->palette_has_changed = flags & 1;
439  smk->pic->key_frame = !!(flags & 2);
440  if (smk->pic->key_frame)
442  else
444 
445  for(i = 0; i < 256; i++)
446  *pal++ = 0xFFU << 24 | bytestream2_get_be24u(&gb2);
447 
448  last_reset(smk->mmap_tbl, smk->mmap_last);
449  last_reset(smk->mclr_tbl, smk->mclr_last);
450  last_reset(smk->full_tbl, smk->full_last);
451  last_reset(smk->type_tbl, smk->type_last);
452  if ((ret = init_get_bits8(&gb, avpkt->data + 769, avpkt->size - 769)) < 0)
453  return ret;
454 
455  blk = 0;
456  bw = avctx->width >> 2;
457  bh = avctx->height >> 2;
458  blocks = bw * bh;
459  stride = smk->pic->linesize[0];
460  while(blk < blocks) {
461  int type, run, mode;
462  uint16_t pix;
463 
464  type = smk_get_code(&gb, smk->type_tbl, smk->type_last);
465  run = block_runs[(type >> 2) & 0x3F];
466  switch(type & 3){
467  case SMK_BLK_MONO:
468  while(run-- && blk < blocks){
469  int clr, map;
470  int hi, lo;
471  clr = smk_get_code(&gb, smk->mclr_tbl, smk->mclr_last);
472  map = smk_get_code(&gb, smk->mmap_tbl, smk->mmap_last);
473  out = smk->pic->data[0] + (blk / bw) * (stride * 4) + (blk % bw) * 4;
474  hi = clr >> 8;
475  lo = clr & 0xFF;
476  for(i = 0; i < 4; i++) {
477  if(map & 1) out[0] = hi; else out[0] = lo;
478  if(map & 2) out[1] = hi; else out[1] = lo;
479  if(map & 4) out[2] = hi; else out[2] = lo;
480  if(map & 8) out[3] = hi; else out[3] = lo;
481  map >>= 4;
482  out += stride;
483  }
484  blk++;
485  }
486  break;
487  case SMK_BLK_FULL:
488  mode = 0;
489  if(avctx->codec_tag == MKTAG('S', 'M', 'K', '4')) { // In case of Smacker v4 we have three modes
490  if(get_bits1(&gb)) mode = 1;
491  else if(get_bits1(&gb)) mode = 2;
492  }
493  while(run-- && blk < blocks){
494  out = smk->pic->data[0] + (blk / bw) * (stride * 4) + (blk % bw) * 4;
495  switch(mode){
496  case 0:
497  for(i = 0; i < 4; i++) {
498  pix = smk_get_code(&gb, smk->full_tbl, smk->full_last);
499  AV_WL16(out+2,pix);
500  pix = smk_get_code(&gb, smk->full_tbl, smk->full_last);
501  AV_WL16(out,pix);
502  out += stride;
503  }
504  break;
505  case 1:
506  pix = smk_get_code(&gb, smk->full_tbl, smk->full_last);
507  out[0] = out[1] = pix & 0xFF;
508  out[2] = out[3] = pix >> 8;
509  out += stride;
510  out[0] = out[1] = pix & 0xFF;
511  out[2] = out[3] = pix >> 8;
512  out += stride;
513  pix = smk_get_code(&gb, smk->full_tbl, smk->full_last);
514  out[0] = out[1] = pix & 0xFF;
515  out[2] = out[3] = pix >> 8;
516  out += stride;
517  out[0] = out[1] = pix & 0xFF;
518  out[2] = out[3] = pix >> 8;
519  break;
520  case 2:
521  for(i = 0; i < 2; i++) {
522  uint16_t pix1, pix2;
523  pix2 = smk_get_code(&gb, smk->full_tbl, smk->full_last);
524  pix1 = smk_get_code(&gb, smk->full_tbl, smk->full_last);
525  AV_WL16(out,pix1);
526  AV_WL16(out+2,pix2);
527  out += stride;
528  AV_WL16(out,pix1);
529  AV_WL16(out+2,pix2);
530  out += stride;
531  }
532  break;
533  }
534  blk++;
535  }
536  break;
537  case SMK_BLK_SKIP:
538  while(run-- && blk < blocks)
539  blk++;
540  break;
541  case SMK_BLK_FILL:
542  mode = type >> 8;
543  while(run-- && blk < blocks){
544  uint32_t col;
545  out = smk->pic->data[0] + (blk / bw) * (stride * 4) + (blk % bw) * 4;
546  col = mode * 0x01010101U;
547  for(i = 0; i < 4; i++) {
548  *((uint32_t*)out) = col;
549  out += stride;
550  }
551  blk++;
552  }
553  break;
554  }
555 
556  }
557 
558  if ((ret = av_frame_ref(data, smk->pic)) < 0)
559  return ret;
560 
561  *got_frame = 1;
562 
563  /* always report that the buffer was completely consumed */
564  return avpkt->size;
565 }
566 
567 
569 {
570  SmackVContext * const smk = avctx->priv_data;
571 
572  av_freep(&smk->mmap_tbl);
573  av_freep(&smk->mclr_tbl);
574  av_freep(&smk->full_tbl);
575  av_freep(&smk->type_tbl);
576 
577  av_frame_free(&smk->pic);
578 
579  return 0;
580 }
581 
582 
584 {
585  SmackVContext * const c = avctx->priv_data;
586  int ret;
587 
588  c->avctx = avctx;
589 
590  avctx->pix_fmt = AV_PIX_FMT_PAL8;
591 
592  c->pic = av_frame_alloc();
593  if (!c->pic)
594  return AVERROR(ENOMEM);
595 
596  /* decode huffman trees from extradata */
597  if(avctx->extradata_size < 16){
598  av_log(avctx, AV_LOG_ERROR, "Extradata missing!\n");
599  decode_end(avctx);
600  return AVERROR(EINVAL);
601  }
602 
603  ret = decode_header_trees(c);
604  if (ret < 0) {
605  decode_end(avctx);
606  return ret;
607  }
608 
609  return 0;
610 }
611 
612 
614 {
615  if (avctx->channels < 1 || avctx->channels > 2) {
616  av_log(avctx, AV_LOG_ERROR, "invalid number of channels\n");
617  return AVERROR_INVALIDDATA;
618  }
621 
622  return 0;
623 }
624 
625 /**
626  * Decode Smacker audio data
627  */
629  int *got_frame_ptr, AVPacket *avpkt)
630 {
631  AVFrame *frame = data;
632  const uint8_t *buf = avpkt->data;
633  int buf_size = avpkt->size;
634  GetBitContext gb;
635  HuffContext h[4] = { { 0 } };
636  VLC vlc[4] = { { 0 } };
637  int16_t *samples;
638  uint8_t *samples8;
639  int val;
640  int i, res, ret;
641  int unp_size;
642  int bits, stereo;
643  int pred[2] = {0, 0};
644 
645  if (buf_size <= 4) {
646  av_log(avctx, AV_LOG_ERROR, "packet is too small\n");
647  return AVERROR_INVALIDDATA;
648  }
649 
650  unp_size = AV_RL32(buf);
651 
652  if (unp_size > (1U<<24)) {
653  av_log(avctx, AV_LOG_ERROR, "packet is too big\n");
654  return AVERROR_INVALIDDATA;
655  }
656 
657  if ((ret = init_get_bits8(&gb, buf + 4, buf_size - 4)) < 0)
658  return ret;
659 
660  if(!get_bits1(&gb)){
661  av_log(avctx, AV_LOG_INFO, "Sound: no data\n");
662  *got_frame_ptr = 0;
663  return 1;
664  }
665  stereo = get_bits1(&gb);
666  bits = get_bits1(&gb);
667  if (stereo ^ (avctx->channels != 1)) {
668  av_log(avctx, AV_LOG_ERROR, "channels mismatch\n");
669  return AVERROR_INVALIDDATA;
670  }
671  if (bits == (avctx->sample_fmt == AV_SAMPLE_FMT_U8)) {
672  av_log(avctx, AV_LOG_ERROR, "sample format mismatch\n");
673  return AVERROR_INVALIDDATA;
674  }
675 
676  /* get output buffer */
677  frame->nb_samples = unp_size / (avctx->channels * (bits + 1));
678  if (unp_size % (avctx->channels * (bits + 1))) {
679  av_log(avctx, AV_LOG_ERROR,
680  "The buffer does not contain an integer number of samples\n");
681  return AVERROR_INVALIDDATA;
682  }
683  if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
684  return ret;
685  samples = (int16_t *)frame->data[0];
686  samples8 = frame->data[0];
687 
688  // Initialize
689  for(i = 0; i < (1 << (bits + stereo)); i++) {
690  h[i].length = 256;
691  h[i].maxlength = 0;
692  h[i].current = 0;
693  h[i].bits = av_mallocz(256 * 4);
694  h[i].lengths = av_mallocz(256 * sizeof(int));
695  h[i].values = av_mallocz(256 * sizeof(int));
696  if (!h[i].bits || !h[i].lengths || !h[i].values) {
697  ret = AVERROR(ENOMEM);
698  goto error;
699  }
700  skip_bits1(&gb);
701  if (smacker_decode_tree(&gb, &h[i], 0, 0) < 0) {
702  ret = AVERROR_INVALIDDATA;
703  goto error;
704  }
705  skip_bits1(&gb);
706  if(h[i].current > 1) {
707  res = init_vlc(&vlc[i], SMKTREE_BITS, h[i].length,
708  h[i].lengths, sizeof(int), sizeof(int),
709  h[i].bits, sizeof(uint32_t), sizeof(uint32_t), INIT_VLC_LE);
710  if(res < 0) {
711  av_log(avctx, AV_LOG_ERROR, "Cannot build VLC table\n");
712  ret = AVERROR_INVALIDDATA;
713  goto error;
714  }
715  }
716  }
717  /* this codec relies on wraparound instead of clipping audio */
718  if(bits) { //decode 16-bit data
719  for(i = stereo; i >= 0; i--)
720  pred[i] = sign_extend(av_bswap16(get_bits(&gb, 16)), 16);
721  for(i = 0; i <= stereo; i++)
722  *samples++ = pred[i];
723  for(; i < unp_size / 2; i++) {
724  if (get_bits_left(&gb) < 0) {
725  ret = AVERROR_INVALIDDATA;
726  goto error;
727  }
728  if(i & stereo) {
729  if(vlc[2].table)
730  res = get_vlc2(&gb, vlc[2].table, SMKTREE_BITS, 3);
731  else
732  res = 0;
733  if (res < 0) {
734  av_log(avctx, AV_LOG_ERROR, "invalid vlc\n");
735  ret = AVERROR_INVALIDDATA;
736  goto error;
737  }
738  val = h[2].values[res];
739  if(vlc[3].table)
740  res = get_vlc2(&gb, vlc[3].table, SMKTREE_BITS, 3);
741  else
742  res = 0;
743  if (res < 0) {
744  av_log(avctx, AV_LOG_ERROR, "invalid vlc\n");
745  ret = AVERROR_INVALIDDATA;
746  goto error;
747  }
748  val |= h[3].values[res] << 8;
749  pred[1] += sign_extend(val, 16);
750  *samples++ = pred[1];
751  } else {
752  if(vlc[0].table)
753  res = get_vlc2(&gb, vlc[0].table, SMKTREE_BITS, 3);
754  else
755  res = 0;
756  if (res < 0) {
757  av_log(avctx, AV_LOG_ERROR, "invalid vlc\n");
758  ret = AVERROR_INVALIDDATA;
759  goto error;
760  }
761  val = h[0].values[res];
762  if(vlc[1].table)
763  res = get_vlc2(&gb, vlc[1].table, SMKTREE_BITS, 3);
764  else
765  res = 0;
766  if (res < 0) {
767  av_log(avctx, AV_LOG_ERROR, "invalid vlc\n");
768  ret = AVERROR_INVALIDDATA;
769  goto error;
770  }
771  val |= h[1].values[res] << 8;
772  pred[0] += sign_extend(val, 16);
773  *samples++ = pred[0];
774  }
775  }
776  } else { //8-bit data
777  for(i = stereo; i >= 0; i--)
778  pred[i] = get_bits(&gb, 8);
779  for(i = 0; i <= stereo; i++)
780  *samples8++ = pred[i];
781  for(; i < unp_size; i++) {
782  if (get_bits_left(&gb) < 0) {
783  ret = AVERROR_INVALIDDATA;
784  goto error;
785  }
786  if(i & stereo){
787  if(vlc[1].table)
788  res = get_vlc2(&gb, vlc[1].table, SMKTREE_BITS, 3);
789  else
790  res = 0;
791  if (res < 0) {
792  av_log(avctx, AV_LOG_ERROR, "invalid vlc\n");
793  ret = AVERROR_INVALIDDATA;
794  goto error;
795  }
796  pred[1] += sign_extend(h[1].values[res], 8);
797  *samples8++ = pred[1];
798  } else {
799  if(vlc[0].table)
800  res = get_vlc2(&gb, vlc[0].table, SMKTREE_BITS, 3);
801  else
802  res = 0;
803  if (res < 0) {
804  av_log(avctx, AV_LOG_ERROR, "invalid vlc\n");
805  ret = AVERROR_INVALIDDATA;
806  goto error;
807  }
808  pred[0] += sign_extend(h[0].values[res], 8);
809  *samples8++ = pred[0];
810  }
811  }
812  }
813 
814  *got_frame_ptr = 1;
815  ret = buf_size;
816 
817 error:
818  for(i = 0; i < 4; i++) {
819  if(vlc[i].table)
820  ff_free_vlc(&vlc[i]);
821  av_free(h[i].bits);
822  av_free(h[i].lengths);
823  av_free(h[i].values);
824  }
825 
826  return ret;
827 }
828 
830  .name = "smackvid",
831  .long_name = NULL_IF_CONFIG_SMALL("Smacker video"),
832  .type = AVMEDIA_TYPE_VIDEO,
834  .priv_data_size = sizeof(SmackVContext),
835  .init = decode_init,
836  .close = decode_end,
837  .decode = decode_frame,
838  .capabilities = AV_CODEC_CAP_DR1,
839 };
840 
842  .name = "smackaud",
843  .long_name = NULL_IF_CONFIG_SMALL("Smacker audio"),
844  .type = AVMEDIA_TYPE_AUDIO,
846  .init = smka_decode_init,
847  .decode = smka_decode_frame,
848  .capabilities = AV_CODEC_CAP_DR1,
849 };
static int smacker_decode_bigtree(GetBitContext *gb, HuffContext *hc, DBCtx *ctx, int length)
Decode header tree.
Definition: smacker.c:135
static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: smacker.c:415
int type_last[3]
Definition: smacker.c:54
#define NULL
Definition: coverity.c:32
const char const char void * val
Definition: avisynth_c.h:863
#define SMK_NODE
Definition: smacker.c:44
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
This structure describes decoded (raw) audio or video data.
Definition: frame.h:295
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:100
int lcur
Definition: smacker.c:75
static const int block_runs[64]
Definition: smacker.c:79
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:379
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
int current
Definition: smacker.c:63
int length
Definition: smacker.c:61
int * recode1
Definition: smacker.c:72
int * recode2
Definition: smacker.c:72
int size
Definition: avcodec.h:1481
#define av_bswap16
Definition: bswap.h:31
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1778
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
Definition: bytestream.h:133
GLint GLenum type
Definition: opengl_enc.c:104
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:236
uint8_t run
Definition: svq3.c:206
#define AV_CH_LAYOUT_STEREO
#define blk(i)
Definition: sha.c:185
static av_cold int decode_init(AVCodecContext *avctx)
Definition: smacker.c:583
AVCodec.
Definition: avcodec.h:3492
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:71
int escapes[3]
Definition: smacker.c:73
VLC * v2
Definition: smacker.c:71
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:2236
uint8_t
#define av_cold
Definition: attributes.h:82
#define av_malloc(s)
AV_SAMPLE_FMT_U8
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:189
VLC * v1
Definition: smacker.c:71
8 bits with AV_PIX_FMT_RGB32 palette
Definition: pixfmt.h:77
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
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:443
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:1669
static av_cold int smka_decode_init(AVCodecContext *avctx)
Definition: smacker.c:613
Definition: smacker.c:70
uint8_t * data
Definition: avcodec.h:1480
int maxlength
Definition: smacker.c:62
bitstream reader API header.
#define SMKTREE_DECODE_BIG_MAX_RECURSION
Definition: smacker.c:47
ptrdiff_t size
Definition: opengl_enc.c:100
int bits_per_coded_sample
bits per sample/pixel from the demuxer (needed for huffyuv).
Definition: avcodec.h:2792
#define av_log(a,...)
static const uint16_t table[]
Definition: prosumer.c:206
int * type_tbl
Definition: smacker.c:53
int full_last[3]
Definition: smacker.c:54
#define U(x)
Definition: vp56_arith.h:37
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:849
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
AVCodec ff_smacker_decoder
Definition: smacker.c:829
#define init_vlc(vlc, nb_bits, nb_codes,bits, bits_wrap, bits_size,codes, codes_wrap, codes_size,flags)
Definition: vlc.h:38
#define SMKTREE_DECODE_MAX_RECURSION
Definition: smacker.c:46
SmkBlockTypes
Definition: smacker.c:89
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:202
static int smacker_decode_tree(GetBitContext *gb, HuffContext *hc, uint32_t prefix, int length)
Decode local frame tree.
Definition: smacker.c:98
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:186
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:2015
const char * r
Definition: vf_curves.c:114
GLsizei GLsizei * length
Definition: opengl_enc.c:114
const char * name
Name of the codec implementation.
Definition: avcodec.h:3499
uint8_t bits
Definition: vp3data.h:202
AVFrame * pic
Definition: smacker.c:51
int * mmap_tbl
Definition: smacker.c:53
Definition: vlc.h:26
uint64_t channel_layout
Audio channel layout.
Definition: avcodec.h:2279
static int smka_decode_frame(AVCodecContext *avctx, void *data, int *got_frame_ptr, AVPacket *avpkt)
Decode Smacker audio data.
Definition: smacker.c:628
audio channel layout utility functions
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:378
int mmap_last[3]
Definition: smacker.c:54
int width
picture width / height.
Definition: avcodec.h:1741
Context used for code reconstructing.
Definition: smacker.c:60
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
AVFormatContext * ctx
Definition: movenc.c:48
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
static av_cold int decode_end(AVCodecContext *avctx)
Definition: smacker.c:568
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
static void error(const char *err)
int * mclr_tbl
Definition: smacker.c:53
#define INIT_VLC_LE
Definition: vlc.h:54
static int smacker_decode_header_tree(SmackVContext *smk, GetBitContext *gb, int **recodes, int *last, int size)
Store large tree as FFmpeg&#39;s vlc codes.
Definition: smacker.c:187
static const float pred[4]
Definition: siprdata.h:259
int * full_tbl
Definition: smacker.c:53
#define AV_LOG_INFO
Standard information.
Definition: log.h:187
Libavcodec external API header.
AVCodec ff_smackaud_decoder
Definition: smacker.c:841
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:326
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:677
main external API structure.
Definition: avcodec.h:1568
unsigned int codec_tag
fourcc (LSB first, so "ABCD" -> (&#39;D&#39;<<24) + (&#39;C&#39;<<16) + (&#39;B&#39;<<8) + &#39;A&#39;).
Definition: avcodec.h:1593
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1968
void * buf
Definition: avisynth_c.h:766
int extradata_size
Definition: avcodec.h:1670
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:498
static void skip_bits1(GetBitContext *s)
Definition: get_bits.h:538
int palette_has_changed
Tell user application that palette has changed from previous frame.
Definition: frame.h:452
const VDPAUPixFmtMap * map
int * last
Definition: smacker.c:74
static av_const int sign_extend(int val, unsigned bits)
Definition: mathops.h:130
#define flags(name, subs,...)
Definition: cbs_av1.c:561
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:309
int * lengths
Definition: smacker.c:65
AVCodecContext * avctx
Definition: smacker.c:50
common internal api header.
uint32_t * bits
Definition: smacker.c:64
signed 16 bits
Definition: samplefmt.h:61
#define AV_WL16(p, v)
Definition: intreadwrite.h:412
static av_always_inline int smk_get_code(GetBitContext *gb, int *recode, int *last)
Definition: smacker.c:396
#define SMKTREE_BITS
Definition: smacker.c:43
void * priv_data
Definition: avcodec.h:1595
#define av_free(p)
int channels
number of audio channels
Definition: avcodec.h:2229
VLC_TYPE(* table)[2]
code, bits
Definition: vlc.h:28
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:373
int mclr_last[3]
Definition: smacker.c:54
int * values
Definition: smacker.c:66
FILE * out
Definition: movenc.c:54
Filter the word “frame” indicates either a video frame or a group of audio samples
#define av_freep(p)
#define av_always_inline
Definition: attributes.h:39
static int decode_header_trees(SmackVContext *smk)
Definition: smacker.c:319
static av_always_inline void last_reset(int *recode, int *last)
Definition: smacker.c:391
#define stride
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
#define AV_CH_LAYOUT_MONO
#define MKTAG(a, b, c, d)
Definition: common.h:366
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:87
This structure stores compressed data.
Definition: avcodec.h:1457
void ff_free_vlc(VLC *vlc)
Definition: bitstream.c:359
mode
Use these values in ebur128_init (or&#39;ed).
Definition: ebur128.h:83
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:361
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: avcodec.h:984
Predicted.
Definition: avutil.h:275
void * av_mallocz_array(size_t nmemb, size_t size)
Definition: mem.c:191