FFmpeg: libavcodec/utvideodec.c Source File

FFmpeg

[フレーム]

libavcodec

utvideodec.c

Go to the documentation of this file.

1 /*

2 * Ut Video 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 * Ut Video decoder

25 */

27 #include <stdlib.h>

29 #include "libavutil/intreadwrite.h"

30 #include "avcodec.h"

31 #include "bytestream.h"

32 #include "get_bits.h"

33 #include "dsputil.h"

34 #include "thread.h"

35 #include "utvideo.h"

37 static int build_huff(const uint8_t *src, VLC *vlc, int *fsym)

38 {

39 int i;

40 HuffEntry he[256];

41 int last;

42 uint32_t codes[256];

43 uint8_t bits[256];

44 uint8_t syms[256];

45 uint32_t code;

47 *fsym = -1;

48 for (i = 0; i < 256; i++) {

49 he[i].sym = i;

50 he[i].len = *src++;

51 }

52 qsort(he, 256, sizeof(*he), ff_ut_huff_cmp_len);

54 if (!he[0].len) {

55 *fsym = he[0].sym;

56 return 0;

57 }

58 if (he[0].len > 32)

59 return -1;

61 last = 255;

62 while (he[last].len == 255 && last)

63 last--;

65 code = 1;

66 for (i = last; i >= 0; i--) {

67 codes[i] = code >> (32 - he[i].len);

68 bits[i] = he[i].len;

69 syms[i] = he[i].sym;

70 code += 0x80000000u >> (he[i].len - 1);

71 }

73 return ff_init_vlc_sparse(vlc, FFMIN(he[last].len, 10), last + 1,

74 bits, sizeof(*bits), sizeof(*bits),

75 codes, sizeof(*codes), sizeof(*codes),

76 syms, sizeof(*syms), sizeof(*syms), 0);

77 }

79 static int decode_plane(UtvideoContext *c, int plane_no,

80 uint8_t *dst, int step, int stride,

81 int width, int height,

82 const uint8_t *src, int use_pred)

83 {

84 int i, j, slice, pix;

85 int sstart, send;

86 VLC vlc;

87 GetBitContext gb;

88 int prev, fsym;

89 const int cmask = ~(!plane_no && c->avctx->pix_fmt == AV_PIX_FMT_YUV420P);

91 if (build_huff(src, &vlc, &fsym)) {

92 av_log(c->avctx, AV_LOG_ERROR, "Cannot build Huffman codes\n");

93 return AVERROR_INVALIDDATA;

94 }

95 if (fsym >= 0) { // build_huff reported a symbol to fill slices with

96 send = 0;

97 for (slice = 0; slice < c->slices; slice++) {

98 uint8_t *dest;

100 sstart = send;

101 send = (height * (slice + 1) / c->slices) & cmask;

102 dest = dst + sstart * stride;

103

104 prev = 0x80;

105 for (j = sstart; j < send; j++) {

106 for (i = 0; i < width * step; i += step) {

107 pix = fsym;

108 if (use_pred) {

109 prev += pix;

110 pix = prev;

111 }

112 dest[i] = pix;

113 }

114 dest += stride;

115 }

116 }

117 return 0;

118 }

119

120 src += 256;

121

122 send = 0;

123 for (slice = 0; slice < c->slices; slice++) {

124 uint8_t *dest;

125 int slice_data_start, slice_data_end, slice_size;

126

127 sstart = send;

128 send = (height * (slice + 1) / c->slices) & cmask;

129 dest = dst + sstart * stride;

130

131 // slice offset and size validation was done earlier

132 slice_data_start = slice ? AV_RL32(src + slice * 4 - 4) : 0;

133 slice_data_end = AV_RL32(src + slice * 4);

134 slice_size = slice_data_end - slice_data_start;

135

136 if (!slice_size) {

137 av_log(c->avctx, AV_LOG_ERROR, "Plane has more than one symbol "

138 "yet a slice has a length of zero.\n");

139 goto fail;

140 }

141

142 memcpy(c->slice_bits, src + slice_data_start + c->slices * 4,

143 slice_size);

144 memset(c->slice_bits + slice_size, 0, FF_INPUT_BUFFER_PADDING_SIZE);

145 c->dsp.bswap_buf((uint32_t *) c->slice_bits, (uint32_t *) c->slice_bits,

146 (slice_data_end - slice_data_start + 3) >> 2);

147 init_get_bits(&gb, c->slice_bits, slice_size * 8);

148

149 prev = 0x80;

150 for (j = sstart; j < send; j++) {

151 for (i = 0; i < width * step; i += step) {

152 if (get_bits_left(&gb) <= 0) {

153 av_log(c->avctx, AV_LOG_ERROR,

154 "Slice decoding ran out of bits\n");

155 goto fail;

156 }

157 pix = get_vlc2(&gb, vlc.table, vlc.bits, 4);

158 if (pix < 0) {

159 av_log(c->avctx, AV_LOG_ERROR, "Decoding error\n");

160 goto fail;

161 }

162 if (use_pred) {

163 prev += pix;

164 pix = prev;

165 }

166 dest[i] = pix;

167 }

168 dest += stride;

169 }

170 if (get_bits_left(&gb) > 32)

171 av_log(c->avctx, AV_LOG_WARNING,

172 "%d bits left after decoding slice\n", get_bits_left(&gb));

173 }

174

175 ff_free_vlc(&vlc);

176

177 return 0;

178 fail:

179 ff_free_vlc(&vlc);

180 return AVERROR_INVALIDDATA;

181 }

182

183 static void restore_rgb_planes(uint8_t *src, int step, int stride, int width,

184 int height)

185 {

186 int i, j;

187 uint8_t r, g, b;

188

189 for (j = 0; j < height; j++) {

190 for (i = 0; i < width * step; i += step) {

191 r = src[i];

192 g = src[i + 1];

193 b = src[i + 2];

194 src[i] = r + g - 0x80;

195 src[i + 2] = b + g - 0x80;

196 }

197 src += stride;

198 }

199 }

200

201 static void restore_median(uint8_t *src, int step, int stride,

202 int width, int height, int slices, int rmode)

203 {

204 int i, j, slice;

205 int A, B, C;

206 uint8_t *bsrc;

207 int slice_start, slice_height;

208 const int cmask = ~rmode;

209

210 for (slice = 0; slice < slices; slice++) {

211 slice_start = ((slice * height) / slices) & cmask;

212 slice_height = ((((slice + 1) * height) / slices) & cmask) -

213 slice_start;

214

215 bsrc = src + slice_start * stride;

216

217 // first line - left neighbour prediction

218 bsrc[0] += 0x80;

219 A = bsrc[0];

220 for (i = step; i < width * step; i += step) {

221 bsrc[i] += A;

222 A = bsrc[i];

223 }

224 bsrc += stride;

225 if (slice_height == 1)

226 continue;

227 // second line - first element has top prediction, the rest uses median

228 C = bsrc[-stride];

229 bsrc[0] += C;

230 A = bsrc[0];

231 for (i = step; i < width * step; i += step) {

232 B = bsrc[i - stride];

233 bsrc[i] += mid_pred(A, B, (uint8_t)(A + B - C));

234 C = B;

235 A = bsrc[i];

236 }

237 bsrc += stride;

238 // the rest of lines use continuous median prediction

239 for (j = 2; j < slice_height; j++) {

240 for (i = 0; i < width * step; i += step) {

241 B = bsrc[i - stride];

242 bsrc[i] += mid_pred(A, B, (uint8_t)(A + B - C));

243 C = B;

244 A = bsrc[i];

245 }

246 bsrc += stride;

247 }

248 }

249 }

250

251 /* UtVideo interlaced mode treats every two lines as a single one,

252 * so restoring function should take care of possible padding between

253 * two parts of the same "line".

254 */

255 static void restore_median_il(uint8_t *src, int step, int stride,

256 int width, int height, int slices, int rmode)

257 {

258 int i, j, slice;

259 int A, B, C;

260 uint8_t *bsrc;

261 int slice_start, slice_height;

262 const int cmask = ~(rmode ? 3 : 1);

263 const int stride2 = stride << 1;

264

265 for (slice = 0; slice < slices; slice++) {

266 slice_start = ((slice * height) / slices) & cmask;

267 slice_height = ((((slice + 1) * height) / slices) & cmask) -

268 slice_start;

269 slice_height >>= 1;

270

271 bsrc = src + slice_start * stride;

272

273 // first line - left neighbour prediction

274 bsrc[0] += 0x80;

275 A = bsrc[0];

276 for (i = step; i < width * step; i += step) {

277 bsrc[i] += A;

278 A = bsrc[i];

279 }

280 for (i = 0; i < width * step; i += step) {

281 bsrc[stride + i] += A;

282 A = bsrc[stride + i];

283 }

284 bsrc += stride2;

285 if (slice_height == 1)

286 continue;

287 // second line - first element has top prediction, the rest uses median

288 C = bsrc[-stride2];

289 bsrc[0] += C;

290 A = bsrc[0];

291 for (i = step; i < width * step; i += step) {

292 B = bsrc[i - stride2];

293 bsrc[i] += mid_pred(A, B, (uint8_t)(A + B - C));

294 C = B;

295 A = bsrc[i];

296 }

297 for (i = 0; i < width * step; i += step) {

298 B = bsrc[i - stride];

299 bsrc[stride + i] += mid_pred(A, B, (uint8_t)(A + B - C));

300 C = B;

301 A = bsrc[stride + i];

302 }

303 bsrc += stride2;

304 // the rest of lines use continuous median prediction

305 for (j = 2; j < slice_height; j++) {

306 for (i = 0; i < width * step; i += step) {

307 B = bsrc[i - stride2];

308 bsrc[i] += mid_pred(A, B, (uint8_t)(A + B - C));

309 C = B;

310 A = bsrc[i];

311 }

312 for (i = 0; i < width * step; i += step) {

313 B = bsrc[i - stride];

314 bsrc[i + stride] += mid_pred(A, B, (uint8_t)(A + B - C));

315 C = B;

316 A = bsrc[i + stride];

317 }

318 bsrc += stride2;

319 }

320 }

321 }

322

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

324 AVPacket *avpkt)

325 {

326 const uint8_t *buf = avpkt->data;

327 int buf_size = avpkt->size;

328 UtvideoContext *c = avctx->priv_data;

329 int i, j;

330 const uint8_t *plane_start[5];

331 int plane_size, max_slice_size = 0, slice_start, slice_end, slice_size;

332 int ret;

333 GetByteContext gb;

334 ThreadFrame frame = { .f = data };

335

336 if ((ret = ff_thread_get_buffer(avctx, &frame, 0)) < 0)

337 return ret;

338

339 /* parse plane structure to get frame flags and validate slice offsets */

340 bytestream2_init(&gb, buf, buf_size);

341 for (i = 0; i < c->planes; i++) {

342 plane_start[i] = gb.buffer;

343 if (bytestream2_get_bytes_left(&gb) < 256 + 4 * c->slices) {

344 av_log(avctx, AV_LOG_ERROR, "Insufficient data for a plane\n");

345 return AVERROR_INVALIDDATA;

346 }

347 bytestream2_skipu(&gb, 256);

348 slice_start = 0;

349 slice_end = 0;

350 for (j = 0; j < c->slices; j++) {

351 slice_end = bytestream2_get_le32u(&gb);

352 slice_size = slice_end - slice_start;

353 if (slice_end < 0 || slice_size < 0 ||

354 bytestream2_get_bytes_left(&gb) < slice_end) {

355 av_log(avctx, AV_LOG_ERROR, "Incorrect slice size\n");

356 return AVERROR_INVALIDDATA;

357 }

358 slice_start = slice_end;

359 max_slice_size = FFMAX(max_slice_size, slice_size);

360 }

361 plane_size = slice_end;

362 bytestream2_skipu(&gb, plane_size);

363 }

364 plane_start[c->planes] = gb.buffer;

365 if (bytestream2_get_bytes_left(&gb) < c->frame_info_size) {

366 av_log(avctx, AV_LOG_ERROR, "Not enough data for frame information\n");

367 return AVERROR_INVALIDDATA;

368 }

369 c->frame_info = bytestream2_get_le32u(&gb);

370 av_log(avctx, AV_LOG_DEBUG, "frame information flags %X\n", c->frame_info);

371

372 c->frame_pred = (c->frame_info >> 8) & 3;

373

374 if (c->frame_pred == PRED_GRADIENT) {

375 avpriv_request_sample(avctx, "Frame with gradient prediction");

376 return AVERROR_PATCHWELCOME;

377 }

378

379 av_fast_malloc(&c->slice_bits, &c->slice_bits_size,

380 max_slice_size + FF_INPUT_BUFFER_PADDING_SIZE);

381

382 if (!c->slice_bits) {

383 av_log(avctx, AV_LOG_ERROR, "Cannot allocate temporary buffer\n");

384 return AVERROR(ENOMEM);

385 }

386

387 switch (c->avctx->pix_fmt) {

388 case AV_PIX_FMT_RGB24:

389 case AV_PIX_FMT_RGBA:

390 for (i = 0; i < c->planes; i++) {

391 ret = decode_plane(c, i, frame.f->data[0] + ff_ut_rgb_order[i],

392 c->planes, frame.f->linesize[0], avctx->width,

393 avctx->height, plane_start[i],

394 c->frame_pred == PRED_LEFT);

395 if (ret)

396 return ret;

397 if (c->frame_pred == PRED_MEDIAN) {

398 if (!c->interlaced) {

399 restore_median(frame.f->data[0] + ff_ut_rgb_order[i],

400 c->planes, frame.f->linesize[0], avctx->width,

401 avctx->height, c->slices, 0);

402 } else {

403 restore_median_il(frame.f->data[0] + ff_ut_rgb_order[i],

404 c->planes, frame.f->linesize[0],

405 avctx->width, avctx->height, c->slices,

406 0);

407 }

408 }

409 }

410 restore_rgb_planes(frame.f->data[0], c->planes, frame.f->linesize[0],

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

412 break;

413 case AV_PIX_FMT_YUV420P:

414 for (i = 0; i < 3; i++) {

415 ret = decode_plane(c, i, frame.f->data[i], 1, frame.f->linesize[i],

416 avctx->width >> !!i, avctx->height >> !!i,

417 plane_start[i], c->frame_pred == PRED_LEFT);

418 if (ret)

419 return ret;

420 if (c->frame_pred == PRED_MEDIAN) {

421 if (!c->interlaced) {

422 restore_median(frame.f->data[i], 1, frame.f->linesize[i],

423 avctx->width >> !!i, avctx->height >> !!i,

424 c->slices, !i);

425 } else {

426 restore_median_il(frame.f->data[i], 1, frame.f->linesize[i],

427 avctx->width >> !!i,

428 avctx->height >> !!i,

429 c->slices, !i);

430 }

431 }

432 }

433 break;

434 case AV_PIX_FMT_YUV422P:

435 for (i = 0; i < 3; i++) {

436 ret = decode_plane(c, i, frame.f->data[i], 1, frame.f->linesize[i],

437 avctx->width >> !!i, avctx->height,

438 plane_start[i], c->frame_pred == PRED_LEFT);

439 if (ret)

440 return ret;

441 if (c->frame_pred == PRED_MEDIAN) {

442 if (!c->interlaced) {

443 restore_median(frame.f->data[i], 1, frame.f->linesize[i],

444 avctx->width >> !!i, avctx->height,

445 c->slices, 0);

446 } else {

447 restore_median_il(frame.f->data[i], 1, frame.f->linesize[i],

448 avctx->width >> !!i, avctx->height,

449 c->slices, 0);

450 }

451 }

452 }

453 break;

454 }

455

456 frame.f->key_frame = 1;

457 frame.f->pict_type = AV_PICTURE_TYPE_I;

458 frame.f->interlaced_frame = !!c->interlaced;

459

460 *got_frame = 1;

461

462 /* always report that the buffer was completely consumed */

463 return buf_size;

464 }

465

466 static av_cold int decode_init(AVCodecContext *avctx)

467 {

468 UtvideoContext * const c = avctx->priv_data;

469

470 c->avctx = avctx;

471

472 ff_dsputil_init(&c->dsp, avctx);

473

474 if (avctx->extradata_size < 16) {

475 av_log(avctx, AV_LOG_ERROR,

476 "Insufficient extradata size %d, should be at least 16\n",

477 avctx->extradata_size);

478 return AVERROR_INVALIDDATA;

479 }

480

481 av_log(avctx, AV_LOG_DEBUG, "Encoder version %d.%d.%d.%d\n",

482 avctx->extradata[3], avctx->extradata[2],

483 avctx->extradata[1], avctx->extradata[0]);

484 av_log(avctx, AV_LOG_DEBUG, "Original format %X\n",

485 AV_RB32(avctx->extradata + 4));

486 c->frame_info_size = AV_RL32(avctx->extradata + 8);

487 c->flags = AV_RL32(avctx->extradata + 12);

488

489 if (c->frame_info_size != 4)

490 avpriv_request_sample(avctx, "Frame info not 4 bytes");

491 av_log(avctx, AV_LOG_DEBUG, "Encoding parameters %08X\n", c->flags);

492 c->slices = (c->flags >> 24) + 1;

493 c->compression = c->flags & 1;

494 c->interlaced = c->flags & 0x800;

495

496 c->slice_bits_size = 0;

497

498 switch (avctx->codec_tag) {

499 case MKTAG('U', 'L', 'R', 'G'):

500 c->planes = 3;

501 avctx->pix_fmt = AV_PIX_FMT_RGB24;

502 break;

503 case MKTAG('U', 'L', 'R', 'A'):

504 c->planes = 4;

505 avctx->pix_fmt = AV_PIX_FMT_RGBA;

506 break;

507 case MKTAG('U', 'L', 'Y', '0'):

508 c->planes = 3;

509 avctx->pix_fmt = AV_PIX_FMT_YUV420P;

510 avctx->colorspace = AVCOL_SPC_BT470BG;

511 break;

512 case MKTAG('U', 'L', 'Y', '2'):

513 c->planes = 3;

514 avctx->pix_fmt = AV_PIX_FMT_YUV422P;

515 avctx->colorspace = AVCOL_SPC_BT470BG;

516 break;

517 case MKTAG('U', 'L', 'H', '0'):

518 c->planes = 3;

519 avctx->pix_fmt = AV_PIX_FMT_YUV420P;

520 avctx->colorspace = AVCOL_SPC_BT709;

521 break;

522 case MKTAG('U', 'L', 'H', '2'):

523 c->planes = 3;

524 avctx->pix_fmt = AV_PIX_FMT_YUV422P;

525 avctx->colorspace = AVCOL_SPC_BT709;

526 break;

527 default:

528 av_log(avctx, AV_LOG_ERROR, "Unknown Ut Video FOURCC provided (%08X)\n",

529 avctx->codec_tag);

530 return AVERROR_INVALIDDATA;

531 }

532

533 return 0;

534 }

535

536 static av_cold int decode_end(AVCodecContext *avctx)

537 {

538 UtvideoContext * const c = avctx->priv_data;

539

540 av_freep(&c->slice_bits);

541

542 return 0;

543 }

544

545 AVCodec ff_utvideo_decoder = {

546 .name = "utvideo",

547 .long_name = NULL_IF_CONFIG_SMALL("Ut Video"),

548 .type = AVMEDIA_TYPE_VIDEO,

549 .id = AV_CODEC_ID_UTVIDEO,

550 .priv_data_size = sizeof(UtvideoContext),

551 .init = decode_init,

552 .close = decode_end,

553 .decode = decode_frame,

554 .capabilities = CODEC_CAP_DR1 | CODEC_CAP_FRAME_THREADS,

555 };

Generated on Sat Jan 25 2014 19:51:56 for FFmpeg by doxygen 1.8.2