FFmpeg: libavcodec/dxtory.c Source File

FFmpeg

[フレーム]

libavcodec

dxtory.c

Go to the documentation of this file.

1 /*

2 * Dxtory decoder

3 *

5 *

6 * This file is part of FFmpeg.

7 *

8 * FFmpeg is free software; you can redistribute it and/or

9 * modify it under the terms of the GNU Lesser General Public

10 * License as published by the Free Software Foundation; either

11 * version 2.1 of the License, or (at your option) any later version.

12 *

13 * FFmpeg is distributed in the hope that it will be useful,

14 * but WITHOUT ANY WARRANTY; without even the implied warranty of

15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

16 * Lesser General Public License for more details.

17 *

18 * You should have received a copy of the GNU Lesser General Public

19 * License along with FFmpeg; if not, write to the Free Software

20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

21 */

23 #include <inttypes.h>

25 #define BITSTREAM_READER_LE

26 #include "avcodec.h"

27 #include "bytestream.h"

28 #include "get_bits.h"

29 #include "internal.h"

30 #include "unary.h"

31 #include "libavutil/common.h"

32 #include "libavutil/intreadwrite.h"

34 static int dxtory_decode_v1_rgb(AVCodecContext *avctx, AVFrame *pic,

35 const uint8_t *src, int src_size,

36 int id, int bpp)

37 {

38 int h;

39 uint8_t *dst;

40 int ret;

42 if (src_size < avctx->width * avctx->height * (int64_t)bpp) {

43 av_log(avctx, AV_LOG_ERROR, "packet too small\n");

44 return AVERROR_INVALIDDATA;

45 }

47 avctx->pix_fmt = id;

48 if ((ret = ff_get_buffer(avctx, pic, 0)) < 0)

49 return ret;

51 dst = pic->data[0];

52 for (h = 0; h < avctx->height; h++) {

53 memcpy(dst, src, avctx->width * bpp);

54 src += avctx->width * bpp;

55 dst += pic->linesize[0];

56 }

58 return 0;

59 }

61 static int dxtory_decode_v1_410(AVCodecContext *avctx, AVFrame *pic,

62 const uint8_t *src, int src_size)

63 {

64 int h, w;

65 uint8_t *Y1, *Y2, *Y3, *Y4, *U, *V;

66 int ret;

68 if (src_size < avctx->width * avctx->height * 9LL / 8) {

69 av_log(avctx, AV_LOG_ERROR, "packet too small\n");

70 return AVERROR_INVALIDDATA;

71 }

73 avctx->pix_fmt = AV_PIX_FMT_YUV410P;

74 if ((ret = ff_get_buffer(avctx, pic, 0)) < 0)

75 return ret;

77 Y1 = pic->data[0];

78 Y2 = pic->data[0] + pic->linesize[0];

79 Y3 = pic->data[0] + pic->linesize[0] * 2;

80 Y4 = pic->data[0] + pic->linesize[0] * 3;

81 U = pic->data[1];

82 V = pic->data[2];

83 for (h = 0; h < avctx->height; h += 4) {

84 for (w = 0; w < avctx->width; w += 4) {

85 AV_COPY32U(Y1 + w, src);

86 AV_COPY32U(Y2 + w, src + 4);

87 AV_COPY32U(Y3 + w, src + 8);

88 AV_COPY32U(Y4 + w, src + 12);

89 U[w >> 2] = src[16] + 0x80;

90 V[w >> 2] = src[17] + 0x80;

91 src += 18;

92 }

93 Y1 += pic->linesize[0] << 2;

94 Y2 += pic->linesize[0] << 2;

95 Y3 += pic->linesize[0] << 2;

96 Y4 += pic->linesize[0] << 2;

97 U += pic->linesize[1];

98 V += pic->linesize[2];

99 }

100

101 return 0;

102 }

103

104 static int dxtory_decode_v1_420(AVCodecContext *avctx, AVFrame *pic,

105 const uint8_t *src, int src_size)

106 {

107 int h, w;

108 uint8_t *Y1, *Y2, *U, *V;

109 int ret;

110

111 if (src_size < avctx->width * avctx->height * 3LL / 2) {

112 av_log(avctx, AV_LOG_ERROR, "packet too small\n");

113 return AVERROR_INVALIDDATA;

114 }

115

116 avctx->pix_fmt = AV_PIX_FMT_YUV420P;

117 if ((ret = ff_get_buffer(avctx, pic, 0)) < 0)

118 return ret;

119

120 Y1 = pic->data[0];

121 Y2 = pic->data[0] + pic->linesize[0];

122 U = pic->data[1];

123 V = pic->data[2];

124 for (h = 0; h < avctx->height; h += 2) {

125 for (w = 0; w < avctx->width; w += 2) {

126 AV_COPY16(Y1 + w, src);

127 AV_COPY16(Y2 + w, src + 2);

128 U[w >> 1] = src[4] + 0x80;

129 V[w >> 1] = src[5] + 0x80;

130 src += 6;

131 }

132 Y1 += pic->linesize[0] << 1;

133 Y2 += pic->linesize[0] << 1;

134 U += pic->linesize[1];

135 V += pic->linesize[2];

136 }

137

138 return 0;

139 }

140

141 static int dxtory_decode_v1_444(AVCodecContext *avctx, AVFrame *pic,

142 const uint8_t *src, int src_size)

143 {

144 int h, w;

145 uint8_t *Y, *U, *V;

146 int ret;

147

148 if (src_size < avctx->width * avctx->height * 3LL) {

149 av_log(avctx, AV_LOG_ERROR, "packet too small\n");

150 return AVERROR_INVALIDDATA;

151 }

152

153 avctx->pix_fmt = AV_PIX_FMT_YUV444P;

154 if ((ret = ff_get_buffer(avctx, pic, 0)) < 0)

155 return ret;

156

157 Y = pic->data[0];

158 U = pic->data[1];

159 V = pic->data[2];

160 for (h = 0; h < avctx->height; h++) {

161 for (w = 0; w < avctx->width; w++) {

162 Y[w] = *src++;

163 U[w] = *src++ ^ 0x80;

164 V[w] = *src++ ^ 0x80;

165 }

166 Y += pic->linesize[0];

167 U += pic->linesize[1];

168 V += pic->linesize[2];

169 }

170

171 return 0;

172 }

173

174 static const uint8_t def_lru[8] = { 0x00, 0x20, 0x40, 0x60, 0x80, 0xA0, 0xC0, 0xFF };

175 static const uint8_t def_lru_555[8] = { 0x00, 0x08, 0x10, 0x18, 0x1F };

176 static const uint8_t def_lru_565[8] = { 0x00, 0x08, 0x10, 0x20, 0x30, 0x3F };

177

178 static inline uint8_t decode_sym(GetBitContext *gb, uint8_t lru[8])

179 {

180 uint8_t c, val;

181

182 c = get_unary(gb, 0, 8);

183 if (!c) {

184 val = get_bits(gb, 8);

185 memmove(lru + 1, lru, sizeof(*lru) * (8 - 1));

186 } else {

187 val = lru[c - 1];

188 memmove(lru + 1, lru, sizeof(*lru) * (c - 1));

189 }

190 lru[0] = val;

191

192 return val;

193 }

194

195 static inline uint8_t decode_sym_565(GetBitContext *gb, uint8_t lru[8],

196 int bits)

197 {

198 uint8_t c, val;

199

200 c = get_unary(gb, 0, bits);

201 if (!c) {

202 val = get_bits(gb, bits);

203 memmove(lru + 1, lru, sizeof(*lru) * (6 - 1));

204 } else {

205 val = lru[c - 1];

206 memmove(lru + 1, lru, sizeof(*lru) * (c - 1));

207 }

208 lru[0] = val;

209

210 return val;

211 }

212

213 static int dx2_decode_slice_565(GetBitContext *gb, int width, int height,

214 uint8_t *dst, int stride, int is_565)

215 {

216 int x, y;

217 int r, g, b;

218 uint8_t lru[3][8];

219

220 memcpy(lru[0], def_lru_555, 8 * sizeof(*def_lru));

221 memcpy(lru[1], is_565 ? def_lru_565 : def_lru_555, 8 * sizeof(*def_lru));

222 memcpy(lru[2], def_lru_555, 8 * sizeof(*def_lru));

223

224 for (y = 0; y < height; y++) {

225 for (x = 0; x < width; x++) {

226 b = decode_sym_565(gb, lru[0], 5);

227 g = decode_sym_565(gb, lru[1], is_565 ? 6 : 5);

228 r = decode_sym_565(gb, lru[2], 5);

229 dst[x * 3 + 0] = (r << 3) | (r >> 2);

230 dst[x * 3 + 1] = is_565 ? (g << 2) | (g >> 4) : (g << 3) | (g >> 2);

231 dst[x * 3 + 2] = (b << 3) | (b >> 2);

232 }

233

234 dst += stride;

235 }

236

237 return 0;

238 }

239

240 static int dxtory_decode_v2_565(AVCodecContext *avctx, AVFrame *pic,

241 const uint8_t *src, int src_size, int is_565)

242 {

243 GetByteContext gb;

244 GetBitContext gb2;

245 int nslices, slice, slice_height;

246 uint32_t off, slice_size;

247 uint8_t *dst;

248 int ret;

249

250 bytestream2_init(&gb, src, src_size);

251 nslices = bytestream2_get_le16(&gb);

252 off = FFALIGN(nslices * 4 + 2, 16);

253 if (src_size < off) {

254 av_log(avctx, AV_LOG_ERROR, "no slice data\n");

255 return AVERROR_INVALIDDATA;

256 }

257

258 if (!nslices || avctx->height % nslices) {

259 avpriv_request_sample(avctx, "%d slices for %dx%d", nslices,

260 avctx->width, avctx->height);

261 return AVERROR_PATCHWELCOME;

262 }

263

264 slice_height = avctx->height / nslices;

265 avctx->pix_fmt = AV_PIX_FMT_RGB24;

266 if ((ret = ff_get_buffer(avctx, pic, 0)) < 0)

267 return ret;

268

269 dst = pic->data[0];

270 for (slice = 0; slice < nslices; slice++) {

271 slice_size = bytestream2_get_le32(&gb);

272 if (slice_size > src_size - off) {

273 av_log(avctx, AV_LOG_ERROR,

274 "invalid slice size %"PRIu32" (only %"PRIu32" bytes left)\n",

275 slice_size, src_size - off);

276 return AVERROR_INVALIDDATA;

277 }

278 if (slice_size <= 16) {

279 av_log(avctx, AV_LOG_ERROR, "invalid slice size %"PRIu32"\n", slice_size);

280 return AVERROR_INVALIDDATA;

281 }

282

283 if (AV_RL32(src + off) != slice_size - 16) {

284 av_log(avctx, AV_LOG_ERROR,

285 "Slice sizes mismatch: got %"PRIu32" instead of %"PRIu32"\n",

286 AV_RL32(src + off), slice_size - 16);

287 }

288 if ((ret = init_get_bits8(&gb2, src + off + 16, slice_size - 16)) < 0)

289 return ret;

290 dx2_decode_slice_565(&gb2, avctx->width, slice_height, dst,

291 pic->linesize[0], is_565);

292

293 dst += pic->linesize[0] * slice_height;

294 off += slice_size;

295 }

296

297 return 0;

298 }

299

300 static int dx2_decode_slice_rgb(GetBitContext *gb, int width, int height,

301 uint8_t *dst, int stride)

302 {

303 int x, y, i;

304 uint8_t lru[3][8];

305

306 for (i = 0; i < 3; i++)

307 memcpy(lru[i], def_lru, 8 * sizeof(*def_lru));

308

309 for (y = 0; y < height; y++) {

310 for (x = 0; x < width; x++) {

311 dst[x * 3 + 0] = decode_sym(gb, lru[0]);

312 dst[x * 3 + 1] = decode_sym(gb, lru[1]);

313 dst[x * 3 + 2] = decode_sym(gb, lru[2]);

314 }

315

316 dst += stride;

317 }

318

319 return 0;

320 }

321

322 static int dxtory_decode_v2_rgb(AVCodecContext *avctx, AVFrame *pic,

323 const uint8_t *src, int src_size)

324 {

325 GetByteContext gb;

326 GetBitContext gb2;

327 int nslices, slice, slice_height;

328 uint32_t off, slice_size;

329 uint8_t *dst;

330 int ret;

331

332 bytestream2_init(&gb, src, src_size);

333 nslices = bytestream2_get_le16(&gb);

334 off = FFALIGN(nslices * 4 + 2, 16);

335 if (src_size < off) {

336 av_log(avctx, AV_LOG_ERROR, "no slice data\n");

337 return AVERROR_INVALIDDATA;

338 }

339

340 if (!nslices || avctx->height % nslices) {

341 avpriv_request_sample(avctx, "%d slices for %dx%d", nslices,

342 avctx->width, avctx->height);

343 return AVERROR_PATCHWELCOME;

344 }

345

346 slice_height = avctx->height / nslices;

347 avctx->pix_fmt = AV_PIX_FMT_BGR24;

348 if ((ret = ff_get_buffer(avctx, pic, 0)) < 0)

349 return ret;

350

351 dst = pic->data[0];

352 for (slice = 0; slice < nslices; slice++) {

353 slice_size = bytestream2_get_le32(&gb);

354 if (slice_size > src_size - off) {

355 av_log(avctx, AV_LOG_ERROR,

356 "invalid slice size %"PRIu32" (only %"PRIu32" bytes left)\n",

357 slice_size, src_size - off);

358 return AVERROR_INVALIDDATA;

359 }

360 if (slice_size <= 16) {

361 av_log(avctx, AV_LOG_ERROR, "invalid slice size %"PRIu32"\n",

362 slice_size);

363 return AVERROR_INVALIDDATA;

364 }

365

366 if (AV_RL32(src + off) != slice_size - 16) {

367 av_log(avctx, AV_LOG_ERROR,

368 "Slice sizes mismatch: got %"PRIu32" instead of %"PRIu32"\n",

369 AV_RL32(src + off), slice_size - 16);

370 }

371 if ((ret = init_get_bits8(&gb2, src + off + 16, slice_size - 16)) < 0)

372 return ret;

373 dx2_decode_slice_rgb(&gb2, avctx->width, slice_height, dst,

374 pic->linesize[0]);

375

376 dst += pic->linesize[0] * slice_height;

377 off += slice_size;

378 }

379

380 return 0;

381 }

382

383 static int dx2_decode_slice_410(GetBitContext *gb, int width, int height,

384 uint8_t *Y, uint8_t *U, uint8_t *V,

385 int ystride, int ustride, int vstride)

386 {

387 int x, y, i, j;

388 uint8_t lru[3][8];

389

390 for (i = 0; i < 3; i++)

391 memcpy(lru[i], def_lru, 8 * sizeof(*def_lru));

392

393 for (y = 0; y < height; y += 4) {

394 for (x = 0; x < width; x += 4) {

395 for (j = 0; j < 4; j++)

396 for (i = 0; i < 4; i++)

397 Y[x + i + j * ystride] = decode_sym(gb, lru[0]);

398 U[x >> 2] = decode_sym(gb, lru[1]) ^ 0x80;

399 V[x >> 2] = decode_sym(gb, lru[2]) ^ 0x80;

400 }

401

402 Y += ystride << 2;

403 U += ustride;

404 V += vstride;

405 }

406

407 return 0;

408 }

409

410 static int dxtory_decode_v2_410(AVCodecContext *avctx, AVFrame *pic,

411 const uint8_t *src, int src_size)

412 {

413 GetByteContext gb;

414 GetBitContext gb2;

415 int nslices, slice, slice_height;

416 int cur_y, next_y;

417 uint32_t off, slice_size;

418 uint8_t *Y, *U, *V;

419 int ret;

420

421 bytestream2_init(&gb, src, src_size);

422 nslices = bytestream2_get_le16(&gb);

423 off = FFALIGN(nslices * 4 + 2, 16);

424 if (src_size < off) {

425 av_log(avctx, AV_LOG_ERROR, "no slice data\n");

426 return AVERROR_INVALIDDATA;

427 }

428

429 if (!nslices) {

430 avpriv_request_sample(avctx, "%d slices for %dx%d", nslices,

431 avctx->width, avctx->height);

432 return AVERROR_PATCHWELCOME;

433 }

434

435 if ((avctx->width & 3) || (avctx->height & 3)) {

436 avpriv_request_sample(avctx, "Frame dimensions %dx%d",

437 avctx->width, avctx->height);

438 }

439

440 avctx->pix_fmt = AV_PIX_FMT_YUV410P;

441 if ((ret = ff_get_buffer(avctx, pic, 0)) < 0)

442 return ret;

443

444 Y = pic->data[0];

445 U = pic->data[1];

446 V = pic->data[2];

447

448 cur_y = 0;

449 for (slice = 0; slice < nslices; slice++) {

450 slice_size = bytestream2_get_le32(&gb);

451 next_y = ((slice + 1) * avctx->height) / nslices;

452 slice_height = (next_y & ~3) - (cur_y & ~3);

453 if (slice_size > src_size - off) {

454 av_log(avctx, AV_LOG_ERROR,

455 "invalid slice size %"PRIu32" (only %"PRIu32" bytes left)\n",

456 slice_size, src_size - off);

457 return AVERROR_INVALIDDATA;

458 }

459 if (slice_size <= 16) {

460 av_log(avctx, AV_LOG_ERROR, "invalid slice size %"PRIu32"\n", slice_size);

461 return AVERROR_INVALIDDATA;

462 }

463

464 if (AV_RL32(src + off) != slice_size - 16) {

465 av_log(avctx, AV_LOG_ERROR,

466 "Slice sizes mismatch: got %"PRIu32" instead of %"PRIu32"\n",

467 AV_RL32(src + off), slice_size - 16);

468 }

469 if ((ret = init_get_bits8(&gb2, src + off + 16, slice_size - 16)) < 0)

470 return ret;

471 dx2_decode_slice_410(&gb2, avctx->width, slice_height, Y, U, V,

472 pic->linesize[0], pic->linesize[1],

473 pic->linesize[2]);

474

475 Y += pic->linesize[0] * slice_height;

476 U += pic->linesize[1] * (slice_height >> 2);

477 V += pic->linesize[2] * (slice_height >> 2);

478 off += slice_size;

479 cur_y = next_y;

480 }

481

482 return 0;

483 }

484

485 static int dx2_decode_slice_420(GetBitContext *gb, int width, int height,

486 uint8_t *Y, uint8_t *U, uint8_t *V,

487 int ystride, int ustride, int vstride)

488 {

489 int x, y, i;

490 uint8_t lru[3][8];

491

492 for (i = 0; i < 3; i++)

493 memcpy(lru[i], def_lru, 8 * sizeof(*def_lru));

494

495 for (y = 0; y < height; y+=2) {

496 for (x = 0; x < width; x += 2) {

497 Y[x + 0 + 0 * ystride] = decode_sym(gb, lru[0]);

498 Y[x + 1 + 0 * ystride] = decode_sym(gb, lru[0]);

499 Y[x + 0 + 1 * ystride] = decode_sym(gb, lru[0]);

500 Y[x + 1 + 1 * ystride] = decode_sym(gb, lru[0]);

501 U[x >> 1] = decode_sym(gb, lru[1]) ^ 0x80;

502 V[x >> 1] = decode_sym(gb, lru[2]) ^ 0x80;

503 }

504

505 Y += ystride << 1;

506 U += ustride;

507 V += vstride;

508 }

509

510 return 0;

511 }

512

513 static int dxtory_decode_v2_420(AVCodecContext *avctx, AVFrame *pic,

514 const uint8_t *src, int src_size)

515 {

516 GetByteContext gb;

517 GetBitContext gb2;

518 int nslices, slice, slice_height;

519 int cur_y, next_y;

520 uint32_t off, slice_size;

521 uint8_t *Y, *U, *V;

522 int ret;

523

524 bytestream2_init(&gb, src, src_size);

525 nslices = bytestream2_get_le16(&gb);

526 off = FFALIGN(nslices * 4 + 2, 16);

527 if (src_size < off) {

528 av_log(avctx, AV_LOG_ERROR, "no slice data\n");

529 return AVERROR_INVALIDDATA;

530 }

531

532 if (!nslices) {

533 avpriv_request_sample(avctx, "%d slices for %dx%d", nslices,

534 avctx->width, avctx->height);

535 return AVERROR_PATCHWELCOME;

536 }

537

538 if ((avctx->width & 1) || (avctx->height & 1)) {

539 avpriv_request_sample(avctx, "Frame dimensions %dx%d",

540 avctx->width, avctx->height);

541 }

542

543 avctx->pix_fmt = AV_PIX_FMT_YUV420P;

544 if ((ret = ff_get_buffer(avctx, pic, 0)) < 0)

545 return ret;

546

547 Y = pic->data[0];

548 U = pic->data[1];

549 V = pic->data[2];

550

551 cur_y = 0;

552 for (slice = 0; slice < nslices; slice++) {

553 slice_size = bytestream2_get_le32(&gb);

554 next_y = ((slice + 1) * avctx->height) / nslices;

555 slice_height = (next_y & ~1) - (cur_y & ~1);

556 if (slice_size > src_size - off) {

557 av_log(avctx, AV_LOG_ERROR,

558 "invalid slice size %"PRIu32" (only %"PRIu32" bytes left)\n",

559 slice_size, src_size - off);

560 return AVERROR_INVALIDDATA;

561 }

562 if (slice_size <= 16) {

563 av_log(avctx, AV_LOG_ERROR, "invalid slice size %"PRIu32"\n", slice_size);

564 return AVERROR_INVALIDDATA;

565 }

566

567 if (AV_RL32(src + off) != slice_size - 16) {

568 av_log(avctx, AV_LOG_ERROR,

569 "Slice sizes mismatch: got %"PRIu32" instead of %"PRIu32"\n",

570 AV_RL32(src + off), slice_size - 16);

571 }

572 if ((ret = init_get_bits8(&gb2, src + off + 16, slice_size - 16)) < 0)

573 return ret;

574 dx2_decode_slice_420(&gb2, avctx->width, slice_height, Y, U, V,

575 pic->linesize[0], pic->linesize[1],

576 pic->linesize[2]);

577

578 Y += pic->linesize[0] * slice_height;

579 U += pic->linesize[1] * (slice_height >> 1);

580 V += pic->linesize[2] * (slice_height >> 1);

581 off += slice_size;

582 cur_y = next_y;

583 }

584

585 return 0;

586 }

587

588 static int dx2_decode_slice_444(GetBitContext *gb, int width, int height,

589 uint8_t *Y, uint8_t *U, uint8_t *V,

590 int ystride, int ustride, int vstride)

591 {

592 int x, y, i;

593 uint8_t lru[3][8];

594

595 for (i = 0; i < 3; i++)

596 memcpy(lru[i], def_lru, 8 * sizeof(*def_lru));

597

598 for (y = 0; y < height; y++) {

599 for (x = 0; x < width; x++) {

600 Y[x] = decode_sym(gb, lru[0]);

601 U[x] = decode_sym(gb, lru[1]) ^ 0x80;

602 V[x] = decode_sym(gb, lru[2]) ^ 0x80;

603 }

604

605 Y += ystride;

606 U += ustride;

607 V += vstride;

608 }

609

610 return 0;

611 }

612

613 static int dxtory_decode_v2_444(AVCodecContext *avctx, AVFrame *pic,

614 const uint8_t *src, int src_size)

615 {

616 GetByteContext gb;

617 GetBitContext gb2;

618 int nslices, slice, slice_height;

619 uint32_t off, slice_size;

620 uint8_t *Y, *U, *V;

621 int ret;

622

623 bytestream2_init(&gb, src, src_size);

624 nslices = bytestream2_get_le16(&gb);

625 off = FFALIGN(nslices * 4 + 2, 16);

626 if (src_size < off) {

627 av_log(avctx, AV_LOG_ERROR, "no slice data\n");

628 return AVERROR_INVALIDDATA;

629 }

630

631 if (!nslices || avctx->height % nslices) {

632 avpriv_request_sample(avctx, "%d slices for %dx%d", nslices,

633 avctx->width, avctx->height);

634 return AVERROR_PATCHWELCOME;

635 }

636

637 slice_height = avctx->height / nslices;

638

639 avctx->pix_fmt = AV_PIX_FMT_YUV444P;

640 if ((ret = ff_get_buffer(avctx, pic, 0)) < 0)

641 return ret;

642

643 Y = pic->data[0];

644 U = pic->data[1];

645 V = pic->data[2];

646

647 for (slice = 0; slice < nslices; slice++) {

648 slice_size = bytestream2_get_le32(&gb);

649 if (slice_size > src_size - off) {

650 av_log(avctx, AV_LOG_ERROR,

651 "invalid slice size %"PRIu32" (only %"PRIu32" bytes left)\n",

652 slice_size, src_size - off);

653 return AVERROR_INVALIDDATA;

654 }

655 if (slice_size <= 16) {

656 av_log(avctx, AV_LOG_ERROR, "invalid slice size %"PRIu32"\n", slice_size);

657 return AVERROR_INVALIDDATA;

658 }

659

660 if (AV_RL32(src + off) != slice_size - 16) {

661 av_log(avctx, AV_LOG_ERROR,

662 "Slice sizes mismatch: got %"PRIu32" instead of %"PRIu32"\n",

663 AV_RL32(src + off), slice_size - 16);

664 }

665 if ((ret = init_get_bits8(&gb2, src + off + 16, slice_size - 16)) < 0)

666 return ret;

667 dx2_decode_slice_444(&gb2, avctx->width, slice_height, Y, U, V,

668 pic->linesize[0], pic->linesize[1],

669 pic->linesize[2]);

670

671 Y += pic->linesize[0] * slice_height;

672 U += pic->linesize[1] * slice_height;

673 V += pic->linesize[2] * slice_height;

674 off += slice_size;

675 }

676

677 return 0;

678 }

679

680 static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame,

681 AVPacket *avpkt)

682 {

683 AVFrame *pic = data;

684 const uint8_t *src = avpkt->data;

685 int ret;

686

687 if (avpkt->size < 16) {

688 av_log(avctx, AV_LOG_ERROR, "packet too small\n");

689 return AVERROR_INVALIDDATA;

690 }

691

692 switch (AV_RB32(src)) {

693 case 0x01000001:

694 ret = dxtory_decode_v1_rgb(avctx, pic, src + 16, avpkt->size - 16,

695 AV_PIX_FMT_BGR24, 3);

696 break;

697 case 0x01000009:

698 ret = dxtory_decode_v2_rgb(avctx, pic, src + 16, avpkt->size - 16);

699 break;

700 case 0x02000001:

701 ret = dxtory_decode_v1_420(avctx, pic, src + 16, avpkt->size - 16);

702 break;

703 case 0x02000009:

704 ret = dxtory_decode_v2_420(avctx, pic, src + 16, avpkt->size - 16);

705 break;

706 case 0x03000001:

707 ret = dxtory_decode_v1_410(avctx, pic, src + 16, avpkt->size - 16);

708 break;

709 case 0x03000009:

710 ret = dxtory_decode_v2_410(avctx, pic, src + 16, avpkt->size - 16);

711 break;

712 case 0x04000001:

713 ret = dxtory_decode_v1_444(avctx, pic, src + 16, avpkt->size - 16);

714 break;

715 case 0x04000009:

716 ret = dxtory_decode_v2_444(avctx, pic, src + 16, avpkt->size - 16);

717 break;

718 case 0x17000001:

719 ret = dxtory_decode_v1_rgb(avctx, pic, src + 16, avpkt->size - 16,

720 AV_PIX_FMT_RGB565LE, 2);

721 break;

722 case 0x17000009:

723 ret = dxtory_decode_v2_565(avctx, pic, src + 16, avpkt->size - 16, 1);

724 break;

725 case 0x18000001:

726 case 0x19000001:

727 ret = dxtory_decode_v1_rgb(avctx, pic, src + 16, avpkt->size - 16,

728 AV_PIX_FMT_RGB555LE, 2);

729 break;

730 case 0x18000009:

731 case 0x19000009:

732 ret = dxtory_decode_v2_565(avctx, pic, src + 16, avpkt->size - 16, 0);

733 break;

734 default:

735 avpriv_request_sample(avctx, "Frame header %"PRIX32, AV_RB32(src));

736 return AVERROR_PATCHWELCOME;

737 }

738

739 if (ret)

740 return ret;

741

742 pic->pict_type = AV_PICTURE_TYPE_I;

743 pic->key_frame = 1;

744 *got_frame = 1;

745

746 return avpkt->size;

747 }

748

749 AVCodec ff_dxtory_decoder = {

750 .name = "dxtory",

751 .long_name = NULL_IF_CONFIG_SMALL("Dxtory"),

752 .type = AVMEDIA_TYPE_VIDEO,

753 .id = AV_CODEC_ID_DXTORY,

754 .decode = decode_frame,

755 .capabilities = CODEC_CAP_DR1,

756 };

dx2_decode_slice_444

static int dx2_decode_slice_444(GetBitContext *gb, int width, int height, uint8_t *Y, uint8_t *U, uint8_t *V, int ystride, int ustride, int vstride)

Definition: dxtory.c:588

dxtory_decode_v2_rgb

static int dxtory_decode_v2_rgb(AVCodecContext *avctx, AVFrame *pic, const uint8_t *src, int src_size)

Definition: dxtory.c:322

val

const char const char void * val

Definition: avisynth_c.h:634

GetByteContext

Definition: bytestream.h:33

dx2_decode_slice_rgb

static int dx2_decode_slice_rgb(GetBitContext *gb, int width, int height, uint8_t *dst, int stride)

Definition: dxtory.c:300

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

Definition: vp9dsp_template.c:2093

data

ptrdiff_t const GLvoid * data

Definition: opengl_enc.c:101

enum AVCodecID id

Definition: mxfenc.c:99

AV_PIX_FMT_YUV444P

planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)

Definition: pixfmt.h:68

get_bits

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

Read 1-25 bits.

Definition: get_bits.h:260

AV_PIX_FMT_RGB24

packed RGB 8:8:8, 24bpp, RGBRGB...

Definition: pixfmt.h:65

AV_CODEC_ID_DXTORY

Definition: avcodec.h:264

const char * g

Definition: vf_curves.c:108

AV_PIX_FMT_RGB555LE

packed RGB 5:5:5, 16bpp, (msb)1X 5R 5G 5B(lsb), little-endian, X=unused/undefined ...

Definition: pixfmt.h:117

AVPacket::size

int size

Definition: avcodec.h:1163

const char * b

Definition: vf_curves.c:109

def_lru_555

static const uint8_t def_lru_555[8]

Definition: dxtory.c:175

AVCodecContext::pix_fmt

enum AVPixelFormat pix_fmt

Pixel format, see AV_PIX_FMT_xxx.

Definition: avcodec.h:1444

bytestream2_init

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

Definition: bytestream.h:131

AVCodec

AVCodec.

Definition: avcodec.h:3181

dxtory_decode_v2_420

static int dxtory_decode_v2_420(AVCodecContext *avctx, AVFrame *pic, const uint8_t *src, int src_size)

Definition: dxtory.c:513

FFALIGN

#define FFALIGN(x, a)

Definition: common.h:71

AV_PIX_FMT_RGB565LE

packed RGB 5:6:5, 16bpp, (msb) 5R 6G 5B(lsb), little-endian

Definition: pixfmt.h:115

avpriv_request_sample

void void avpriv_request_sample(void *avc, const char *msg,...) av_printf_format(2

Log a generic warning message about a missing feature.

bits

uint8_t bits

Definition: crc.c:295

uint8_t

Definition: audio_convert.c:194

#define Y

Definition: vf_boxblur.c:76

dxtory_decode_v2_444

static int dxtory_decode_v2_444(AVCodecContext *avctx, AVFrame *pic, const uint8_t *src, int src_size)

Definition: dxtory.c:613

dxtory_decode_v1_420

static int dxtory_decode_v1_420(AVCodecContext *avctx, AVFrame *pic, const uint8_t *src, int src_size)

Definition: dxtory.c:104

AV_RB32

uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_RB32

Definition: bytestream.h:85

CODEC_CAP_DR1

#define CODEC_CAP_DR1

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

Definition: avcodec.h:789

dxtory_decode_v1_410

static int dxtory_decode_v1_410(AVCodecContext *avctx, AVFrame *pic, const uint8_t *src, int src_size)

Definition: dxtory.c:61

AVPacket::data

uint8_t * data

Definition: avcodec.h:1162

get_bits.h

bitstream reader API header.

dxtory_decode_v1_444

static int dxtory_decode_v1_444(AVCodecContext *avctx, AVFrame *pic, const uint8_t *src, int src_size)

Definition: dxtory.c:141

av_log

#define av_log(a,...)

Definition: tableprint_vlc.h:28

#define U(x)

Definition: vp56_arith.h:37

def_lru

static const uint8_t def_lru[8]

Definition: dxtory.c:174

AV_LOG_ERROR

#define AV_LOG_ERROR

Something went wrong and cannot losslessly be recovered.

Definition: log.h:176

dx2_decode_slice_420

static int dx2_decode_slice_420(GetBitContext *gb, int width, int height, uint8_t *Y, uint8_t *U, uint8_t *V, int ystride, int ustride, int vstride)

Definition: dxtory.c:485

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

const char * r

Definition: vf_curves.c:107

AVCodec::name

const char * name

Name of the codec implementation.

Definition: avcodec.h:3188

avcodec.h

Libavcodec external API header.

bytestream.h

AV_PICTURE_TYPE_I

Intra.

Definition: avutil.h:267

AVFrame::pict_type

enum AVPictureType pict_type

Picture type of the frame.

Definition: frame.h:242

AV_COPY16

#define AV_COPY16(d, s)

Definition: intreadwrite.h:582

float y

Definition: avf_showspectrum.c:96

intreadwrite.h

ret

Definition: avfilter.c:974

AVCodecContext::width

int width

picture width / height.

Definition: avcodec.h:1414

AV_COPY32U

#define AV_COPY32U(d, s)

Definition: intreadwrite.h:557

AV_PIX_FMT_BGR24

packed RGB 8:8:8, 24bpp, BGRBGR...

Definition: pixfmt.h:66

decode_sym

static uint8_t decode_sym(GetBitContext *gb, uint8_t lru[8])

Definition: dxtory.c:178

dxtory_decode_v2_410

static int dxtory_decode_v2_410(AVCodecContext *avctx, AVFrame *pic, const uint8_t *src, int src_size)

Definition: dxtory.c:410

AVCodecContext::height

int height

Definition: avcodec.h:1414

AVERROR_PATCHWELCOME

#define AVERROR_PATCHWELCOME

Not yet implemented in FFmpeg, patches welcome.

Definition: error.h:62

ff_dxtory_decoder

AVCodec ff_dxtory_decoder

Definition: dxtory.c:749

src

AVS_Value src

Definition: avisynth_c.h:482

AVFrame::linesize

int linesize[AV_NUM_DATA_POINTERS]

For video, size in bytes of each picture line.

Definition: frame.h:199

dxtory_decode_v2_565

static int dxtory_decode_v2_565(AVCodecContext *avctx, AVFrame *pic, const uint8_t *src, int src_size, int is_565)

Definition: dxtory.c:240

init_get_bits8

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

Initialize GetBitContext.

Definition: get_bits.h:441

AVCodecContext

main external API structure.

Definition: avcodec.h:1241

ff_get_buffer

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

Get a buffer for a frame.

Definition: utils.c:1035

height

BYTE int const BYTE int int int height

Definition: avisynth_c.h:676

AV_PIX_FMT_YUV410P

planar YUV 4:1:0, 9bpp, (1 Cr & Cb sample per 4x4 Y samples)

Definition: pixfmt.h:69

unary.h

dx2_decode_slice_565

static int dx2_decode_slice_565(GetBitContext *gb, int width, int height, uint8_t *dst, int stride, int is_565)

Definition: dxtory.c:213

AVFrame::data

uint8_t * data[AV_NUM_DATA_POINTERS]

pointer to the picture/channel planes.

Definition: frame.h:182

def_lru_565

static const uint8_t def_lru_565[8]

Definition: dxtory.c:176

stride

GLint GLenum GLboolean GLsizei stride

Definition: opengl_enc.c:105

AV_PIX_FMT_YUV420P

planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)

Definition: pixfmt.h:63

GetBitContext

Definition: get_bits.h:54

internal.h

common internal api header.

common.h

common internal and external API header

get_unary

static int get_unary(GetBitContext *gb, int stop, int len)

Get unary code of limited length.

Definition: unary.h:33

static double c[64]

Definition: vsrc_mptestsrc.c:87

AVFrame::key_frame

int key_frame

1 -> keyframe, 0-> not

Definition: frame.h:237

dx2_decode_slice_410

static int dx2_decode_slice_410(GetBitContext *gb, int width, int height, uint8_t *Y, uint8_t *U, uint8_t *V, int ystride, int ustride, int vstride)

Definition: dxtory.c:383

dxtory_decode_v1_rgb

static int dxtory_decode_v1_rgb(AVCodecContext *avctx, AVFrame *pic, const uint8_t *src, int src_size, int id, int bpp)

Definition: dxtory.c:34

AVMEDIA_TYPE_VIDEO

Definition: avutil.h:194

stride

#define stride

AV_RL32

uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32

Definition: bytestream.h:85

AVPacket

This structure stores compressed data.

Definition: avcodec.h:1139

decode_sym_565

static uint8_t decode_sym_565(GetBitContext *gb, uint8_t lru[8], int bits)

Definition: dxtory.c:195

#define V

Definition: avdct.c:30

decode_frame

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

Definition: dxtory.c:680

width

static int width

Definition: demuxing_decoding.c:39

Generated on Wed Jun 10 2015 01:56:39 for FFmpeg by doxygen 1.8.6