FFmpeg: libavcodec/smacker.c Source File

FFmpeg

[フレーム]

libavcodec

smacker.c

Go to the documentation of this file.

1 /*

2 * Smacker decoder

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 */

22 /**

23 * @file

24 * Smacker decoder

25 */

27 /*

28 * Based on http://wiki.multimedia.cx/index.php?title=Smacker

29 */

31 #include <stdio.h>

32 #include <stdlib.h>

34 #include "libavutil/channel_layout.h"

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"

43 #define SMKTREE_BITS 9

44 #define SMK_NODE 0x80000000

46 #define SMKTREE_DECODE_MAX_RECURSION 32

47 #define SMKTREE_DECODE_BIG_MAX_RECURSION 500

49 typedef struct SmackVContext {

50 AVCodecContext *avctx;

51 AVFrame *pic;

53 int *mmap_tbl, *mclr_tbl, *full_tbl, *type_tbl;

54 int mmap_last[3], mclr_last[3], full_last[3], type_last[3];

55 } SmackVContext;

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;

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;

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 };

89 enum SmkBlockTypes {

90 SMK_BLK_MONO = 0,

91 SMK_BLK_FULL = 1,

92 SMK_BLK_SKIP = 2,

93 SMK_BLK_FILL = 3 };

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 */

135 static int smacker_decode_bigtree(GetBitContext *gb, HuffContext *hc,

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

319 static int decode_header_trees(SmackVContext *smk) {

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)

434 smk->pic->pict_type = AV_PICTURE_TYPE_I;

435 else

436 smk->pic->pict_type = AV_PICTURE_TYPE_P;

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

561 static av_cold int decode_end(AVCodecContext *avctx)

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

576 static av_cold int decode_init(AVCodecContext *avctx)

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

606 static av_cold int smka_decode_init(AVCodecContext *avctx)

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 }

612 avctx->channel_layout = (avctx->channels==2) ? AV_CH_LAYOUT_STEREO : AV_CH_LAYOUT_MONO;

613 avctx->sample_fmt = avctx->bits_per_coded_sample == 8 ? AV_SAMPLE_FMT_U8 : AV_SAMPLE_FMT_S16;

614

615 return 0;

616 }

617

618 /**

619 * Decode Smacker audio data

620 */

621 static int smka_decode_frame(AVCodecContext *avctx, void *data,

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

812 AVCodec ff_smacker_decoder = {

813 .name = "smackvid",

814 .long_name = NULL_IF_CONFIG_SMALL("Smacker video"),

815 .type = AVMEDIA_TYPE_VIDEO,

816 .id = AV_CODEC_ID_SMACKVIDEO,

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

824 AVCodec ff_smackaud_decoder = {

825 .name = "smackaud",

826 .long_name = NULL_IF_CONFIG_SMALL("Smacker audio"),

827 .type = AVMEDIA_TYPE_AUDIO,

828 .id = AV_CODEC_ID_SMACKAUDIO,

829 .init = smka_decode_init,

830 .decode = smka_decode_frame,

831 .capabilities = AV_CODEC_CAP_DR1,

832 };

smacker_decode_bigtree

static int smacker_decode_bigtree(GetBitContext *gb, HuffContext *hc, DBCtx *ctx, int length)

Decode header tree.

Definition: smacker.c:135

decode_frame

static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)

Definition: smacker.c:408

SmackVContext::type_last

int type_last[3]

Definition: smacker.c:54

NULL

#define NULL

Definition: coverity.c:32

val

const char const char void * val

Definition: avisynth_c.h:771

SMK_NODE

#define SMK_NODE

Definition: smacker.c:44

GetByteContext

Definition: bytestream.h:33

AVERROR_INVALIDDATA

#define AVERROR_INVALIDDATA

Invalid data found when processing input.

Definition: error.h:59

AVFrame

This structure describes decoded (raw) audio or video data.

Definition: frame.h:218

Definition: vp9dsp_template.c:2038

data

ptrdiff_t const GLvoid * data

Definition: opengl_enc.c:101

DBCtx::lcur

int lcur

Definition: smacker.c:75

block_runs

static const int block_runs[64]

Definition: smacker.c:79

get_bits

static unsigned int get_bits(GetBitContext *s, int n)

Read 1-25 bits.

Definition: get_bits.h:269

init

static av_cold int init(AVCodecContext *avctx)

Definition: avrndec.c:35

HuffContext::current

int current

Definition: smacker.c:63

SmackVContext

Definition: smacker.c:49

AV_CODEC_ID_SMACKVIDEO

Definition: avcodec.h:301

HuffContext::length

int length

Definition: smacker.c:61

DBCtx::recode1

int * recode1

Definition: smacker.c:72

DBCtx::recode2

int * recode2

Definition: smacker.c:72

AVPacket::size

int size

Definition: avcodec.h:1431

av_bswap16

#define av_bswap16

Definition: bswap.h:31

AVCodecContext::pix_fmt

enum AVPixelFormat pix_fmt

Pixel format, see AV_PIX_FMT_xxx.

Definition: avcodec.h:1727

bytestream2_init

static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)

Definition: bytestream.h:133

av_mallocz

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

SMK_BLK_MONO

Definition: smacker.c:90

run

uint8_t run

Definition: svq3.c:206

AV_CH_LAYOUT_STEREO

#define AV_CH_LAYOUT_STEREO

Definition: channel_layout.h:86

blk

#define blk(i)

Definition: sha.c:185

decode_init

static av_cold int decode_init(AVCodecContext *avctx)

Definition: smacker.c:576

AVCodec

AVCodec.

Definition: avcodec.h:3408

decode

static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)

Definition: decode_audio.c:42

ff_reget_buffer

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:1938

DBCtx::escapes

int escapes[3]

Definition: smacker.c:73

DBCtx::v2

VLC * v2

Definition: smacker.c:71

SMK_BLK_FULL

Definition: smacker.c:91

AVCodecContext::sample_fmt

enum AVSampleFormat sample_fmt

audio sample format

Definition: avcodec.h:2181

uint8_t

Definition: audio_convert.c:194

av_cold

#define av_cold

Definition: attributes.h:82

av_malloc

#define av_malloc(s)

Definition: tableprint_vlc.h:31

AV_SAMPLE_FMT_U8

Definition: audio_convert.c:194

av_frame_alloc

AVFrame * av_frame_alloc(void)

Allocate an AVFrame and set its fields to default values.

Definition: frame.c:189

DBCtx::v1

VLC * v1

Definition: smacker.c:71

AV_PIX_FMT_PAL8

8 bits with AV_PIX_FMT_RGB32 palette

Definition: pixfmt.h:73

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:441

AVCodecContext::extradata

uint8_t * extradata

some codecs need / can use extradata like Huffman tables.

Definition: avcodec.h:1618

smka_decode_init

static av_cold int smka_decode_init(AVCodecContext *avctx)

Definition: smacker.c:606

frame

static AVFrame * frame

Definition: demuxing_decoding.c:53

DBCtx

Definition: smacker.c:70

AVPacket::data

uint8_t * data

Definition: avcodec.h:1430

flags

static int flags

Definition: log.c:55

HuffContext::maxlength

int maxlength

Definition: smacker.c:62

get_bits.h

bitstream reader API header.

SMKTREE_DECODE_BIG_MAX_RECURSION

#define SMKTREE_DECODE_BIG_MAX_RECURSION

Definition: smacker.c:47

size

ptrdiff_t size

Definition: opengl_enc.c:101

AVCodecContext::bits_per_coded_sample

int bits_per_coded_sample

bits per sample/pixel from the demuxer (needed for huffyuv).

Definition: avcodec.h:2734

av_log

#define av_log(a,...)

Definition: tableprint_vlc.h:28

SmackVContext::type_tbl

int * type_tbl

Definition: smacker.c:53

SmackVContext::full_last

int full_last[3]

Definition: smacker.c:54

#define U(x)

Definition: vp56_arith.h:37

get_bits_left

static int get_bits_left(GetBitContext *gb)

Definition: get_bits.h:596

AV_LOG_ERROR

#define AV_LOG_ERROR

Something went wrong and cannot losslessly be recovered.

Definition: log.h:176

ff_smacker_decoder

AVCodec ff_smacker_decoder

Definition: smacker.c:812

SMK_BLK_SKIP

Definition: smacker.c:92

init_vlc

#define init_vlc(vlc, nb_bits, nb_codes,bits, bits_wrap, bits_size,codes, codes_wrap, codes_size,flags)

Definition: vlc.h:38

SMKTREE_DECODE_MAX_RECURSION

#define SMKTREE_DECODE_MAX_RECURSION

Definition: smacker.c:46

AVERROR

#define AVERROR(e)

Definition: error.h:43

SmkBlockTypes

Definition: smacker.c:89

av_frame_free

void av_frame_free(AVFrame **frame)

Free the frame and any dynamically allocated objects in it, e.g.

Definition: frame.c:202

table

static const struct endianess table[]

smacker_decode_tree

static int smacker_decode_tree(GetBitContext *gb, HuffContext *hc, uint32_t prefix, int length)

Decode local frame tree.

Definition: smacker.c:98

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:186

const char * r

Definition: vf_curves.c:111

AVMEDIA_TYPE_AUDIO

Definition: avutil.h:202

length

GLsizei GLsizei * length

Definition: opengl_enc.c:115

AVCodec::name

const char * name

Name of the codec implementation.

Definition: avcodec.h:3415

SmackVContext::pic

AVFrame * pic

Definition: smacker.c:51

SmackVContext::mmap_tbl

int * mmap_tbl

Definition: smacker.c:53

bytestream.h

VLC

Definition: vlc.h:26

AVCodecContext::channel_layout

uint64_t channel_layout

Audio channel layout.

Definition: avcodec.h:2224

smka_decode_frame

static int smka_decode_frame(AVCodecContext *avctx, void *data, int *got_frame_ptr, AVPacket *avpkt)

Decode Smacker audio data.

Definition: smacker.c:621

channel_layout.h

audio channel layout utility functions

AV_PICTURE_TYPE_I

Intra.

Definition: avutil.h:274

AVFrame::pict_type

enum AVPictureType pict_type

Picture type of the frame.

Definition: frame.h:301

SmackVContext::mmap_last

int mmap_last[3]

Definition: smacker.c:54

AVCodecContext::width

int width

picture width / height.

Definition: avcodec.h:1690

HuffContext

Context used for code reconstructing.

Definition: smacker.c:60

mathops.h

ctx

AVFormatContext * ctx

Definition: movenc.c:48

decode_end

static av_cold int decode_end(AVCodecContext *avctx)

Definition: smacker.c:561

get_vlc2

static av_always_inline int get_vlc2(GetBitContext *s, VLC_TYPE(*table)[2], int bits, int max_depth)

Parse a vlc code.

Definition: get_bits.h:563

AVCodecContext::height

int height

Definition: avcodec.h:1690

error

static void error(const char *err)

Definition: target_dec_fuzzer.c:59

SmackVContext::mclr_tbl

int * mclr_tbl

Definition: smacker.c:53

INIT_VLC_LE

#define INIT_VLC_LE

Definition: vlc.h:54

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:187

pred

static const float pred[4]

Definition: siprdata.h:259

SmackVContext::full_tbl

int * full_tbl

Definition: smacker.c:53

AV_LOG_INFO

#define AV_LOG_INFO

Standard information.

Definition: log.h:187

avcodec.h

Libavcodec external API header.

ff_smackaud_decoder

AVCodec ff_smackaud_decoder

Definition: smacker.c:824

AVFrame::linesize

int linesize[AV_NUM_DATA_POINTERS]

For video, size in bytes of each picture line.

Definition: frame.h:249

init_get_bits8

static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)

Initialize GetBitContext.

Definition: get_bits.h:464

AVCodecContext

main external API structure.

Definition: avcodec.h:1518

SMK_BLK_FILL

Definition: smacker.c:93

AVCodecContext::codec_tag

unsigned int codec_tag

fourcc (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A').

Definition: avcodec.h:1543

ff_get_buffer

int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)

Get a buffer for a frame.

Definition: decode.c:1891

buf

void * buf

Definition: avisynth_c.h:690

type

GLint GLenum type

Definition: opengl_enc.c:105

AVCodecContext::extradata_size

int extradata_size

Definition: avcodec.h:1619

get_bits1

static unsigned int get_bits1(GetBitContext *s)

Definition: get_bits.h:321

skip_bits1

static void skip_bits1(GetBitContext *s)

Definition: get_bits.h:346

AVFrame::palette_has_changed

int palette_has_changed

Tell user application that palette has changed from previous frame.

Definition: frame.h:375

map

const VDPAUPixFmtMap * map

Definition: hwcontext_vdpau.c:83

DBCtx::last

int * last

Definition: smacker.c:74

sign_extend

static av_const int sign_extend(int val, unsigned bits)

Definition: mathops.h:130

AVFrame::data

uint8_t * data[AV_NUM_DATA_POINTERS]

pointer to the picture/channel planes.

Definition: frame.h:232

HuffContext::lengths

int * lengths

Definition: smacker.c:65

SmackVContext::avctx

AVCodecContext * avctx

Definition: smacker.c:50

GetBitContext

Definition: get_bits.h:56

internal.h

common internal api header.

HuffContext::bits

uint32_t * bits

Definition: smacker.c:64

AV_SAMPLE_FMT_S16

signed 16 bits

Definition: samplefmt.h:61

static double c[64]

Definition: vsrc_mptestsrc.c:87

AV_WL16

#define AV_WL16(p, v)

Definition: intreadwrite.h:412

smk_get_code

static av_always_inline int smk_get_code(GetBitContext *gb, int *recode, int *last)

Definition: smacker.c:389

SMKTREE_BITS

#define SMKTREE_BITS

Definition: smacker.c:43

AVCodecContext::priv_data

void * priv_data

Definition: avcodec.h:1545

av_free

#define av_free(p)

Definition: tableprint_vlc.h:34

AVCodecContext::channels

int channels

number of audio channels

Definition: avcodec.h:2174

VLC::table

VLC_TYPE(* table)[2]

code, bits

Definition: vlc.h:28

AVFrame::key_frame

int key_frame

1 -> keyframe, 0-> not

Definition: frame.h:296

SmackVContext::mclr_last

int mclr_last[3]

Definition: smacker.c:54

HuffContext::values

int * values

Definition: smacker.c:66

out

FILE * out

Definition: movenc.c:54

av_freep

#define av_freep(p)

Definition: tableprint_vlc.h:35

AVMEDIA_TYPE_VIDEO

Definition: avutil.h:201

av_always_inline

#define av_always_inline

Definition: attributes.h:39

decode_header_trees

static int decode_header_trees(SmackVContext *smk)

Definition: smacker.c:319

last_reset

static av_always_inline void last_reset(int *recode, int *last)

Definition: smacker.c:384

stride

#define stride

AV_CH_LAYOUT_MONO

#define AV_CH_LAYOUT_MONO

Definition: channel_layout.h:85

MKTAG

#define MKTAG(a, b, c, d)

Definition: common.h:366

AV_RL32

uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32

Definition: bytestream.h:87

AVPacket

This structure stores compressed data.

Definition: avcodec.h:1407

ff_free_vlc

void ff_free_vlc(VLC *vlc)

Definition: bitstream.c:354

mode

Use these values in ebur128_init (or'ed).

Definition: ebur128.h:83

AVFrame::nb_samples

int nb_samples

number of audio samples (per channel) described by this frame

Definition: frame.h:284

AV_CODEC_CAP_DR1

#define AV_CODEC_CAP_DR1

Codec uses get_buffer() for allocating buffers and supports custom allocators.

Definition: avcodec.h:959

AV_PICTURE_TYPE_P

Predicted.

Definition: avutil.h:275

AV_CODEC_ID_SMACKAUDIO

Definition: avcodec.h:574

av_mallocz_array

void * av_mallocz_array(size_t nmemb, size_t size)

Definition: mem.c:191

Generated on Sun May 13 2018 02:03:55 for FFmpeg by doxygen 1.8.6