FFmpeg: libavcodec/dvdec.c Source File

FFmpeg

[フレーム]

libavcodec

dvdec.c

Go to the documentation of this file.

1 /*

2 * DV decoder

5 *

6 * 50 Mbps (DVCPRO50) support

8 *

9 * 100 Mbps (DVCPRO HD) support

10 * Initial code by Daniel Maas <dmaas@maasdigital.com> (funded by BBC R&D)

11 * Final code by Roman Shaposhnik

12 *

13 * Many thanks to Dan Dennedy <dan@dennedy.org> for providing wealth

14 * of DV technical info.

15 *

16 * This file is part of FFmpeg.

17 *

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

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

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

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

22 *

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

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

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

26 * Lesser General Public License for more details.

27 *

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

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

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

31 */

33 /**

34 * @file

35 * DV decoder

36 */

38 #include "libavutil/avassert.h"

39 #include "libavutil/imgutils.h"

40 #include "libavutil/internal.h"

41 #include "libavutil/pixdesc.h"

43 #include "avcodec.h"

44 #include "dv.h"

45 #include "dv_profile_internal.h"

46 #include "dvdata.h"

47 #include "get_bits.h"

48 #include "idctdsp.h"

49 #include "internal.h"

50 #include "put_bits.h"

51 #include "simple_idct.h"

53 typedef struct BlockInfo {

54 const uint32_t *factor_table;

55 const uint8_t *scan_table;

56 uint8_t pos; /* position in block */

57 void (*idct_put)(uint8_t *dest, int line_size, int16_t *block);

58 uint8_t partial_bit_count;

59 uint32_t partial_bit_buffer;

60 int shift_offset;

61 } BlockInfo;

63 static const int dv_iweight_bits = 14;

65 static const uint16_t dv_iweight_88[64] = {

66 32768, 16705, 16705, 17734, 17032, 17734, 18205, 18081,

67 18081, 18205, 18725, 18562, 19195, 18562, 18725, 19266,

68 19091, 19705, 19705, 19091, 19266, 21407, 19643, 20267,

69 20228, 20267, 19643, 21407, 22725, 21826, 20853, 20806,

70 20806, 20853, 21826, 22725, 23170, 23170, 21407, 21400,

71 21407, 23170, 23170, 24598, 23786, 22018, 22018, 23786,

72 24598, 25251, 24465, 22654, 24465, 25251, 25972, 25172,

73 25172, 25972, 26722, 27969, 26722, 29692, 29692, 31521,

74 };

75 static const uint16_t dv_iweight_248[64] = {

76 32768, 16384, 16705, 16705, 17734, 17734, 17734, 17734,

77 18081, 18081, 18725, 18725, 21407, 21407, 19091, 19091,

78 19195, 19195, 18205, 18205, 18725, 18725, 19705, 19705,

79 20267, 20267, 21826, 21826, 23170, 23170, 20806, 20806,

80 20267, 20267, 19266, 19266, 21407, 21407, 20853, 20853,

81 21400, 21400, 23786, 23786, 24465, 24465, 22018, 22018,

82 23170, 23170, 22725, 22725, 24598, 24598, 24465, 24465,

83 25172, 25172, 27969, 27969, 25972, 25972, 29692, 29692

84 };

86 /**

87 * The "inverse" DV100 weights are actually just the spec weights (zig-zagged).

88 */

89 static const uint16_t dv_iweight_1080_y[64] = {

90 128, 16, 16, 17, 17, 17, 18, 18,

91 18, 18, 18, 18, 19, 18, 18, 19,

92 19, 19, 19, 19, 19, 42, 38, 40,

93 40, 40, 38, 42, 44, 43, 41, 41,

94 41, 41, 43, 44, 45, 45, 42, 42,

95 42, 45, 45, 48, 46, 43, 43, 46,

96 48, 49, 48, 44, 48, 49, 101, 98,

97 98, 101, 104, 109, 104, 116, 116, 123,

98 };

99 static const uint16_t dv_iweight_1080_c[64] = {

100 128, 16, 16, 17, 17, 17, 25, 25,

101 25, 25, 26, 25, 26, 25, 26, 26,

102 26, 27, 27, 26, 26, 42, 38, 40,

103 40, 40, 38, 42, 44, 43, 41, 41,

104 41, 41, 43, 44, 91, 91, 84, 84,

105 84, 91, 91, 96, 93, 86, 86, 93,

106 96, 197, 191, 177, 191, 197, 203, 197,

107 197, 203, 209, 219, 209, 232, 232, 246,

108 };

109 static const uint16_t dv_iweight_720_y[64] = {

110 128, 16, 16, 17, 17, 17, 18, 18,

111 18, 18, 18, 18, 19, 18, 18, 19,

112 19, 19, 19, 19, 19, 42, 38, 40,

113 40, 40, 38, 42, 44, 43, 41, 41,

114 41, 41, 43, 44, 68, 68, 63, 63,

115 63, 68, 68, 96, 92, 86, 86, 92,

116 96, 98, 96, 88, 96, 98, 202, 196,

117 196, 202, 208, 218, 208, 232, 232, 246,

118 };

119 static const uint16_t dv_iweight_720_c[64] = {

120 128, 24, 24, 26, 26, 26, 36, 36,

121 36, 36, 36, 36, 38, 36, 36, 38,

122 38, 38, 38, 38, 38, 84, 76, 80,

123 80, 80, 76, 84, 88, 86, 82, 82,

124 82, 82, 86, 88, 182, 182, 168, 168,

125 168, 182, 182, 192, 186, 192, 172, 186,

126 192, 394, 382, 354, 382, 394, 406, 394,

127 394, 406, 418, 438, 418, 464, 464, 492,

128 };

129

130 static void dv_init_weight_tables(DVVideoContext *ctx, const AVDVProfile *d)

131 {

132 int j, i, c, s;

133 uint32_t *factor1 = &ctx->idct_factor[0],

134 *factor2 = &ctx->idct_factor[DV_PROFILE_IS_HD(d) ? 4096 : 2816];

135

136 if (DV_PROFILE_IS_HD(d)) {

137 /* quantization quanta by QNO for DV100 */

138 static const uint8_t dv100_qstep[16] = {

139 1, /* QNO = 0 and 1 both have no quantization */

140 1,

141 2, 3, 4, 5, 6, 7, 8, 16, 18, 20, 22, 24, 28, 52

142 };

143 const uint16_t *iweight1, *iweight2;

144

145 if (d->height == 720) {

146 iweight1 = &dv_iweight_720_y[0];

147 iweight2 = &dv_iweight_720_c[0];

148 } else {

149 iweight1 = &dv_iweight_1080_y[0];

150 iweight2 = &dv_iweight_1080_c[0];

151 }

152 for (c = 0; c < 4; c++) {

153 for (s = 0; s < 16; s++) {

154 for (i = 0; i < 64; i++) {

155 *factor1++ = (dv100_qstep[s] << (c + 9)) * iweight1[i];

156 *factor2++ = (dv100_qstep[s] << (c + 9)) * iweight2[i];

157 }

158 }

159 }

160 } else {

161 static const uint8_t dv_quant_areas[4] = { 6, 21, 43, 64 };

162 const uint16_t *iweight1 = &dv_iweight_88[0];

163 for (j = 0; j < 2; j++, iweight1 = &dv_iweight_248[0]) {

164 for (s = 0; s < 22; s++) {

165 for (i = c = 0; c < 4; c++) {

166 for (; i < dv_quant_areas[c]; i++) {

167 *factor1 = iweight1[i] << (ff_dv_quant_shifts[s][c] + 1);

168 *factor2++ = (*factor1++) << 1;

169 }

170 }

171 }

172 }

173 }

174 }

175

176 static av_cold int dvvideo_decode_init(AVCodecContext *avctx)

177 {

178 DVVideoContext *s = avctx->priv_data;

179 IDCTDSPContext idsp;

180 int i;

181

182 memset(&idsp,0, sizeof(idsp));

183 ff_idctdsp_init(&idsp, avctx);

184

185 for (i = 0; i < 64; i++)

186 s->dv_zigzag[0][i] = idsp.idct_permutation[ff_zigzag_direct[i]];

187

188 if (avctx->lowres){

189 for (i = 0; i < 64; i++){

190 int j = ff_dv_zigzag248_direct[i];

191 s->dv_zigzag[1][i] = idsp.idct_permutation[(j & 7) + (j & 8) * 4 + (j & 48) / 2];

192 }

193 }else

194 memcpy(s->dv_zigzag[1], ff_dv_zigzag248_direct, sizeof(s->dv_zigzag[1]));

195

196 s->idct_put[0] = idsp.idct_put;

197 s->idct_put[1] = ff_simple_idct248_put;

198

199 return ff_dvvideo_init(avctx);

200 }

201

202 /* decode AC coefficients */

203 static void dv_decode_ac(GetBitContext *gb, BlockInfo *mb, int16_t *block)

204 {

205 int last_index = gb->size_in_bits;

206 const uint8_t *scan_table = mb->scan_table;

207 const uint32_t *factor_table = mb->factor_table;

208 int pos = mb->pos;

209 int partial_bit_count = mb->partial_bit_count;

210 int level, run, vlc_len, index;

211

212 OPEN_READER_NOSIZE(re, gb);

213 UPDATE_CACHE(re, gb);

214

215 /* if we must parse a partial VLC, we do it here */

216 if (partial_bit_count > 0) {

217 re_cache = re_cache >> partial_bit_count |

218 mb->partial_bit_buffer;

219 re_index -= partial_bit_count;

220 mb->partial_bit_count = 0;

221 }

222

223 /* get the AC coefficients until last_index is reached */

224 for (;;) {

225 av_dlog(NULL, "%2d: bits=%04x index=%d\n", pos, SHOW_UBITS(re, gb, 16),

226 re_index);

227 /* our own optimized GET_RL_VLC */

228 index = NEG_USR32(re_cache, TEX_VLC_BITS);

229 vlc_len = ff_dv_rl_vlc[index].len;

230 if (vlc_len < 0) {

231 index = NEG_USR32((unsigned) re_cache << TEX_VLC_BITS, -vlc_len) +

232 ff_dv_rl_vlc[index].level;

233 vlc_len = TEX_VLC_BITS - vlc_len;

234 }

235 level = ff_dv_rl_vlc[index].level;

236 run = ff_dv_rl_vlc[index].run;

237

238 /* gotta check if we're still within gb boundaries */

239 if (re_index + vlc_len > last_index) {

240 /* should be < 16 bits otherwise a codeword could have been parsed */

241 mb->partial_bit_count = last_index - re_index;

242 mb->partial_bit_buffer = re_cache & ~(-1u >> mb->partial_bit_count);

243 re_index = last_index;

244 break;

245 }

246 re_index += vlc_len;

247

248 av_dlog(NULL, "run=%d level=%d\n", run, level);

249 pos += run;

250 if (pos >= 64)

251 break;

252

253 level = (level * factor_table[pos] + (1 << (dv_iweight_bits - 1))) >>

254 dv_iweight_bits;

255 block[scan_table[pos]] = level;

256

257 UPDATE_CACHE(re, gb);

258 }

259 CLOSE_READER(re, gb);

260 mb->pos = pos;

261 }

262

263 static inline void bit_copy(PutBitContext *pb, GetBitContext *gb)

264 {

265 int bits_left = get_bits_left(gb);

266 while (bits_left >= MIN_CACHE_BITS) {

267 put_bits(pb, MIN_CACHE_BITS, get_bits(gb, MIN_CACHE_BITS));

268 bits_left -= MIN_CACHE_BITS;

269 }

270 if (bits_left > 0)

271 put_bits(pb, bits_left, get_bits(gb, bits_left));

272 }

273

274 /* mb_x and mb_y are in units of 8 pixels */

275 static int dv_decode_video_segment(AVCodecContext *avctx, void *arg)

276 {

277 DVVideoContext *s = avctx->priv_data;

278 DVwork_chunk *work_chunk = arg;

279 int quant, dc, dct_mode, class1, j;

280 int mb_index, mb_x, mb_y, last_index;

281 int y_stride, linesize;

282 int16_t *block, *block1;

283 int c_offset;

284 uint8_t *y_ptr;

285 const uint8_t *buf_ptr;

286 PutBitContext pb, vs_pb;

287 GetBitContext gb;

288 BlockInfo mb_data[5 * DV_MAX_BPM], *mb, *mb1;

289 LOCAL_ALIGNED_16(int16_t, sblock, [5 * DV_MAX_BPM], [64]);

290 LOCAL_ALIGNED_16(uint8_t, mb_bit_buffer, [80 + FF_INPUT_BUFFER_PADDING_SIZE]); /* allow some slack */

291 LOCAL_ALIGNED_16(uint8_t, vs_bit_buffer, [80 * 5 + FF_INPUT_BUFFER_PADDING_SIZE]); /* allow some slack */

292 const int log2_blocksize = 3-s->avctx->lowres;

293 int is_field_mode[5];

294

295 av_assert1((((int) mb_bit_buffer) & 7) == 0);

296 av_assert1((((int) vs_bit_buffer) & 7) == 0);

297

298 memset(sblock, 0, 5 * DV_MAX_BPM * sizeof(*sblock));

299

300 /* pass 1: read DC and AC coefficients in blocks */

301 buf_ptr = &s->buf[work_chunk->buf_offset * 80];

302 block1 = &sblock[0][0];

303 mb1 = mb_data;

304 init_put_bits(&vs_pb, vs_bit_buffer, 5 * 80);

305 for (mb_index = 0; mb_index < 5; mb_index++, mb1 += s->sys->bpm, block1 += s->sys->bpm * 64) {

306 /* skip header */

307 quant = buf_ptr[3] & 0x0f;

308 buf_ptr += 4;

309 init_put_bits(&pb, mb_bit_buffer, 80);

310 mb = mb1;

311 block = block1;

312 is_field_mode[mb_index] = 0;

313 for (j = 0; j < s->sys->bpm; j++) {

314 last_index = s->sys->block_sizes[j];

315 init_get_bits(&gb, buf_ptr, last_index);

316

317 /* get the DC */

318 dc = get_sbits(&gb, 9);

319 dct_mode = get_bits1(&gb);

320 class1 = get_bits(&gb, 2);

321 if (DV_PROFILE_IS_HD(s->sys)) {

322 mb->idct_put = s->idct_put[0];

323 mb->scan_table = s->dv_zigzag[0];

324 mb->factor_table = &s->idct_factor[(j >= 4) * 4 * 16 * 64 +

325 class1 * 16 * 64 +

326 quant * 64];

327 is_field_mode[mb_index] |= !j && dct_mode;

328 } else {

329 mb->idct_put = s->idct_put[dct_mode && log2_blocksize == 3];

330 mb->scan_table = s->dv_zigzag[dct_mode];

331 mb->factor_table =

332 &s->idct_factor[(class1 == 3) * 2 * 22 * 64 +

333 dct_mode * 22 * 64 +

334 (quant + ff_dv_quant_offset[class1]) * 64];

335 }

336 dc = dc << 2;

337 /* convert to unsigned because 128 is not added in the

338 * standard IDCT */

339 dc += 1024;

340 block[0] = dc;

341 buf_ptr += last_index >> 3;

342 mb->pos = 0;

343 mb->partial_bit_count = 0;

344

345 av_dlog(avctx, "MB block: %d, %d ", mb_index, j);

346 dv_decode_ac(&gb, mb, block);

347

348 /* write the remaining bits in a new buffer only if the

349 * block is finished */

350 if (mb->pos >= 64)

351 bit_copy(&pb, &gb);

352

353 block += 64;

354 mb++;

355 }

356

357 /* pass 2: we can do it just after */

358 av_dlog(avctx, "***pass 2 size=%d MB#=%d\n", put_bits_count(&pb), mb_index);

359 block = block1;

360 mb = mb1;

361 init_get_bits(&gb, mb_bit_buffer, put_bits_count(&pb));

362 put_bits32(&pb, 0); // padding must be zeroed

363 flush_put_bits(&pb);

364 for (j = 0; j < s->sys->bpm; j++, block += 64, mb++) {

365 if (mb->pos < 64 && get_bits_left(&gb) > 0) {

366 dv_decode_ac(&gb, mb, block);

367 /* if still not finished, no need to parse other blocks */

368 if (mb->pos < 64)

369 break;

370 }

371 }

372 /* all blocks are finished, so the extra bytes can be used at

373 * the video segment level */

374 if (j >= s->sys->bpm)

375 bit_copy(&vs_pb, &gb);

376 }

377

378 /* we need a pass over the whole video segment */

379 av_dlog(avctx, "***pass 3 size=%d\n", put_bits_count(&vs_pb));

380 block = &sblock[0][0];

381 mb = mb_data;

382 init_get_bits(&gb, vs_bit_buffer, put_bits_count(&vs_pb));

383 put_bits32(&vs_pb, 0); // padding must be zeroed

384 flush_put_bits(&vs_pb);

385 for (mb_index = 0; mb_index < 5; mb_index++) {

386 for (j = 0; j < s->sys->bpm; j++) {

387 if (mb->pos < 64 && get_bits_left(&gb) > 0) {

388 av_dlog(avctx, "start %d:%d\n", mb_index, j);

389 dv_decode_ac(&gb, mb, block);

390 }

391 if (mb->pos >= 64 && mb->pos < 127)

392 av_log(avctx, AV_LOG_ERROR,

393 "AC EOB marker is absent pos=%d\n", mb->pos);

394 block += 64;

395 mb++;

396 }

397 }

398

399 /* compute idct and place blocks */

400 block = &sblock[0][0];

401 mb = mb_data;

402 for (mb_index = 0; mb_index < 5; mb_index++) {

403 dv_calculate_mb_xy(s, work_chunk, mb_index, &mb_x, &mb_y);

404

405 /* idct_put'ting luminance */

406 if ((s->sys->pix_fmt == AV_PIX_FMT_YUV420P) ||

407 (s->sys->pix_fmt == AV_PIX_FMT_YUV411P && mb_x >= (704 / 8)) ||

408 (s->sys->height >= 720 && mb_y != 134)) {

409 y_stride = (s->frame->linesize[0] <<

410 ((!is_field_mode[mb_index]) * log2_blocksize));

411 } else {

412 y_stride = (2 << log2_blocksize);

413 }

414 y_ptr = s->frame->data[0] +

415 ((mb_y * s->frame->linesize[0] + mb_x) << log2_blocksize);

416 linesize = s->frame->linesize[0] << is_field_mode[mb_index];

417 mb[0].idct_put(y_ptr, linesize, block + 0 * 64);

418 if (s->sys->video_stype == 4) { /* SD 422 */

419 mb[2].idct_put(y_ptr + (1 << log2_blocksize), linesize, block + 2 * 64);

420 } else {

421 mb[1].idct_put(y_ptr + (1 << log2_blocksize), linesize, block + 1 * 64);

422 mb[2].idct_put(y_ptr + y_stride, linesize, block + 2 * 64);

423 mb[3].idct_put(y_ptr + (1 << log2_blocksize) + y_stride, linesize, block + 3 * 64);

424 }

425 mb += 4;

426 block += 4 * 64;

427

428 /* idct_put'ting chrominance */

429 c_offset = (((mb_y >> (s->sys->pix_fmt == AV_PIX_FMT_YUV420P)) * s->frame->linesize[1] +

430 (mb_x >> ((s->sys->pix_fmt == AV_PIX_FMT_YUV411P) ? 2 : 1))) << log2_blocksize);

431 for (j = 2; j; j--) {

432 uint8_t *c_ptr = s->frame->data[j] + c_offset;

433 if (s->sys->pix_fmt == AV_PIX_FMT_YUV411P && mb_x >= (704 / 8)) {

434 uint64_t aligned_pixels[64 / 8];

435 uint8_t *pixels = (uint8_t *) aligned_pixels;

436 uint8_t *c_ptr1, *ptr1;

437 int x, y;

438 mb->idct_put(pixels, 8, block);

439 for (y = 0; y < (1 << log2_blocksize); y++, c_ptr += s->frame->linesize[j], pixels += 8) {

440 ptr1 = pixels + ((1 << (log2_blocksize))>>1);

441 c_ptr1 = c_ptr + (s->frame->linesize[j] << log2_blocksize);

442 for (x = 0; x < (1 << FFMAX(log2_blocksize - 1, 0)); x++) {

443 c_ptr[x] = pixels[x];

444 c_ptr1[x] = ptr1[x];

445 }

446 }

447 block += 64;

448 mb++;

449 } else {

450 y_stride = (mb_y == 134) ? (1 << log2_blocksize) :

451 s->frame->linesize[j] << ((!is_field_mode[mb_index]) * log2_blocksize);

452 linesize = s->frame->linesize[j] << is_field_mode[mb_index];

453 (mb++)->idct_put(c_ptr, linesize, block);

454 block += 64;

455 if (s->sys->bpm == 8) {

456 (mb++)->idct_put(c_ptr + y_stride, linesize, block);

457 block += 64;

458 }

459 }

460 }

461 }

462 return 0;

463 }

464

465 /* NOTE: exactly one frame must be given (120000 bytes for NTSC,

466 * 144000 bytes for PAL - or twice those for 50Mbps) */

467 static int dvvideo_decode_frame(AVCodecContext *avctx, void *data,

468 int *got_frame, AVPacket *avpkt)

469 {

470 uint8_t *buf = avpkt->data;

471 int buf_size = avpkt->size;

472 DVVideoContext *s = avctx->priv_data;

473 const uint8_t *vsc_pack;

474 int apt, is16_9, ret;

475 const AVDVProfile *sys;

476

477 sys = ff_dv_frame_profile(avctx, s->sys, buf, buf_size);

478 if (!sys || buf_size < sys->frame_size) {

479 av_log(avctx, AV_LOG_ERROR, "could not find dv frame profile\n");

480 return -1; /* NOTE: we only accept several full frames */

481 }

482

483 if (sys != s->sys) {

484 ret = ff_dv_init_dynamic_tables(s, sys);

485 if (ret < 0) {

486 av_log(avctx, AV_LOG_ERROR, "Error initializing the work tables.\n");

487 return ret;

488 }

489 dv_init_weight_tables(s, sys);

490 s->sys = sys;

491 }

492

493 s->frame = data;

494 s->frame->key_frame = 1;

495 s->frame->pict_type = AV_PICTURE_TYPE_I;

496 avctx->pix_fmt = s->sys->pix_fmt;

497 avctx->framerate = av_inv_q(s->sys->time_base);

498

499 ret = ff_set_dimensions(avctx, s->sys->width, s->sys->height);

500 if (ret < 0)

501 return ret;

502

503 /* Determine the codec's sample_aspect ratio from the packet */

504 vsc_pack = buf + 80 * 5 + 48 + 5;

505 if (*vsc_pack == dv_video_control) {

506 apt = buf[4] & 0x07;

507 is16_9 = (vsc_pack[2] & 0x07) == 0x02 ||

508 (!apt && (vsc_pack[2] & 0x07) == 0x07);

509 ff_set_sar(avctx, s->sys->sar[is16_9]);

510 }

511

512 if ((ret = ff_get_buffer(avctx, s->frame, 0)) < 0)

513 return ret;

514 s->frame->interlaced_frame = 1;

515 s->frame->top_field_first = 0;

516

517 /* Determine the codec's field order from the packet */

518 if ( *vsc_pack == dv_video_control ) {

519 s->frame->top_field_first = !(vsc_pack[3] & 0x40);

520 }

521

522 s->buf = buf;

523 avctx->execute(avctx, dv_decode_video_segment, s->work_chunks, NULL,

524 dv_work_pool_size(s->sys), sizeof(DVwork_chunk));

525

526 emms_c();

527

528 /* return image */

529 *got_frame = 1;

530

531 return s->sys->frame_size;

532 }

533

534 AVCodec ff_dvvideo_decoder = {

535 .name = "dvvideo",

536 .long_name = NULL_IF_CONFIG_SMALL("DV (Digital Video)"),

537 .type = AVMEDIA_TYPE_VIDEO,

538 .id = AV_CODEC_ID_DVVIDEO,

539 .priv_data_size = sizeof(DVVideoContext),

540 .init = dvvideo_decode_init,

541 .decode = dvvideo_decode_frame,

542 .capabilities = CODEC_CAP_DR1 | CODEC_CAP_SLICE_THREADS,

543 .max_lowres = 3,

544 };

Generated on Sun Mar 8 2015 02:34:50 for FFmpeg by doxygen 1.8.2