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
38
39 #define BITSTREAM_READER_LE
42
43 #define SMKTREE_BITS 9
44 #define SMK_NODE 0x80000000
45
46 /*
47 * Decoder context
48 */
52
56
57 /**
58 * Context used for code reconstructing
59 */
68
69 /* common parameters used for decode_bigtree */
77
78 /* possible runs of blocks */
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
94
95 /**
96 * Decode local frame tree
97 */
99 {
103 }
108 }
109 if(length){
112 } else {
115 }
120 return 0;
121 } else { //Node
123 length++;
125 if(r)
128 }
129 }
130
131 /**
132 * Decode header tree
133 */
135 {
139 }
141 int val, i1, i2;
144 if (i1 < 0 || i2 < 0)
149 val = 0;
150 }
else if(val == ctx->
escapes[1]) {
152 val = 0;
153 }
else if(val == ctx->
escapes[2]) {
155 val = 0;
156 }
157
159 return 1;
160 } else { //Node
162
165 if(r < 0)
168 r++;
170 if (r_new < 0)
171 return r_new;
172 return r + r_new;
173 }
174 }
175
176 /**
177 * Store large tree as FFmpeg's vlc codes
178 */
180 {
181 int res;
184 VLC vlc[2] = { { 0 } };
185 int escapes[3];
187 int err = 0;
188
189 if(size >= UINT_MAX>>4){ // (((size + 3) >> 2) + 3) << 2 must not overflow
192 }
193
200
207
210 if (res < 0)
211 return res;
215 tmp1.
lengths,
sizeof(
int),
sizeof(
int),
217 if(res < 0) {
220 }
221 }
222 }
225 }
228 if (res < 0)
229 return res;
233 tmp2.
lengths,
sizeof(
int),
sizeof(
int),
235 if(res < 0) {
238 }
239 }
240 }
241 if (!vlc[1].table) {
243 }
244
248
249 last[0] = last[1] = last[2] = -1;
250
259
260 huff.
length = ((size + 3) >> 2) + 3;
264
266 err = -1;
275 }
276
278
279 if(vlc[0].table)
281 if(vlc[1].table)
289
290 return err;
291 }
292
295 int mmap_size, mclr_size, full_size, type_size;
296
301
303
309 } else {
312 }
318 } else {
321 }
327 } else {
330 }
336 } else {
339 }
340
341 return 0;
342 }
343
345 recode[last[0]] = recode[last[1]] = recode[last[2]] = 0;
346 }
347
348 /* get code and update history */
350 register int *
table = recode;
351 int v;
352
355 table += (*table) & (~SMK_NODE);
356 table++;
357 }
359
360 if(v != recode[last[0]]) {
361 recode[last[2]] = recode[last[1]];
362 recode[last[1]] = recode[last[0]];
363 recode[last[0]] = v;
364 }
365 return v;
366 }
367
370 {
373 uint32_t *pal;
376 int blocks,
blk, bw, bh;
377 int i, ret;
380
381 if (avpkt->
size <= 769)
383
388 return ret;
389 }
390
391 /* make the palette available on the way out */
392 pal = (uint32_t*)smk->
pic.
data[1];
394 flags = bytestream2_get_byteu(&gb2);
399 else
401
402 for(i = 0; i < 256; i++)
403 *pal++ = 0xFFU << 24 | bytestream2_get_be24u(&gb2);
404
410
411 blk = 0;
412 bw = avctx->
width >> 2;
414 blocks = bw * bh;
417 while(blk < blocks) {
419 uint16_t pix;
420
423 switch(type & 3){
425 while(run-- && blk < blocks){
426 int clr, map;
427 int hi, lo;
430 out = smk->
pic.
data[0] + (blk / bw) * (stride * 4) + (blk % bw) * 4;
431 hi = clr >> 8;
432 lo = clr & 0xFF;
433 for(i = 0; i < 4; i++) {
434 if(map & 1) out[0] = hi; else out[0] = lo;
435 if(map & 2) out[1] = hi; else out[1] = lo;
436 if(map & 4) out[2] = hi; else out[2] = lo;
437 if(map & 8) out[3] = hi; else out[3] = lo;
438 map >>= 4;
440 }
441 blk++;
442 }
443 break;
445 mode = 0;
446 if(avctx->
codec_tag ==
MKTAG(
'S',
'M',
'K',
'4')) {
// In case of Smacker v4 we have three modes
449 }
450 while(run-- && blk < blocks){
451 out = smk->
pic.
data[0] + (blk / bw) * (stride * 4) + (blk % bw) * 4;
452 switch(mode){
453 case 0:
454 for(i = 0; i < 4; i++) {
460 }
461 break;
462 case 1:
464 out[0] = out[1] = pix & 0xFF;
465 out[2] = out[3] = pix >> 8;
467 out[0] = out[1] = pix & 0xFF;
468 out[2] = out[3] = pix >> 8;
471 out[0] = out[1] = pix & 0xFF;
472 out[2] = out[3] = pix >> 8;
474 out[0] = out[1] = pix & 0xFF;
475 out[2] = out[3] = pix >> 8;
477 break;
478 case 2:
479 for(i = 0; i < 2; i++) {
480 uint16_t pix1, pix2;
489 }
490 break;
491 }
492 blk++;
493 }
494 break;
496 while(run-- && blk < blocks)
497 blk++;
498 break;
500 mode = type >> 8;
501 while(run-- && blk < blocks){
502 uint32_t col;
503 out = smk->
pic.
data[0] + (blk / bw) * (stride * 4) + (blk % bw) * 4;
504 col = mode * 0x01010101;
505 for(i = 0; i < 4; i++) {
506 *((uint32_t*)out) = col;
508 }
509 blk++;
510 }
511 break;
512 }
513
514 }
515
516 *got_frame = 1;
518
519 /* always report that the buffer was completely consumed */
521 }
522
523
524
525 /*
526 *
527 * Init smacker decoder
528 *
529 */
531 {
533
535
537
539
540 /* decode huffman trees from extradata */
544 }
545
548
549 return 0;
550 }
551
552
553
554 /*
555 *
556 * Uninit smacker decoder
557 *
558 */
560 {
562
567
570
571 return 0;
572 }
573
574
578
580 {
582
586 }
589
592
593 return 0;
594 }
595
596 /**
597 * Decode Smacker audio data
598 */
600 int *got_frame_ptr,
AVPacket *avpkt)
601 {
604 int buf_size = avpkt->
size;
607 VLC vlc[4] = { { 0 } };
610 int val;
611 int i, res, ret;
612 int unp_size;
614 int pred[2] = {0, 0};
615
616 if (buf_size <= 4) {
619 }
620
622
623 if (unp_size > (1
U<<24)) {
626 }
627
629
632 *got_frame_ptr = 0;
633 return 1;
634 }
637 if (stereo ^ (avctx->
channels != 1)) {
640 }
644 }
645
646 /* get output buffer */
650 return ret;
651 }
654
655 // Initialize
656 for(i = 0; i < (1 << (bits + stereo)); i++) {
665 if (res < 0)
666 return res;
668 if(h[i].current > 1) {
670 h[i].lengths, sizeof(int), sizeof(int),
671 h[i].bits,
sizeof(uint32_t),
sizeof(uint32_t),
INIT_VLC_LE);
672 if(res < 0) {
675 }
676 }
677 }
678 if(bits) { //decode 16-bit data
679 for(i = stereo; i >= 0; i--)
681 for(i = 0; i <= stereo; i++)
682 *samples++ = pred[i];
683 for(; i < unp_size / 2; i++) {
686 if(i & stereo) {
689 else
690 res = 0;
691 if (res < 0) {
694 }
696 if(vlc[3].table)
698 else
699 res = 0;
700 if (res < 0) {
703 }
704 val |= h[3].
values[res] << 8;
706 *samples++ = pred[1];
707 } else {
710 else
711 res = 0;
712 if (res < 0) {
715 }
717 if(vlc[1].table)
719 else
720 res = 0;
721 if (res < 0) {
724 }
725 val |= h[1].
values[res] << 8;
727 *samples++ = pred[0];
728 }
729 }
730 } else { //8-bit data
731 for(i = stereo; i >= 0; i--)
733 for(i = 0; i <= stereo; i++)
734 *samples8++ = pred[i];
735 for(; i < unp_size; i++) {
738 if(i & stereo){
741 else
742 res = 0;
743 if (res < 0) {
746 }
748 *samples8++ = av_clip_uint8(pred[1]);
749 } else {
752 else
753 res = 0;
754 if (res < 0) {
757 }
759 *samples8++ = av_clip_uint8(pred[0]);
760 }
761 }
762 }
763
764 for(i = 0; i < 4; i++) {
770 }
771
772 *got_frame_ptr = 1;
774
775 return buf_size;
776 }
777
788 };
789
799 };