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 
323  mmap_size = AV_RL32(smk->avctx->extradata);
324  mclr_size = AV_RL32(smk->avctx->extradata + 4);
325  full_size = AV_RL32(smk->avctx->extradata + 8);
326  type_size = AV_RL32(smk->avctx->extradata + 12);
327 
328  ret = init_get_bits8(&gb, smk->avctx->extradata + 16, smk->avctx->extradata_size - 16);
329  if (ret < 0)
330  return ret;
331 
332  if(!get_bits1(&gb)) {
333  av_log(smk->avctx, AV_LOG_INFO, "Skipping MMAP tree\n");
334  smk->mmap_tbl = av_malloc(sizeof(int) * 2);
335  if (!smk->mmap_tbl)
336  return AVERROR(ENOMEM);
337  smk->mmap_tbl[0] = 0;
338  smk->mmap_last[0] = smk->mmap_last[1] = smk->mmap_last[2] = 1;
339  } else {
340  ret = smacker_decode_header_tree(smk, &gb, &smk->mmap_tbl, smk->mmap_last, mmap_size);
341  if (ret < 0)
342  return ret;
343  }
344  if(!get_bits1(&gb)) {
345  av_log(smk->avctx, AV_LOG_INFO, "Skipping MCLR tree\n");
346  smk->mclr_tbl = av_malloc(sizeof(int) * 2);
347  if (!smk->mclr_tbl)
348  return AVERROR(ENOMEM);
349  smk->mclr_tbl[0] = 0;
350  smk->mclr_last[0] = smk->mclr_last[1] = smk->mclr_last[2] = 1;
351  } else {
352  ret = smacker_decode_header_tree(smk, &gb, &smk->mclr_tbl, smk->mclr_last, mclr_size);
353  if (ret < 0)
354  return ret;
355  }
356  if(!get_bits1(&gb)) {
357  av_log(smk->avctx, AV_LOG_INFO, "Skipping FULL tree\n");
358  smk->full_tbl = av_malloc(sizeof(int) * 2);
359  if (!smk->full_tbl)
360  return AVERROR(ENOMEM);
361  smk->full_tbl[0] = 0;
362  smk->full_last[0] = smk->full_last[1] = smk->full_last[2] = 1;
363  } else {
364  ret = smacker_decode_header_tree(smk, &gb, &smk->full_tbl, smk->full_last, full_size);
365  if (ret < 0)
366  return ret;
367  }
368  if(!get_bits1(&gb)) {
369  av_log(smk->avctx, AV_LOG_INFO, "Skipping TYPE tree\n");
370  smk->type_tbl = av_malloc(sizeof(int) * 2);
371  if (!smk->type_tbl)
372  return AVERROR(ENOMEM);
373  smk->type_tbl[0] = 0;
374  smk->type_last[0] = smk->type_last[1] = smk->type_last[2] = 1;
375  } else {
376  ret = smacker_decode_header_tree(smk, &gb, &smk->type_tbl, smk->type_last, type_size);
377  if (ret < 0)
378  return ret;
379  }
380 
381  return 0;
382 }
383 
384 static av_always_inline void last_reset(int *recode, int *last) {
385  recode[last[0]] = recode[last[1]] = recode[last[2]] = 0;
386 }
387 
388 /* get code and update history */
389 static av_always_inline int smk_get_code(GetBitContext *gb, int *recode, int *last) {
390  register int *table = recode;
391  int v;
392 
393  while(*table & SMK_NODE) {
394  if(get_bits1(gb))
395  table += (*table) & (~SMK_NODE);
396  table++;
397  }
398  v = *table;
399 
400  if(v != recode[last[0]]) {
401  recode[last[2]] = recode[last[1]];
402  recode[last[1]] = recode[last[0]];
403  recode[last[0]] = v;
404  }
405  return v;
406 }
407 
408 static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
409  AVPacket *avpkt)
410 {
411  SmackVContext * const smk = avctx->priv_data;
412  uint8_t *out;
413  uint32_t *pal;
414  GetByteContext gb2;
415  GetBitContext gb;
416  int blocks, blk, bw, bh;
417  int i, ret;
418  int stride;
419  int flags;
420 
421  if (avpkt->size <= 769)
422  return AVERROR_INVALIDDATA;
423 
424  if ((ret = ff_reget_buffer(avctx, smk->pic)) < 0)
425  return ret;
426 
427  /* make the palette available on the way out */
428  pal = (uint32_t*)smk->pic->data[1];
429  bytestream2_init(&gb2, avpkt->data, avpkt->size);
430  flags = bytestream2_get_byteu(&gb2);
431  smk->pic->palette_has_changed = flags & 1;
432  smk->pic->key_frame = !!(flags & 2);
433  if (smk->pic->key_frame)
435  else
437 
438  for(i = 0; i < 256; i++)
439  *pal++ = 0xFFU << 24 | bytestream2_get_be24u(&gb2);
440 
441  last_reset(smk->mmap_tbl, smk->mmap_last);
442  last_reset(smk->mclr_tbl, smk->mclr_last);
443  last_reset(smk->full_tbl, smk->full_last);
444  last_reset(smk->type_tbl, smk->type_last);
445  if ((ret = init_get_bits8(&gb, avpkt->data + 769, avpkt->size - 769)) < 0)
446  return ret;
447 
448  blk = 0;
449  bw = avctx->width >> 2;
450  bh = avctx->height >> 2;
451  blocks = bw * bh;
452  stride = smk->pic->linesize[0];
453  while(blk < blocks) {
454  int type, run, mode;
455  uint16_t pix;
456 
457  type = smk_get_code(&gb, smk->type_tbl, smk->type_last);
458  run = block_runs[(type >> 2) & 0x3F];
459  switch(type & 3){
460  case SMK_BLK_MONO:
461  while(run-- && blk < blocks){
462  int clr, map;
463  int hi, lo;
464  clr = smk_get_code(&gb, smk->mclr_tbl, smk->mclr_last);
465  map = smk_get_code(&gb, smk->mmap_tbl, smk->mmap_last);
466  out = smk->pic->data[0] + (blk / bw) * (stride * 4) + (blk % bw) * 4;
467  hi = clr >> 8;
468  lo = clr & 0xFF;
469  for(i = 0; i < 4; i++) {
470  if(map & 1) out[0] = hi; else out[0] = lo;
471  if(map & 2) out[1] = hi; else out[1] = lo;
472  if(map & 4) out[2] = hi; else out[2] = lo;
473  if(map & 8) out[3] = hi; else out[3] = lo;
474  map >>= 4;
475  out += stride;
476  }
477  blk++;
478  }
479  break;
480  case SMK_BLK_FULL:
481  mode = 0;
482  if(avctx->codec_tag == MKTAG('S', 'M', 'K', '4')) { // In case of Smacker v4 we have three modes
483  if(get_bits1(&gb)) mode = 1;
484  else if(get_bits1(&gb)) mode = 2;
485  }
486  while(run-- && blk < blocks){
487  out = smk->pic->data[0] + (blk / bw) * (stride * 4) + (blk % bw) * 4;
488  switch(mode){
489  case 0:
490  for(i = 0; i < 4; i++) {
491  pix = smk_get_code(&gb, smk->full_tbl, smk->full_last);
492  AV_WL16(out+2,pix);
493  pix = smk_get_code(&gb, smk->full_tbl, smk->full_last);
494  AV_WL16(out,pix);
495  out += stride;
496  }
497  break;
498  case 1:
499  pix = smk_get_code(&gb, smk->full_tbl, smk->full_last);
500  out[0] = out[1] = pix & 0xFF;
501  out[2] = out[3] = pix >> 8;
502  out += stride;
503  out[0] = out[1] = pix & 0xFF;
504  out[2] = out[3] = pix >> 8;
505  out += stride;
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  break;
513  case 2:
514  for(i = 0; i < 2; i++) {
515  uint16_t pix1, pix2;
516  pix2 = smk_get_code(&gb, smk->full_tbl, smk->full_last);
517  pix1 = smk_get_code(&gb, smk->full_tbl, smk->full_last);
518  AV_WL16(out,pix1);
519  AV_WL16(out+2,pix2);
520  out += stride;
521  AV_WL16(out,pix1);
522  AV_WL16(out+2,pix2);
523  out += stride;
524  }
525  break;
526  }
527  blk++;
528  }
529  break;
530  case SMK_BLK_SKIP:
531  while(run-- && blk < blocks)
532  blk++;
533  break;
534  case SMK_BLK_FILL:
535  mode = type >> 8;
536  while(run-- && blk < blocks){
537  uint32_t col;
538  out = smk->pic->data[0] + (blk / bw) * (stride * 4) + (blk % bw) * 4;
539  col = mode * 0x01010101;
540  for(i = 0; i < 4; i++) {
541  *((uint32_t*)out) = col;
542  out += stride;
543  }
544  blk++;
545  }
546  break;
547  }
548 
549  }
550 
551  if ((ret = av_frame_ref(data, smk->pic)) < 0)
552  return ret;
553 
554  *got_frame = 1;
555 
556  /* always report that the buffer was completely consumed */
557  return avpkt->size;
558 }
559 
560 
562 {
563  SmackVContext * const smk = avctx->priv_data;
564 
565  av_freep(&smk->mmap_tbl);
566  av_freep(&smk->mclr_tbl);
567  av_freep(&smk->full_tbl);
568  av_freep(&smk->type_tbl);
569 
570  av_frame_free(&smk->pic);
571 
572  return 0;
573 }
574 
575 
577 {
578  SmackVContext * const c = avctx->priv_data;
579  int ret;
580 
581  c->avctx = avctx;
582 
583  avctx->pix_fmt = AV_PIX_FMT_PAL8;
584 
585  c->pic = av_frame_alloc();
586  if (!c->pic)
587  return AVERROR(ENOMEM);
588 
589  /* decode huffman trees from extradata */
590  if(avctx->extradata_size < 16){
591  av_log(avctx, AV_LOG_ERROR, "Extradata missing!\n");
592  decode_end(avctx);
593  return AVERROR(EINVAL);
594  }
595 
596  ret = decode_header_trees(c);
597  if (ret < 0) {
598  decode_end(avctx);
599  return ret;
600  }
601 
602  return 0;
603 }
604 
605 
607 {
608  if (avctx->channels < 1 || avctx->channels > 2) {
609  av_log(avctx, AV_LOG_ERROR, "invalid number of channels\n");
610  return AVERROR_INVALIDDATA;
611  }
614 
615  return 0;
616 }
617 
618 /**
619  * Decode Smacker audio data
620  */
622  int *got_frame_ptr, AVPacket *avpkt)
623 {
624  AVFrame *frame = data;
625  const uint8_t *buf = avpkt->data;
626  int buf_size = avpkt->size;
627  GetBitContext gb;
628  HuffContext h[4] = { { 0 } };
629  VLC vlc[4] = { { 0 } };
630  int16_t *samples;
631  uint8_t *samples8;
632  int val;
633  int i, res, ret;
634  int unp_size;
635  int bits, stereo;
636  int pred[2] = {0, 0};
637 
638  if (buf_size <= 4) {
639  av_log(avctx, AV_LOG_ERROR, "packet is too small\n");
640  return AVERROR_INVALIDDATA;
641  }
642 
643  unp_size = AV_RL32(buf);
644 
645  if (unp_size > (1U<<24)) {
646  av_log(avctx, AV_LOG_ERROR, "packet is too big\n");
647  return AVERROR_INVALIDDATA;
648  }
649 
650  if ((ret = init_get_bits8(&gb, buf + 4, buf_size - 4)) < 0)
651  return ret;
652 
653  if(!get_bits1(&gb)){
654  av_log(avctx, AV_LOG_INFO, "Sound: no data\n");
655  *got_frame_ptr = 0;
656  return 1;
657  }
658  stereo = get_bits1(&gb);
659  bits = get_bits1(&gb);
660  if (stereo ^ (avctx->channels != 1)) {
661  av_log(avctx, AV_LOG_ERROR, "channels mismatch\n");
662  return AVERROR_INVALIDDATA;
663  }
664  if (bits == (avctx->sample_fmt == AV_SAMPLE_FMT_U8)) {
665  av_log(avctx, AV_LOG_ERROR, "sample format mismatch\n");
666  return AVERROR_INVALIDDATA;
667  }
668 
669  /* get output buffer */
670  frame->nb_samples = unp_size / (avctx->channels * (bits + 1));
671  if (unp_size % (avctx->channels * (bits + 1))) {
672  av_log(avctx, AV_LOG_ERROR,
673  "The buffer does not contain an integer number of samples\n");
674  return AVERROR_INVALIDDATA;
675  }
676  if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
677  return ret;
678  samples = (int16_t *)frame->data[0];
679  samples8 = frame->data[0];
680 
681  // Initialize
682  for(i = 0; i < (1 << (bits + stereo)); i++) {
683  h[i].length = 256;
684  h[i].maxlength = 0;
685  h[i].current = 0;
686  h[i].bits = av_mallocz(256 * 4);
687  h[i].lengths = av_mallocz(256 * sizeof(int));
688  h[i].values = av_mallocz(256 * sizeof(int));
689  if (!h[i].bits || !h[i].lengths || !h[i].values) {
690  ret = AVERROR(ENOMEM);
691  goto error;
692  }
693  skip_bits1(&gb);
694  if (smacker_decode_tree(&gb, &h[i], 0, 0) < 0) {
695  ret = AVERROR_INVALIDDATA;
696  goto error;
697  }
698  skip_bits1(&gb);
699  if(h[i].current > 1) {
700  res = init_vlc(&vlc[i], SMKTREE_BITS, h[i].length,
701  h[i].lengths, sizeof(int), sizeof(int),
702  h[i].bits, sizeof(uint32_t), sizeof(uint32_t), INIT_VLC_LE);
703  if(res < 0) {
704  av_log(avctx, AV_LOG_ERROR, "Cannot build VLC table\n");
705  ret = AVERROR_INVALIDDATA;
706  goto error;
707  }
708  }
709  }
710  /* this codec relies on wraparound instead of clipping audio */
711  if(bits) { //decode 16-bit data
712  for(i = stereo; i >= 0; i--)
713  pred[i] = sign_extend(av_bswap16(get_bits(&gb, 16)), 16);
714  for(i = 0; i <= stereo; i++)
715  *samples++ = pred[i];
716  for(; i < unp_size / 2; i++) {
717  if(get_bits_left(&gb)<0)
718  return AVERROR_INVALIDDATA;
719  if(i & stereo) {
720  if(vlc[2].table)
721  res = get_vlc2(&gb, vlc[2].table, SMKTREE_BITS, 3);
722  else
723  res = 0;
724  if (res < 0) {
725  av_log(avctx, AV_LOG_ERROR, "invalid vlc\n");
726  return AVERROR_INVALIDDATA;
727  }
728  val = h[2].values[res];
729  if(vlc[3].table)
730  res = get_vlc2(&gb, vlc[3].table, SMKTREE_BITS, 3);
731  else
732  res = 0;
733  if (res < 0) {
734  av_log(avctx, AV_LOG_ERROR, "invalid vlc\n");
735  return AVERROR_INVALIDDATA;
736  }
737  val |= h[3].values[res] << 8;
738  pred[1] += sign_extend(val, 16);
739  *samples++ = pred[1];
740  } else {
741  if(vlc[0].table)
742  res = get_vlc2(&gb, vlc[0].table, SMKTREE_BITS, 3);
743  else
744  res = 0;
745  if (res < 0) {
746  av_log(avctx, AV_LOG_ERROR, "invalid vlc\n");
747  return AVERROR_INVALIDDATA;
748  }
749  val = h[0].values[res];
750  if(vlc[1].table)
751  res = get_vlc2(&gb, vlc[1].table, SMKTREE_BITS, 3);
752  else
753  res = 0;
754  if (res < 0) {
755  av_log(avctx, AV_LOG_ERROR, "invalid vlc\n");
756  return AVERROR_INVALIDDATA;
757  }
758  val |= h[1].values[res] << 8;
759  pred[0] += sign_extend(val, 16);
760  *samples++ = pred[0];
761  }
762  }
763  } else { //8-bit data
764  for(i = stereo; i >= 0; i--)
765  pred[i] = get_bits(&gb, 8);
766  for(i = 0; i <= stereo; i++)
767  *samples8++ = pred[i];
768  for(; i < unp_size; i++) {
769  if(get_bits_left(&gb)<0)
770  return AVERROR_INVALIDDATA;
771  if(i & stereo){
772  if(vlc[1].table)
773  res = get_vlc2(&gb, vlc[1].table, SMKTREE_BITS, 3);
774  else
775  res = 0;
776  if (res < 0) {
777  av_log(avctx, AV_LOG_ERROR, "invalid vlc\n");
778  return AVERROR_INVALIDDATA;
779  }
780  pred[1] += sign_extend(h[1].values[res], 8);
781  *samples8++ = pred[1];
782  } else {
783  if(vlc[0].table)
784  res = get_vlc2(&gb, vlc[0].table, SMKTREE_BITS, 3);
785  else
786  res = 0;
787  if (res < 0) {
788  av_log(avctx, AV_LOG_ERROR, "invalid vlc\n");
789  return AVERROR_INVALIDDATA;
790  }
791  pred[0] += sign_extend(h[0].values[res], 8);
792  *samples8++ = pred[0];
793  }
794  }
795  }
796 
797  *got_frame_ptr = 1;
798  ret = buf_size;
799 
800 error:
801  for(i = 0; i < 4; i++) {
802  if(vlc[i].table)
803  ff_free_vlc(&vlc[i]);
804  av_free(h[i].bits);
805  av_free(h[i].lengths);
806  av_free(h[i].values);
807  }
808 
809  return ret;
810 }
811 
813  .name = "smackvid",
814  .long_name = NULL_IF_CONFIG_SMALL("Smacker video"),
815  .type = AVMEDIA_TYPE_VIDEO,
817  .priv_data_size = sizeof(SmackVContext),
818  .init = decode_init,
819  .close = decode_end,
820  .decode = decode_frame,
821  .capabilities = AV_CODEC_CAP_DR1,
822 };
823 
825  .name = "smackaud",
826  .long_name = NULL_IF_CONFIG_SMALL("Smacker audio"),
827  .type = AVMEDIA_TYPE_AUDIO,
829  .init = smka_decode_init,
830  .decode = smka_decode_frame,
831  .capabilities = AV_CODEC_CAP_DR1,
832 };
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:408
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:1478
#define av_bswap16
Definition: bswap.h:31
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1775
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:576
AVCodec.
Definition: avcodec.h:3481
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:42
int ff_reget_buffer(AVCodecContext *avctx, AVFrame *frame)
Identical in function to av_frame_make_writable(), except it uses ff_get_buffer() to allocate the buf...
Definition: decode.c:2011
int escapes[3]
Definition: smacker.c:73
VLC * v2
Definition: smacker.c:71
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:2233
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:1666
static av_cold int smka_decode_init(AVCodecContext *avctx)
Definition: smacker.c:606
Definition: smacker.c:70
uint8_t * data
Definition: avcodec.h:1477
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:2789
#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:812
#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
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:3488
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:2276
static int smka_decode_frame(AVCodecContext *avctx, void *data, int *got_frame_ptr, AVPacket *avpkt)
Decode Smacker audio data.
Definition: smacker.c:621
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:1738
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:561
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:824
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:1565
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:1590
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1964
void * buf
Definition: avisynth_c.h:766
int extradata_size
Definition: avcodec.h:1667
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:389
#define SMKTREE_BITS
Definition: smacker.c:43
void * priv_data
Definition: avcodec.h:1592
#define av_free(p)
int channels
number of audio channels
Definition: avcodec.h:2226
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:384
#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:1454
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:981
Predicted.
Definition: avutil.h:275
void * av_mallocz_array(size_t nmemb, size_t size)
Definition: mem.c:191