FFmpeg: libavcodec/dvenc.c Source File

FFmpeg

[フレーム]

libavcodec

dvenc.c

Go to the documentation of this file.

1 /*

2 * DV encoder

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 * DV encoder

25 */

27 #include "config.h"

29 #include "libavutil/attributes.h"

30 #include "libavutil/pixdesc.h"

32 #include "avcodec.h"

33 #include "dv.h"

34 #include "dv_profile_internal.h"

35 #include "dv_tablegen.h"

36 #include "fdctdsp.h"

37 #include "internal.h"

38 #include "me_cmp.h"

39 #include "pixblockdsp.h"

40 #include "put_bits.h"

42 static av_cold int dvvideo_encode_init(AVCodecContext *avctx)

43 {

44 DVVideoContext *s = avctx->priv_data;

45 FDCTDSPContext fdsp;

46 MECmpContext mecc;

47 PixblockDSPContext pdsp;

48 int ret;

50 s->sys = av_dv_codec_profile2(avctx->width, avctx->height, avctx->pix_fmt, avctx->time_base);

51 if (!s->sys) {

52 av_log(avctx, AV_LOG_ERROR, "Found no DV profile for %ix%i %s video. "

53 "Valid DV profiles are:\n",

54 avctx->width, avctx->height, av_get_pix_fmt_name(avctx->pix_fmt));

55 ff_dv_print_profiles(avctx, AV_LOG_ERROR);

56 return AVERROR(EINVAL);

57 }

58 if (avctx->height > 576) {

59 av_log(avctx, AV_LOG_ERROR, "DVCPRO HD encoding is not supported.\n");

60 return AVERROR_PATCHWELCOME;

61 }

62 ret = ff_dv_init_dynamic_tables(s, s->sys);

63 if (ret < 0) {

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

65 return ret;

66 }

68 avctx->coded_frame = av_frame_alloc();

69 if (!avctx->coded_frame)

70 return AVERROR(ENOMEM);

72 dv_vlc_map_tableinit();

74 memset(&fdsp,0, sizeof(fdsp));

75 memset(&mecc,0, sizeof(mecc));

76 memset(&pdsp,0, sizeof(pdsp));

77 ff_fdctdsp_init(&fdsp, avctx);

78 ff_me_cmp_init(&mecc, avctx);

79 ff_pixblockdsp_init(&pdsp, avctx);

80 ff_set_cmp(&mecc, mecc.ildct_cmp, avctx->ildct_cmp);

82 s->get_pixels = pdsp.get_pixels;

83 s->ildct_cmp = mecc.ildct_cmp[5];

85 s->fdct[0] = fdsp.fdct;

86 s->fdct[1] = fdsp.fdct248;

88 return ff_dvvideo_init(avctx);

89 }

91 /* bit budget for AC only in 5 MBs */

92 static const int vs_total_ac_bits = (100 * 4 + 68 * 2) * 5;

93 static const int mb_area_start[5] = { 1, 6, 21, 43, 64 };

95 #if CONFIG_SMALL

96 /* Convert run and level (where level != 0) pair into VLC, returning bit size */

97 static av_always_inline int dv_rl2vlc(int run, int level, int sign,

98 uint32_t *vlc)

99 {

100 int size;

101 if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {

102 *vlc = dv_vlc_map[run][level].vlc | sign;

103 size = dv_vlc_map[run][level].size;

104 } else {

105 if (level < DV_VLC_MAP_LEV_SIZE) {

106 *vlc = dv_vlc_map[0][level].vlc | sign;

107 size = dv_vlc_map[0][level].size;

108 } else {

109 *vlc = 0xfe00 | (level << 1) | sign;

110 size = 16;

111 }

112 if (run) {

113 *vlc |= ((run < 16) ? dv_vlc_map[run - 1][0].vlc :

114 (0x1f80 | (run - 1))) << size;

115 size += (run < 16) ? dv_vlc_map[run - 1][0].size : 13;

116 }

117 }

118

119 return size;

120 }

121

122 static av_always_inline int dv_rl2vlc_size(int run, int level)

123 {

124 int size;

125

126 if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {

127 size = dv_vlc_map[run][level].size;

128 } else {

129 size = (level < DV_VLC_MAP_LEV_SIZE) ? dv_vlc_map[0][level].size : 16;

130 if (run)

131 size += (run < 16) ? dv_vlc_map[run - 1][0].size : 13;

132 }

133 return size;

134 }

135 #else

136 static av_always_inline int dv_rl2vlc(int run, int l, int sign, uint32_t *vlc)

137 {

138 *vlc = dv_vlc_map[run][l].vlc | sign;

139 return dv_vlc_map[run][l].size;

140 }

141

142 static av_always_inline int dv_rl2vlc_size(int run, int l)

143 {

144 return dv_vlc_map[run][l].size;

145 }

146 #endif

147

148 typedef struct EncBlockInfo {

149 int area_q[4];

150 int bit_size[4];

151 int prev[5];

152 int cur_ac;

153 int cno;

154 int dct_mode;

155 int16_t mb[64];

156 uint8_t next[64];

157 uint8_t sign[64];

158 uint8_t partial_bit_count;

159 uint32_t partial_bit_buffer; /* we can't use uint16_t here */

160 } EncBlockInfo;

161

162 static av_always_inline PutBitContext *dv_encode_ac(EncBlockInfo *bi,

163 PutBitContext *pb_pool,

164 PutBitContext *pb_end)

165 {

166 int prev, bits_left;

167 PutBitContext *pb = pb_pool;

168 int size = bi->partial_bit_count;

169 uint32_t vlc = bi->partial_bit_buffer;

170

171 bi->partial_bit_count =

172 bi->partial_bit_buffer = 0;

173 for (;;) {

174 /* Find suitable storage space */

175 for (; size > (bits_left = put_bits_left(pb)); pb++) {

176 if (bits_left) {

177 size -= bits_left;

178 put_bits(pb, bits_left, vlc >> size);

179 vlc = vlc & ((1 << size) - 1);

180 }

181 if (pb + 1 >= pb_end) {

182 bi->partial_bit_count = size;

183 bi->partial_bit_buffer = vlc;

184 return pb;

185 }

186 }

187

188 /* Store VLC */

189 put_bits(pb, size, vlc);

190

191 if (bi->cur_ac >= 64)

192 break;

193

194 /* Construct the next VLC */

195 prev = bi->cur_ac;

196 bi->cur_ac = bi->next[prev];

197 if (bi->cur_ac < 64) {

198 size = dv_rl2vlc(bi->cur_ac - prev - 1, bi->mb[bi->cur_ac],

199 bi->sign[bi->cur_ac], &vlc);

200 } else {

201 size = 4;

202 vlc = 6; /* End Of Block stamp */

203 }

204 }

205 return pb;

206 }

207

208 static av_always_inline int dv_guess_dct_mode(DVVideoContext *s, uint8_t *data,

209 int linesize)

210 {

211 if (s->avctx->flags & CODEC_FLAG_INTERLACED_DCT) {

212 int ps = s->ildct_cmp(NULL, data, NULL, linesize, 8) - 400;

213 if (ps > 0) {

214 int is = s->ildct_cmp(NULL, data, NULL, linesize << 1, 4) +

215 s->ildct_cmp(NULL, data + linesize, NULL, linesize << 1, 4);

216 return ps > is;

217 }

218 }

219

220 return 0;

221 }

222

223 static const int dv_weight_bits = 18;

224 static const int dv_weight_88[64] = {

225 131072, 257107, 257107, 242189, 252167, 242189, 235923, 237536,

226 237536, 235923, 229376, 231390, 223754, 231390, 229376, 222935,

227 224969, 217965, 217965, 224969, 222935, 200636, 218652, 211916,

228 212325, 211916, 218652, 200636, 188995, 196781, 205965, 206433,

229 206433, 205965, 196781, 188995, 185364, 185364, 200636, 200704,

230 200636, 185364, 185364, 174609, 180568, 195068, 195068, 180568,

231 174609, 170091, 175557, 189591, 175557, 170091, 165371, 170627,

232 170627, 165371, 160727, 153560, 160727, 144651, 144651, 136258,

233 };

234 static const int dv_weight_248[64] = {

235 131072, 262144, 257107, 257107, 242189, 242189, 242189, 242189,

236 237536, 237536, 229376, 229376, 200636, 200636, 224973, 224973,

237 223754, 223754, 235923, 235923, 229376, 229376, 217965, 217965,

238 211916, 211916, 196781, 196781, 185364, 185364, 206433, 206433,

239 211916, 211916, 222935, 222935, 200636, 200636, 205964, 205964,

240 200704, 200704, 180568, 180568, 175557, 175557, 195068, 195068,

241 185364, 185364, 188995, 188995, 174606, 174606, 175557, 175557,

242 170627, 170627, 153560, 153560, 165371, 165371, 144651, 144651,

243 };

244

245 static av_always_inline int dv_init_enc_block(EncBlockInfo *bi, uint8_t *data,

246 int linesize, DVVideoContext *s,

247 int bias)

248 {

249 const int *weight;

250 const uint8_t *zigzag_scan;

251 LOCAL_ALIGNED_16(int16_t, blk, [64]);

252 int i, area;

253 /* We offer two different methods for class number assignment: the

254 * method suggested in SMPTE 314M Table 22, and an improved

255 * method. The SMPTE method is very conservative; it assigns class

256 * 3 (i.e. severe quantization) to any block where the largest AC

257 * component is greater than 36. FFmpeg's DV encoder tracks AC bit

258 * consumption precisely, so there is no need to bias most blocks

259 * towards strongly lossy compression. Instead, we assign class 2

260 * to most blocks, and use class 3 only when strictly necessary

261 * (for blocks whose largest AC component exceeds 255). */

262

263 #if 0 /* SMPTE spec method */

264 static const int classes[] = { 12, 24, 36, 0xffff };

265 #else /* improved FFmpeg method */

266 static const int classes[] = { -1, -1, 255, 0xffff };

267 #endif

268 int max = classes[0];

269 int prev = 0;

270

271 av_assert2((((int) blk) & 15) == 0);

272

273 bi->area_q[0] =

274 bi->area_q[1] =

275 bi->area_q[2] =

276 bi->area_q[3] = 0;

277 bi->partial_bit_count = 0;

278 bi->partial_bit_buffer = 0;

279 bi->cur_ac = 0;

280 if (data) {

281 bi->dct_mode = dv_guess_dct_mode(s, data, linesize);

282 s->get_pixels(blk, data, linesize);

283 s->fdct[bi->dct_mode](blk);

284 } else {

285 /* We rely on the fact that encoding all zeros leads to an immediate

286 * EOB, which is precisely what the spec calls for in the "dummy"

287 * blocks. */

288 memset(blk, 0, 64 * sizeof(*blk));

289 bi->dct_mode = 0;

290 }

291 bi->mb[0] = blk[0];

292

293 zigzag_scan = bi->dct_mode ? ff_dv_zigzag248_direct : ff_zigzag_direct;

294 weight = bi->dct_mode ? dv_weight_248 : dv_weight_88;

295

296 for (area = 0; area < 4; area++) {

297 bi->prev[area] = prev;

298 bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)

299 for (i = mb_area_start[area]; i < mb_area_start[area + 1]; i++) {

300 int level = blk[zigzag_scan[i]];

301

302 if (level + 15 > 30U) {

303 bi->sign[i] = (level >> 31) & 1;

304 /* Weight it and shift down into range, adding for rounding.

305 * The extra division by a factor of 2^4 reverses the 8x

306 * expansion of the DCT AND the 2x doubling of the weights. */

307 level = (FFABS(level) * weight[i] + (1 << (dv_weight_bits + 3))) >>

308 (dv_weight_bits + 4);

309 bi->mb[i] = level;

310 if (level > max)

311 max = level;

312 bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, level);

313 bi->next[prev] = i;

314 prev = i;

315 }

316 }

317 }

318 bi->next[prev] = i;

319 for (bi->cno = 0; max > classes[bi->cno]; bi->cno++)

320 ;

321

322 bi->cno += bias;

323

324 if (bi->cno >= 3) {

325 bi->cno = 3;

326 prev = 0;

327 i = bi->next[prev];

328 for (area = 0; area < 4; area++) {

329 bi->prev[area] = prev;

330 bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)

331 for (; i < mb_area_start[area + 1]; i = bi->next[i]) {

332 bi->mb[i] >>= 1;

333

334 if (bi->mb[i]) {

335 bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, bi->mb[i]);

336 bi->next[prev] = i;

337 prev = i;

338 }

339 }

340 }

341 bi->next[prev] = i;

342 }

343

344 return bi->bit_size[0] + bi->bit_size[1] +

345 bi->bit_size[2] + bi->bit_size[3];

346 }

347

348 static inline void dv_guess_qnos(EncBlockInfo *blks, int *qnos)

349 {

350 int size[5];

351 int i, j, k, a, prev, a2;

352 EncBlockInfo *b;

353

354 size[0] =

355 size[1] =

356 size[2] =

357 size[3] =

358 size[4] = 1 << 24;

359 do {

360 b = blks;

361 for (i = 0; i < 5; i++) {

362 if (!qnos[i])

363 continue;

364

365 qnos[i]--;

366 size[i] = 0;

367 for (j = 0; j < 6; j++, b++) {

368 for (a = 0; a < 4; a++) {

369 if (b->area_q[a] != ff_dv_quant_shifts[qnos[i] + ff_dv_quant_offset[b->cno]][a]) {

370 b->bit_size[a] = 1; // 4 areas 4 bits for EOB :)

371 b->area_q[a]++;

372 prev = b->prev[a];

373 av_assert2(b->next[prev] >= mb_area_start[a + 1] || b->mb[prev]);

374 for (k = b->next[prev]; k < mb_area_start[a + 1]; k = b->next[k]) {

375 b->mb[k] >>= 1;

376 if (b->mb[k]) {

377 b->bit_size[a] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);

378 prev = k;

379 } else {

380 if (b->next[k] >= mb_area_start[a + 1] && b->next[k] < 64) {

381 for (a2 = a + 1; b->next[k] >= mb_area_start[a2 + 1]; a2++)

382 b->prev[a2] = prev;

383 av_assert2(a2 < 4);

384 av_assert2(b->mb[b->next[k]]);

385 b->bit_size[a2] += dv_rl2vlc_size(b->next[k] - prev - 1, b->mb[b->next[k]]) -

386 dv_rl2vlc_size(b->next[k] - k - 1, b->mb[b->next[k]]);

387 av_assert2(b->prev[a2] == k && (a2 + 1 >= 4 || b->prev[a2 + 1] != k));

388 b->prev[a2] = prev;

389 }

390 b->next[prev] = b->next[k];

391 }

392 }

393 b->prev[a + 1] = prev;

394 }

395 size[i] += b->bit_size[a];

396 }

397 }

398 if (vs_total_ac_bits >= size[0] + size[1] + size[2] + size[3] + size[4])

399 return;

400 }

401 } while (qnos[0] | qnos[1] | qnos[2] | qnos[3] | qnos[4]);

402

403 for (a = 2; a == 2 || vs_total_ac_bits < size[0]; a += a) {

404 b = blks;

405 size[0] = 5 * 6 * 4; // EOB

406 for (j = 0; j < 6 * 5; j++, b++) {

407 prev = b->prev[0];

408 for (k = b->next[prev]; k < 64; k = b->next[k]) {

409 if (b->mb[k] < a && b->mb[k] > -a) {

410 b->next[prev] = b->next[k];

411 } else {

412 size[0] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);

413 prev = k;

414 }

415 }

416 }

417 }

418 }

419

420 static int dv_encode_video_segment(AVCodecContext *avctx, void *arg)

421 {

422 DVVideoContext *s = avctx->priv_data;

423 DVwork_chunk *work_chunk = arg;

424 int mb_index, i, j;

425 int mb_x, mb_y, c_offset, linesize, y_stride;

426 uint8_t *y_ptr;

427 uint8_t *dif;

428 LOCAL_ALIGNED_8(uint8_t, scratch, [128]);

429 EncBlockInfo enc_blks[5 * DV_MAX_BPM];

430 PutBitContext pbs[5 * DV_MAX_BPM];

431 PutBitContext *pb;

432 EncBlockInfo *enc_blk;

433 int vs_bit_size = 0;

434 int qnos[5] = { 15, 15, 15, 15, 15 }; /* No quantization */

435 int *qnosp = &qnos[0];

436

437 dif = &s->buf[work_chunk->buf_offset * 80];

438 enc_blk = &enc_blks[0];

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

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

441

442 /* initializing luminance blocks */

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

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

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

446 y_stride = s->frame->linesize[0] << 3;

447 } else {

448 y_stride = 16;

449 }

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

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

452 linesize = s->frame->linesize[0];

453

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

455 vs_bit_size +=

456 dv_init_enc_block(enc_blk + 0, y_ptr, linesize, s, 0) +

457 dv_init_enc_block(enc_blk + 1, NULL, linesize, s, 0) +

458 dv_init_enc_block(enc_blk + 2, y_ptr + 8, linesize, s, 0) +

459 dv_init_enc_block(enc_blk + 3, NULL, linesize, s, 0);

460 } else {

461 vs_bit_size +=

462 dv_init_enc_block(enc_blk + 0, y_ptr, linesize, s, 0) +

463 dv_init_enc_block(enc_blk + 1, y_ptr + 8, linesize, s, 0) +

464 dv_init_enc_block(enc_blk + 2, y_ptr + y_stride, linesize, s, 0) +

465 dv_init_enc_block(enc_blk + 3, y_ptr + 8 + y_stride, linesize, s, 0);

466 }

467 enc_blk += 4;

468

469 /* initializing chrominance blocks */

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

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

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

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

474 linesize = s->frame->linesize[j];

475 y_stride = (mb_y == 134) ? 8 : (s->frame->linesize[j] << 3);

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

477 uint8_t *d;

478 uint8_t *b = scratch;

479 for (i = 0; i < 8; i++) {

480 d = c_ptr + (linesize << 3);

481 b[0] = c_ptr[0];

482 b[1] = c_ptr[1];

483 b[2] = c_ptr[2];

484 b[3] = c_ptr[3];

485 b[4] = d[0];

486 b[5] = d[1];

487 b[6] = d[2];

488 b[7] = d[3];

489 c_ptr += linesize;

490 b += 16;

491 }

492 c_ptr = scratch;

493 linesize = 16;

494 }

495

496 vs_bit_size += dv_init_enc_block(enc_blk++, c_ptr, linesize, s, 1);

497 if (s->sys->bpm == 8)

498 vs_bit_size += dv_init_enc_block(enc_blk++, c_ptr + y_stride,

499 linesize, s, 1);

500 }

501 }

502

503 if (vs_total_ac_bits < vs_bit_size)

504 dv_guess_qnos(&enc_blks[0], qnosp);

505

506 /* DIF encoding process */

507 for (j = 0; j < 5 * s->sys->bpm;) {

508 int start_mb = j;

509

510 dif[3] = *qnosp++;

511 dif += 4;

512

513 /* First pass over individual cells only */

514 for (i = 0; i < s->sys->bpm; i++, j++) {

515 int sz = s->sys->block_sizes[i] >> 3;

516

517 init_put_bits(&pbs[j], dif, sz);

518 put_sbits(&pbs[j], 9, ((enc_blks[j].mb[0] >> 3) - 1024 + 2) >> 2);

519 put_bits(&pbs[j], 1, enc_blks[j].dct_mode);

520 put_bits(&pbs[j], 2, enc_blks[j].cno);

521

522 dv_encode_ac(&enc_blks[j], &pbs[j], &pbs[j + 1]);

523 dif += sz;

524 }

525

526 /* Second pass over each MB space */

527 pb = &pbs[start_mb];

528 for (i = 0; i < s->sys->bpm; i++)

529 if (enc_blks[start_mb + i].partial_bit_count)

530 pb = dv_encode_ac(&enc_blks[start_mb + i], pb,

531 &pbs[start_mb + s->sys->bpm]);

532 }

533

534 /* Third and final pass over the whole video segment space */

535 pb = &pbs[0];

536 for (j = 0; j < 5 * s->sys->bpm; j++) {

537 if (enc_blks[j].partial_bit_count)

538 pb = dv_encode_ac(&enc_blks[j], pb, &pbs[s->sys->bpm * 5]);

539 if (enc_blks[j].partial_bit_count)

540 av_log(avctx, AV_LOG_ERROR, "ac bitstream overflow\n");

541 }

542

543 for (j = 0; j < 5 * s->sys->bpm; j++) {

544 int pos;

545 int size = pbs[j].size_in_bits >> 3;

546 flush_put_bits(&pbs[j]);

547 pos = put_bits_count(&pbs[j]) >> 3;

548 if (pos > size) {

549 av_log(avctx, AV_LOG_ERROR,

550 "bitstream written beyond buffer size\n");

551 return -1;

552 }

553 memset(pbs[j].buf + pos, 0xff, size - pos);

554 }

555

556 return 0;

557 }

558

559 static inline int dv_write_pack(enum dv_pack_type pack_id, DVVideoContext *c,

560 uint8_t *buf)

561 {

562 /*

563 * Here's what SMPTE314M says about these two:

564 * (page 6) APTn, AP1n, AP2n, AP3n: These data shall be identical

565 * as track application IDs (APTn = 001, AP1n =

566 * 001, AP2n = 001, AP3n = 001), if the source signal

567 * comes from a digital VCR. If the signal source is

568 * unknown, all bits for these data shall be set to 1.

569 * (page 12) STYPE: STYPE defines a signal type of video signal

570 * 00000b = 4:1:1 compression

571 * 00100b = 4:2:2 compression

572 * XXXXXX = Reserved

573 * Now, I've got two problems with these statements:

574 * 1. it looks like APT == 111b should be a safe bet, but it isn't.

575 * It seems that for PAL as defined in IEC 61834 we have to set

576 * APT to 000 and for SMPTE314M to 001.

577 * 2. It is not at all clear what STYPE is used for 4:2:0 PAL

578 * compression scheme (if any).

579 */

580 int apt = (c->sys->pix_fmt == AV_PIX_FMT_YUV420P ? 0 : 1);

581 int fs = c->frame->top_field_first ? 0x00 : 0x40;

582

583 uint8_t aspect = 0;

584 if ((int) (av_q2d(c->avctx->sample_aspect_ratio) *

585 c->avctx->width / c->avctx->height * 10) >= 17) /* 16:9 */

586 aspect = 0x02;

587

588 buf[0] = (uint8_t) pack_id;

589 switch (pack_id) {

590 case dv_header525: /* I can't imagine why these two weren't defined as real */

591 case dv_header625: /* packs in SMPTE314M -- they definitely look like ones */

592 buf[1] = 0xf8 | /* reserved -- always 1 */

593 (apt & 0x07); /* APT: Track application ID */

594 buf[2] = (0 << 7) | /* TF1: audio data is 0 - valid; 1 - invalid */

595 (0x0f << 3) | /* reserved -- always 1 */

596 (apt & 0x07); /* AP1: Audio application ID */

597 buf[3] = (0 << 7) | /* TF2: video data is 0 - valid; 1 - invalid */

598 (0x0f << 3) | /* reserved -- always 1 */

599 (apt & 0x07); /* AP2: Video application ID */

600 buf[4] = (0 << 7) | /* TF3: subcode(SSYB) is 0 - valid; 1 - invalid */

601 (0x0f << 3) | /* reserved -- always 1 */

602 (apt & 0x07); /* AP3: Subcode application ID */

603 break;

604 case dv_video_source:

605 buf[1] = 0xff; /* reserved -- always 1 */

606 buf[2] = (1 << 7) | /* B/W: 0 - b/w, 1 - color */

607 (1 << 6) | /* following CLF is valid - 0, invalid - 1 */

608 (3 << 4) | /* CLF: color frames ID (see ITU-R BT.470-4) */

609 0xf; /* reserved -- always 1 */

610 buf[3] = (3 << 6) | /* reserved -- always 1 */

611 (c->sys->dsf << 5) | /* system: 60fields/50fields */

612 c->sys->video_stype; /* signal type video compression */

613 buf[4] = 0xff; /* VISC: 0xff -- no information */

614 break;

615 case dv_video_control:

616 buf[1] = (0 << 6) | /* Copy generation management (CGMS) 0 -- free */

617 0x3f; /* reserved -- always 1 */

618 buf[2] = 0xc8 | /* reserved -- always b11001xxx */

619 aspect;

620 buf[3] = (1 << 7) | /* frame/field flag 1 -- frame, 0 -- field */

621 fs | /* first/second field flag 0 -- field 2, 1 -- field 1 */

622 (1 << 5) | /* frame change flag 0 -- same picture as before, 1 -- different */

623 (1 << 4) | /* 1 - interlaced, 0 - noninterlaced */

624 0xc; /* reserved -- always b1100 */

625 buf[4] = 0xff; /* reserved -- always 1 */

626 break;

627 default:

628 buf[1] =

629 buf[2] =

630 buf[3] =

631 buf[4] = 0xff;

632 }

633 return 5;

634 }

635

636 static inline int dv_write_dif_id(enum dv_section_type t, uint8_t chan_num,

637 uint8_t seq_num, uint8_t dif_num,

638 uint8_t *buf)

639 {

640 buf[0] = (uint8_t) t; /* Section type */

641 buf[1] = (seq_num << 4) | /* DIF seq number 0-9 for 525/60; 0-11 for 625/50 */

642 (chan_num << 3) | /* FSC: for 50Mb/s 0 - first channel; 1 - second */

643 7; /* reserved -- always 1 */

644 buf[2] = dif_num; /* DIF block number Video: 0-134, Audio: 0-8 */

645 return 3;

646 }

647

648 static inline int dv_write_ssyb_id(uint8_t syb_num, uint8_t fr, uint8_t *buf)

649 {

650 if (syb_num == 0 || syb_num == 6) {

651 buf[0] = (fr << 7) | /* FR ID 1 - first half of each channel; 0 - second */

652 (0 << 4) | /* AP3 (Subcode application ID) */

653 0x0f; /* reserved -- always 1 */

654 } else if (syb_num == 11) {

655 buf[0] = (fr << 7) | /* FR ID 1 - first half of each channel; 0 - second */

656 0x7f; /* reserved -- always 1 */

657 } else {

658 buf[0] = (fr << 7) | /* FR ID 1 - first half of each channel; 0 - second */

659 (0 << 4) | /* APT (Track application ID) */

660 0x0f; /* reserved -- always 1 */

661 }

662 buf[1] = 0xf0 | /* reserved -- always 1 */

663 (syb_num & 0x0f); /* SSYB number 0 - 11 */

664 buf[2] = 0xff; /* reserved -- always 1 */

665 return 3;

666 }

667

668 static void dv_format_frame(DVVideoContext *c, uint8_t *buf)

669 {

670 int chan, i, j, k;

671

672 for (chan = 0; chan < c->sys->n_difchan; chan++) {

673 for (i = 0; i < c->sys->difseg_size; i++) {

674 memset(buf, 0xff, 80 * 6); /* first 6 DIF blocks are for control data */

675

676 /* DV header: 1DIF */

677 buf += dv_write_dif_id(dv_sect_header, chan, i, 0, buf);

678 buf += dv_write_pack((c->sys->dsf ? dv_header625 : dv_header525),

679 c, buf);

680 buf += 72; /* unused bytes */

681

682 /* DV subcode: 2DIFs */

683 for (j = 0; j < 2; j++) {

684 buf += dv_write_dif_id(dv_sect_subcode, chan, i, j, buf);

685 for (k = 0; k < 6; k++)

686 buf += dv_write_ssyb_id(k, (i < c->sys->difseg_size / 2), buf) + 5;

687 buf += 29; /* unused bytes */

688 }

689

690 /* DV VAUX: 3DIFS */

691 for (j = 0; j < 3; j++) {

692 buf += dv_write_dif_id(dv_sect_vaux, chan, i, j, buf);

693 buf += dv_write_pack(dv_video_source, c, buf);

694 buf += dv_write_pack(dv_video_control, c, buf);

695 buf += 7 * 5;

696 buf += dv_write_pack(dv_video_source, c, buf);

697 buf += dv_write_pack(dv_video_control, c, buf);

698 buf += 4 * 5 + 2; /* unused bytes */

699 }

700

701 /* DV Audio/Video: 135 Video DIFs + 9 Audio DIFs */

702 for (j = 0; j < 135; j++) {

703 if (j % 15 == 0) {

704 memset(buf, 0xff, 80);

705 buf += dv_write_dif_id(dv_sect_audio, chan, i, j / 15, buf);

706 buf += 77; /* audio control & shuffled PCM audio */

707 }

708 buf += dv_write_dif_id(dv_sect_video, chan, i, j, buf);

709 buf += 77; /* 1 video macroblock: 1 bytes control

710 * 4 * 14 bytes Y 8x8 data

711 * 10 bytes Cr 8x8 data

712 * 10 bytes Cb 8x8 data */

713 }

714 }

715 }

716 }

717

718 static int dvvideo_encode_frame(AVCodecContext *c, AVPacket *pkt,

719 const AVFrame *frame, int *got_packet)

720 {

721 DVVideoContext *s = c->priv_data;

722 int ret;

723

724 if ((ret = ff_alloc_packet2(c, pkt, s->sys->frame_size)) < 0)

725 return ret;

726

727 c->pix_fmt = s->sys->pix_fmt;

728 s->frame = frame;

729 c->coded_frame->key_frame = 1;

730 c->coded_frame->pict_type = AV_PICTURE_TYPE_I;

731

732 s->buf = pkt->data;

733 c->execute(c, dv_encode_video_segment, s->work_chunks, NULL,

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

735

736 emms_c();

737

738 dv_format_frame(s, pkt->data);

739

740 pkt->flags |= AV_PKT_FLAG_KEY;

741 *got_packet = 1;

742

743 return 0;

744 }

745

746 static int dvvideo_encode_close(AVCodecContext *avctx)

747 {

748 av_frame_free(&avctx->coded_frame);

749 return 0;

750 }

751

752 AVCodec ff_dvvideo_encoder = {

753 .name = "dvvideo",

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

755 .type = AVMEDIA_TYPE_VIDEO,

756 .id = AV_CODEC_ID_DVVIDEO,

757 .priv_data_size = sizeof(DVVideoContext),

758 .init = dvvideo_encode_init,

759 .encode2 = dvvideo_encode_frame,

760 .close = dvvideo_encode_close,

761 .capabilities = CODEC_CAP_SLICE_THREADS | CODEC_CAP_FRAME_THREADS | CODEC_CAP_INTRA_ONLY,

762 .pix_fmts = (const enum AVPixelFormat[]) {

763 AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV422P,

764 AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE

765 },

766 };

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