3 * Copyright (c) 2003 Roman Shaposhnik
5 * This file is part of FFmpeg.
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.
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.
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
21 * quant_deadzone code and fixes sponsored by NOA GmbH
31 #include "libavutil/attributes.h"
32 #include "libavutil/internal.h"
33 #include "libavutil/opt.h"
34 #include "libavutil/pixdesc.h"
38 #include "dv_profile_internal.h"
39 #include "dv_tablegen.h"
44 #include "pixblockdsp.h"
47 static av_cold int dvvideo_encode_init(AVCodecContext *avctx)
49 DVVideoContext *s = avctx->priv_data;
52 PixblockDSPContext pdsp;
55 s->sys = av_dv_codec_profile2(avctx->width, avctx->height, avctx->pix_fmt, avctx->time_base);
57 av_log(avctx, AV_LOG_ERROR, "Found no DV profile for %ix%i %s video. "
58 "Valid DV profiles are:\n",
59 avctx->width, avctx->height, av_get_pix_fmt_name(avctx->pix_fmt));
60 ff_dv_print_profiles(avctx, AV_LOG_ERROR);
61 return AVERROR(EINVAL);
63 if (avctx->height > 576) {
64 av_log(avctx, AV_LOG_ERROR, "DVCPRO HD encoding is not supported.\n");
65 return AVERROR_PATCHWELCOME;
67 ret = ff_dv_init_dynamic_tables(s, s->sys);
69 av_log(avctx, AV_LOG_ERROR, "Error initializing work tables.\n");
73 dv_vlc_map_tableinit();
75 memset(&fdsp,0, sizeof(fdsp));
76 memset(&mecc,0, sizeof(mecc));
77 memset(&pdsp,0, sizeof(pdsp));
78 ff_fdctdsp_init(&fdsp, avctx);
79 ff_me_cmp_init(&mecc, avctx);
80 ff_pixblockdsp_init(&pdsp, avctx);
81 ff_set_cmp(&mecc, mecc.ildct_cmp, avctx->ildct_cmp);
83 s->get_pixels = pdsp.get_pixels;
84 s->ildct_cmp = mecc.ildct_cmp[5];
86 s->fdct[0] = fdsp.fdct;
87 s->fdct[1] = fdsp.fdct248;
89 return ff_dvvideo_init(avctx);
92 /* bit budget for AC only in 5 MBs */
93 static const int vs_total_ac_bits = (100 * 4 + 68 * 2) * 5;
94 static const int mb_area_start[5] = { 1, 6, 21, 43, 64 };
97 /* Convert run and level (where level != 0) pair into VLC, returning bit size */
98 static av_always_inline int dv_rl2vlc(int run, int level, int sign,
102 if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {
103 *vlc = dv_vlc_map[run][level].vlc | sign;
104 size = dv_vlc_map[run][level].size;
106 if (level < DV_VLC_MAP_LEV_SIZE) {
107 *vlc = dv_vlc_map[0][level].vlc | sign;
108 size = dv_vlc_map[0][level].size;
110 *vlc = 0xfe00 | (level << 1) | sign;
114 *vlc |= ((run < 16) ? dv_vlc_map[run - 1][0].vlc :
115 (0x1f80 | (run - 1))) << size;
116 size += (run < 16) ? dv_vlc_map[run - 1][0].size : 13;
123 static av_always_inline int dv_rl2vlc_size(int run, int level)
127 if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {
128 size = dv_vlc_map[run][level].size;
130 size = (level < DV_VLC_MAP_LEV_SIZE) ? dv_vlc_map[0][level].size : 16;
132 size += (run < 16) ? dv_vlc_map[run - 1][0].size : 13;
137 static av_always_inline int dv_rl2vlc(int run, int l, int sign, uint32_t *vlc)
139 *vlc = dv_vlc_map[run][l].vlc | sign;
140 return dv_vlc_map[run][l].size;
143 static av_always_inline int dv_rl2vlc_size(int run, int l)
145 return dv_vlc_map[run][l].size;
149 typedef struct EncBlockInfo {
159 uint8_t partial_bit_count;
160 uint32_t partial_bit_buffer; /* we can't use uint16_t here */
163 static av_always_inline PutBitContext *dv_encode_ac(EncBlockInfo *bi,
164 PutBitContext *pb_pool,
165 PutBitContext *pb_end)
168 PutBitContext *pb = pb_pool;
169 int size = bi->partial_bit_count;
170 uint32_t vlc = bi->partial_bit_buffer;
172 bi->partial_bit_count =
173 bi->partial_bit_buffer = 0;
175 /* Find suitable storage space */
176 for (; size > (bits_left = put_bits_left(pb)); pb++) {
179 put_bits(pb, bits_left, vlc >> size);
180 vlc = av_mod_uintp2(vlc, size);
182 if (pb + 1 >= pb_end) {
183 bi->partial_bit_count = size;
184 bi->partial_bit_buffer = vlc;
190 put_bits(pb, size, vlc);
192 if (bi->cur_ac >= 64)
195 /* Construct the next VLC */
197 bi->cur_ac = bi->next[prev];
198 if (bi->cur_ac < 64) {
199 size = dv_rl2vlc(bi->cur_ac - prev - 1, bi->mb[bi->cur_ac],
200 bi->sign[bi->cur_ac], &vlc);
203 vlc = 6; /* End Of Block stamp */
209 static av_always_inline int dv_guess_dct_mode(DVVideoContext *s, uint8_t *data,
212 if (s->avctx->flags & AV_CODEC_FLAG_INTERLACED_DCT) {
213 int ps = s->ildct_cmp(NULL, data, NULL, linesize, 8) - 400;
215 int is = s->ildct_cmp(NULL, data, NULL, linesize << 1, 4) +
216 s->ildct_cmp(NULL, data + linesize, NULL, linesize << 1, 4);
224 static const int dv_weight_bits = 18;
225 static const int dv_weight_88[64] = {
226 131072, 257107, 257107, 242189, 252167, 242189, 235923, 237536,
227 237536, 235923, 229376, 231390, 223754, 231390, 229376, 222935,
228 224969, 217965, 217965, 224969, 222935, 200636, 218652, 211916,
229 212325, 211916, 218652, 200636, 188995, 196781, 205965, 206433,
230 206433, 205965, 196781, 188995, 185364, 185364, 200636, 200704,
231 200636, 185364, 185364, 174609, 180568, 195068, 195068, 180568,
232 174609, 170091, 175557, 189591, 175557, 170091, 165371, 170627,
233 170627, 165371, 160727, 153560, 160727, 144651, 144651, 136258,
235 static const int dv_weight_248[64] = {
236 131072, 262144, 257107, 257107, 242189, 242189, 242189, 242189,
237 237536, 237536, 229376, 229376, 200636, 200636, 224973, 224973,
238 223754, 223754, 235923, 235923, 229376, 229376, 217965, 217965,
239 211916, 211916, 196781, 196781, 185364, 185364, 206433, 206433,
240 211916, 211916, 222935, 222935, 200636, 200636, 205964, 205964,
241 200704, 200704, 180568, 180568, 175557, 175557, 195068, 195068,
242 185364, 185364, 188995, 188995, 174606, 174606, 175557, 175557,
243 170627, 170627, 153560, 153560, 165371, 165371, 144651, 144651,
246 static av_always_inline int dv_init_enc_block(EncBlockInfo *bi, uint8_t *data,
248 DVVideoContext *s, int bias)
251 const uint8_t *zigzag_scan;
252 LOCAL_ALIGNED_16(int16_t, blk, [64]);
254 /* We offer two different methods for class number assignment: the
255 * method suggested in SMPTE 314M Table 22, and an improved
256 * method. The SMPTE method is very conservative; it assigns class
257 * 3 (i.e. severe quantization) to any block where the largest AC
258 * component is greater than 36. FFmpeg's DV encoder tracks AC bit
259 * consumption precisely, so there is no need to bias most blocks
260 * towards strongly lossy compression. Instead, we assign class 2
261 * to most blocks, and use class 3 only when strictly necessary
262 * (for blocks whose largest AC component exceeds 255). */
264 #if 0 /* SMPTE spec method */
265 static const int classes[] = { 12, 24, 36, 0xffff };
266 #else /* improved FFmpeg method */
267 static const int classes[] = { -1, -1, 255, 0xffff };
269 int max = classes[0];
271 const unsigned deadzone = s->quant_deadzone;
272 const unsigned threshold = 2 * deadzone;
274 av_assert2((((int) blk) & 15) == 0);
280 bi->partial_bit_count = 0;
281 bi->partial_bit_buffer = 0;
284 bi->dct_mode = dv_guess_dct_mode(s, data, linesize);
285 s->get_pixels(blk, data, linesize);
286 s->fdct[bi->dct_mode](blk);
288 /* We rely on the fact that encoding all zeros leads to an immediate
289 * EOB, which is precisely what the spec calls for in the "dummy"
291 memset(blk, 0, 64 * sizeof(*blk));
296 zigzag_scan = bi->dct_mode ? ff_dv_zigzag248_direct : ff_zigzag_direct;
297 weight = bi->dct_mode ? dv_weight_248 : dv_weight_88;
299 for (area = 0; area < 4; area++) {
300 bi->prev[area] = prev;
301 bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
302 for (i = mb_area_start[area]; i < mb_area_start[area + 1]; i++) {
303 int level = blk[zigzag_scan[i]];
305 if (level + deadzone > threshold) {
306 bi->sign[i] = (level >> 31) & 1;
307 /* Weight it and shift down into range, adding for rounding.
308 * The extra division by a factor of 2^4 reverses the 8x
309 * expansion of the DCT AND the 2x doubling of the weights. */
310 level = (FFABS(level) * weight[i] + (1 << (dv_weight_bits + 3))) >>
311 (dv_weight_bits + 4);
317 bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, level);
324 for (bi->cno = 0; max > classes[bi->cno]; bi->cno++)
333 for (area = 0; area < 4; area++) {
334 bi->prev[area] = prev;
335 bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
336 for (; i < mb_area_start[area + 1]; i = bi->next[i]) {
340 bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, bi->mb[i]);
349 return bi->bit_size[0] + bi->bit_size[1] +
350 bi->bit_size[2] + bi->bit_size[3];
353 static inline void dv_guess_qnos(EncBlockInfo *blks, int *qnos)
356 int i, j, k, a, prev, a2;
366 for (i = 0; i < 5; i++) {
372 for (j = 0; j < 6; j++, b++) {
373 for (a = 0; a < 4; a++) {
374 if (b->area_q[a] != ff_dv_quant_shifts[qnos[i] + ff_dv_quant_offset[b->cno]][a]) {
375 b->bit_size[a] = 1; // 4 areas 4 bits for EOB :)
378 av_assert2(b->next[prev] >= mb_area_start[a + 1] || b->mb[prev]);
379 for (k = b->next[prev]; k < mb_area_start[a + 1]; k = b->next[k]) {
382 b->bit_size[a] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
385 if (b->next[k] >= mb_area_start[a + 1] && b->next[k] < 64) {
386 for (a2 = a + 1; b->next[k] >= mb_area_start[a2 + 1]; a2++)
389 av_assert2(b->mb[b->next[k]]);
390 b->bit_size[a2] += dv_rl2vlc_size(b->next[k] - prev - 1, b->mb[b->next[k]]) -
391 dv_rl2vlc_size(b->next[k] - k - 1, b->mb[b->next[k]]);
392 av_assert2(b->prev[a2] == k && (a2 + 1 >= 4 || b->prev[a2 + 1] != k));
395 b->next[prev] = b->next[k];
398 b->prev[a + 1] = prev;
400 size[i] += b->bit_size[a];
403 if (vs_total_ac_bits >= size[0] + size[1] + size[2] + size[3] + size[4])
406 } while (qnos[0] | qnos[1] | qnos[2] | qnos[3] | qnos[4]);
408 for (a = 2; a == 2 || vs_total_ac_bits < size[0]; a += a) {
410 size[0] = 5 * 6 * 4; // EOB
411 for (j = 0; j < 6 * 5; j++, b++) {
413 for (k = b->next[prev]; k < 64; k = b->next[k]) {
414 if (b->mb[k] < a && b->mb[k] > -a) {
415 b->next[prev] = b->next[k];
417 size[0] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
425 static int dv_encode_video_segment(AVCodecContext *avctx, void *arg)
427 DVVideoContext *s = avctx->priv_data;
428 DVwork_chunk *work_chunk = arg;
430 int mb_x, mb_y, c_offset;
431 ptrdiff_t linesize, y_stride;
434 LOCAL_ALIGNED_8(uint8_t, scratch, [128]);
435 EncBlockInfo enc_blks[5 * DV_MAX_BPM];
436 PutBitContext pbs[5 * DV_MAX_BPM];
438 EncBlockInfo *enc_blk;
440 int qnos[5] = { 15, 15, 15, 15, 15 }; /* No quantization */
441 int *qnosp = &qnos[0];
443 dif = &s->buf[work_chunk->buf_offset * 80];
444 enc_blk = &enc_blks[0];
445 for (mb_index = 0; mb_index < 5; mb_index++) {
446 dv_calculate_mb_xy(s, work_chunk, mb_index, &mb_x, &mb_y);
448 /* initializing luminance blocks */
449 if ((s->sys->pix_fmt == AV_PIX_FMT_YUV420P) ||
450 (s->sys->pix_fmt == AV_PIX_FMT_YUV411P && mb_x >= (704 / 8)) ||
451 (s->sys->height >= 720 && mb_y != 134)) {
452 y_stride = s->frame->linesize[0] << 3;
456 y_ptr = s->frame->data[0] +
457 ((mb_y * s->frame->linesize[0] + mb_x) << 3);
458 linesize = s->frame->linesize[0];
460 if (s->sys->video_stype == 4) { /* SD 422 */
462 dv_init_enc_block(enc_blk + 0, y_ptr, linesize, s, 0) +
463 dv_init_enc_block(enc_blk + 1, NULL, linesize, s, 0) +
464 dv_init_enc_block(enc_blk + 2, y_ptr + 8, linesize, s, 0) +
465 dv_init_enc_block(enc_blk + 3, NULL, linesize, s, 0);
468 dv_init_enc_block(enc_blk + 0, y_ptr, linesize, s, 0) +
469 dv_init_enc_block(enc_blk + 1, y_ptr + 8, linesize, s, 0) +
470 dv_init_enc_block(enc_blk + 2, y_ptr + y_stride, linesize, s, 0) +
471 dv_init_enc_block(enc_blk + 3, y_ptr + 8 + y_stride, linesize, s, 0);
475 /* initializing chrominance blocks */
476 c_offset = (((mb_y >> (s->sys->pix_fmt == AV_PIX_FMT_YUV420P)) * s->frame->linesize[1] +
477 (mb_x >> ((s->sys->pix_fmt == AV_PIX_FMT_YUV411P) ? 2 : 1))) << 3);
478 for (j = 2; j; j--) {
479 uint8_t *c_ptr = s->frame->data[j] + c_offset;
480 linesize = s->frame->linesize[j];
481 y_stride = (mb_y == 134) ? 8 : (s->frame->linesize[j] << 3);
482 if (s->sys->pix_fmt == AV_PIX_FMT_YUV411P && mb_x >= (704 / 8)) {
484 uint8_t *b = scratch;
485 for (i = 0; i < 8; i++) {
486 d = c_ptr + (linesize << 3);
502 vs_bit_size += dv_init_enc_block(enc_blk++, c_ptr, linesize, s, 1);
503 if (s->sys->bpm == 8)
504 vs_bit_size += dv_init_enc_block(enc_blk++, c_ptr + y_stride,
509 if (vs_total_ac_bits < vs_bit_size)
510 dv_guess_qnos(&enc_blks[0], qnosp);
512 /* DIF encoding process */
513 for (j = 0; j < 5 * s->sys->bpm;) {
519 /* First pass over individual cells only */
520 for (i = 0; i < s->sys->bpm; i++, j++) {
521 int sz = s->sys->block_sizes[i] >> 3;
523 init_put_bits(&pbs[j], dif, sz);
524 put_sbits(&pbs[j], 9, ((enc_blks[j].mb[0] >> 3) - 1024 + 2) >> 2);
525 put_bits(&pbs[j], 1, enc_blks[j].dct_mode);
526 put_bits(&pbs[j], 2, enc_blks[j].cno);
528 dv_encode_ac(&enc_blks[j], &pbs[j], &pbs[j + 1]);
532 /* Second pass over each MB space */
534 for (i = 0; i < s->sys->bpm; i++)
535 if (enc_blks[start_mb + i].partial_bit_count)
536 pb = dv_encode_ac(&enc_blks[start_mb + i], pb,
537 &pbs[start_mb + s->sys->bpm]);
540 /* Third and final pass over the whole video segment space */
542 for (j = 0; j < 5 * s->sys->bpm; j++) {
543 if (enc_blks[j].partial_bit_count)
544 pb = dv_encode_ac(&enc_blks[j], pb, &pbs[s->sys->bpm * 5]);
545 if (enc_blks[j].partial_bit_count)
546 av_log(avctx, AV_LOG_ERROR, "ac bitstream overflow\n");
549 for (j = 0; j < 5 * s->sys->bpm; j++) {
551 int size = pbs[j].size_in_bits >> 3;
552 flush_put_bits(&pbs[j]);
553 pos = put_bits_count(&pbs[j]) >> 3;
555 av_log(avctx, AV_LOG_ERROR,
556 "bitstream written beyond buffer size\n");
559 memset(pbs[j].buf + pos, 0xff, size - pos);
565 static inline int dv_write_pack(enum dv_pack_type pack_id, DVVideoContext *c,
569 * Here's what SMPTE314M says about these two:
570 * (page 6) APTn, AP1n, AP2n, AP3n: These data shall be identical
571 * as track application IDs (APTn = 001, AP1n =
572 * 001, AP2n = 001, AP3n = 001), if the source signal
573 * comes from a digital VCR. If the signal source is
574 * unknown, all bits for these data shall be set to 1.
575 * (page 12) STYPE: STYPE defines a signal type of video signal
576 * 00000b = 4:1:1 compression
577 * 00100b = 4:2:2 compression
579 * Now, I've got two problems with these statements:
580 * 1. it looks like APT == 111b should be a safe bet, but it isn't.
581 * It seems that for PAL as defined in IEC 61834 we have to set
582 * APT to 000 and for SMPTE314M to 001.
583 * 2. It is not at all clear what STYPE is used for 4:2:0 PAL
584 * compression scheme (if any).
586 int apt = (c->sys->pix_fmt == AV_PIX_FMT_YUV420P ? 0 : 1);
587 int fs = c->frame->top_field_first ? 0x00 : 0x40;
590 if ((int) (av_q2d(c->avctx->sample_aspect_ratio) *
591 c->avctx->width / c->avctx->height * 10) >= 17) /* 16:9 */
594 buf[0] = (uint8_t) pack_id;
596 case dv_header525: /* I can't imagine why these two weren't defined as real */
597 case dv_header625: /* packs in SMPTE314M -- they definitely look like ones */
598 buf[1] = 0xf8 | /* reserved -- always 1 */
599 (apt & 0x07); /* APT: Track application ID */
600 buf[2] = (0 << 7) | /* TF1: audio data is 0 - valid; 1 - invalid */
601 (0x0f << 3) | /* reserved -- always 1 */
602 (apt & 0x07); /* AP1: Audio application ID */
603 buf[3] = (0 << 7) | /* TF2: video data is 0 - valid; 1 - invalid */
604 (0x0f << 3) | /* reserved -- always 1 */
605 (apt & 0x07); /* AP2: Video application ID */
606 buf[4] = (0 << 7) | /* TF3: subcode(SSYB) is 0 - valid; 1 - invalid */
607 (0x0f << 3) | /* reserved -- always 1 */
608 (apt & 0x07); /* AP3: Subcode application ID */
610 case dv_video_source:
611 buf[1] = 0xff; /* reserved -- always 1 */
612 buf[2] = (1 << 7) | /* B/W: 0 - b/w, 1 - color */
613 (1 << 6) | /* following CLF is valid - 0, invalid - 1 */
614 (3 << 4) | /* CLF: color frames ID (see ITU-R BT.470-4) */
615 0xf; /* reserved -- always 1 */
616 buf[3] = (3 << 6) | /* reserved -- always 1 */
617 (c->sys->dsf << 5) | /* system: 60fields/50fields */
618 c->sys->video_stype; /* signal type video compression */
619 buf[4] = 0xff; /* VISC: 0xff -- no information */
621 case dv_video_control:
622 buf[1] = (0 << 6) | /* Copy generation management (CGMS) 0 -- free */
623 0x3f; /* reserved -- always 1 */
624 buf[2] = 0xc8 | /* reserved -- always b11001xxx */
626 buf[3] = (1 << 7) | /* frame/field flag 1 -- frame, 0 -- field */
627 fs | /* first/second field flag 0 -- field 2, 1 -- field 1 */
628 (1 << 5) | /* frame change flag 0 -- same picture as before, 1 -- different */
629 (1 << 4) | /* 1 - interlaced, 0 - noninterlaced */
630 0xc; /* reserved -- always b1100 */
631 buf[4] = 0xff; /* reserved -- always 1 */
642 static inline int dv_write_dif_id(enum dv_section_type t, uint8_t chan_num,
643 uint8_t seq_num, uint8_t dif_num,
646 buf[0] = (uint8_t) t; /* Section type */
647 buf[1] = (seq_num << 4) | /* DIF seq number 0-9 for 525/60; 0-11 for 625/50 */
648 (chan_num << 3) | /* FSC: for 50Mb/s 0 - first channel; 1 - second */
649 7; /* reserved -- always 1 */
650 buf[2] = dif_num; /* DIF block number Video: 0-134, Audio: 0-8 */
654 static inline int dv_write_ssyb_id(uint8_t syb_num, uint8_t fr, uint8_t *buf)
656 if (syb_num == 0 || syb_num == 6) {
657 buf[0] = (fr << 7) | /* FR ID 1 - first half of each channel; 0 - second */
658 (0 << 4) | /* AP3 (Subcode application ID) */
659 0x0f; /* reserved -- always 1 */
660 } else if (syb_num == 11) {
661 buf[0] = (fr << 7) | /* FR ID 1 - first half of each channel; 0 - second */
662 0x7f; /* reserved -- always 1 */
664 buf[0] = (fr << 7) | /* FR ID 1 - first half of each channel; 0 - second */
665 (0 << 4) | /* APT (Track application ID) */
666 0x0f; /* reserved -- always 1 */
668 buf[1] = 0xf0 | /* reserved -- always 1 */
669 (syb_num & 0x0f); /* SSYB number 0 - 11 */
670 buf[2] = 0xff; /* reserved -- always 1 */
674 static void dv_format_frame(DVVideoContext *c, uint8_t *buf)
678 for (chan = 0; chan < c->sys->n_difchan; chan++) {
679 for (i = 0; i < c->sys->difseg_size; i++) {
680 memset(buf, 0xff, 80 * 6); /* first 6 DIF blocks are for control data */
682 /* DV header: 1DIF */
683 buf += dv_write_dif_id(dv_sect_header, chan, i, 0, buf);
684 buf += dv_write_pack((c->sys->dsf ? dv_header625 : dv_header525),
686 buf += 72; /* unused bytes */
688 /* DV subcode: 2DIFs */
689 for (j = 0; j < 2; j++) {
690 buf += dv_write_dif_id(dv_sect_subcode, chan, i, j, buf);
691 for (k = 0; k < 6; k++)
692 buf += dv_write_ssyb_id(k, (i < c->sys->difseg_size / 2), buf) + 5;
693 buf += 29; /* unused bytes */
697 for (j = 0; j < 3; j++) {
698 buf += dv_write_dif_id(dv_sect_vaux, chan, i, j, buf);
699 buf += dv_write_pack(dv_video_source, c, buf);
700 buf += dv_write_pack(dv_video_control, c, buf);
702 buf += dv_write_pack(dv_video_source, c, buf);
703 buf += dv_write_pack(dv_video_control, c, buf);
704 buf += 4 * 5 + 2; /* unused bytes */
707 /* DV Audio/Video: 135 Video DIFs + 9 Audio DIFs */
708 for (j = 0; j < 135; j++) {
710 memset(buf, 0xff, 80);
711 buf += dv_write_dif_id(dv_sect_audio, chan, i, j / 15, buf);
712 buf += 77; /* audio control & shuffled PCM audio */
714 buf += dv_write_dif_id(dv_sect_video, chan, i, j, buf);
715 buf += 77; /* 1 video macroblock: 1 bytes control
716 * 4 * 14 bytes Y 8x8 data
717 * 10 bytes Cr 8x8 data
718 * 10 bytes Cb 8x8 data */
724 static int dvvideo_encode_frame(AVCodecContext *c, AVPacket *pkt,
725 const AVFrame *frame, int *got_packet)
727 DVVideoContext *s = c->priv_data;
730 if ((ret = ff_alloc_packet2(c, pkt, s->sys->frame_size, 0)) < 0)
733 c->pix_fmt = s->sys->pix_fmt;
735 #if FF_API_CODED_FRAME
736 FF_DISABLE_DEPRECATION_WARNINGS
737 c->coded_frame->key_frame = 1;
738 c->coded_frame->pict_type = AV_PICTURE_TYPE_I;
739 FF_ENABLE_DEPRECATION_WARNINGS
743 c->execute(c, dv_encode_video_segment, s->work_chunks, NULL,
744 dv_work_pool_size(s->sys), sizeof(DVwork_chunk));
748 dv_format_frame(s, pkt->data);
750 pkt->flags |= AV_PKT_FLAG_KEY;
756 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
757 #define OFFSET(x) offsetof(DVVideoContext, x)
758 static const AVOption dv_options[] = {
759 { "quant_deadzone", "Quantizer dead zone", OFFSET(quant_deadzone), AV_OPT_TYPE_INT, { .i64 = 7 }, 0, 1024, VE },
763 static const AVClass dvvideo_encode_class = {
764 .class_name = "dvvideo encoder",
765 .item_name = av_default_item_name,
766 .option = dv_options,
767 .version = LIBAVUTIL_VERSION_INT,
770 AVCodec ff_dvvideo_encoder = {
772 .long_name = NULL_IF_CONFIG_SMALL("DV (Digital Video)"),
773 .type = AVMEDIA_TYPE_VIDEO,
774 .id = AV_CODEC_ID_DVVIDEO,
775 .priv_data_size = sizeof(DVVideoContext),
776 .init = dvvideo_encode_init,
777 .encode2 = dvvideo_encode_frame,
778 .capabilities = AV_CODEC_CAP_SLICE_THREADS | AV_CODEC_CAP_FRAME_THREADS | AV_CODEC_CAP_INTRA_ONLY,
779 .pix_fmts = (const enum AVPixelFormat[]) {
780 AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV422P,
781 AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE
783 .priv_class = &dvvideo_encode_class,