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
29 #include "libavutil/attributes.h"
30 #include "libavutil/internal.h"
31 #include "libavutil/pixdesc.h"
35 #include "dv_profile_internal.h"
36 #include "dv_tablegen.h"
41 #include "pixblockdsp.h"
44 static av_cold int dvvideo_encode_init(AVCodecContext *avctx)
46 DVVideoContext *s = avctx->priv_data;
49 PixblockDSPContext pdsp;
52 s->sys = av_dv_codec_profile2(avctx->width, avctx->height, avctx->pix_fmt, avctx->time_base);
54 av_log(avctx, AV_LOG_ERROR, "Found no DV profile for %ix%i %s video. "
55 "Valid DV profiles are:\n",
56 avctx->width, avctx->height, av_get_pix_fmt_name(avctx->pix_fmt));
57 ff_dv_print_profiles(avctx, AV_LOG_ERROR);
58 return AVERROR(EINVAL);
60 if (avctx->height > 576) {
61 av_log(avctx, AV_LOG_ERROR, "DVCPRO HD encoding is not supported.\n");
62 return AVERROR_PATCHWELCOME;
64 ret = ff_dv_init_dynamic_tables(s, s->sys);
66 av_log(avctx, AV_LOG_ERROR, "Error initializing work tables.\n");
70 dv_vlc_map_tableinit();
72 memset(&fdsp,0, sizeof(fdsp));
73 memset(&mecc,0, sizeof(mecc));
74 memset(&pdsp,0, sizeof(pdsp));
75 ff_fdctdsp_init(&fdsp, avctx);
76 ff_me_cmp_init(&mecc, avctx);
77 ff_pixblockdsp_init(&pdsp, avctx);
78 ff_set_cmp(&mecc, mecc.ildct_cmp, avctx->ildct_cmp);
80 s->get_pixels = pdsp.get_pixels;
81 s->ildct_cmp = mecc.ildct_cmp[5];
83 s->fdct[0] = fdsp.fdct;
84 s->fdct[1] = fdsp.fdct248;
86 return ff_dvvideo_init(avctx);
89 /* bit budget for AC only in 5 MBs */
90 static const int vs_total_ac_bits = (100 * 4 + 68 * 2) * 5;
91 static const int mb_area_start[5] = { 1, 6, 21, 43, 64 };
94 /* Convert run and level (where level != 0) pair into VLC, returning bit size */
95 static av_always_inline int dv_rl2vlc(int run, int level, int sign,
99 if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {
100 *vlc = dv_vlc_map[run][level].vlc | sign;
101 size = dv_vlc_map[run][level].size;
103 if (level < DV_VLC_MAP_LEV_SIZE) {
104 *vlc = dv_vlc_map[0][level].vlc | sign;
105 size = dv_vlc_map[0][level].size;
107 *vlc = 0xfe00 | (level << 1) | sign;
111 *vlc |= ((run < 16) ? dv_vlc_map[run - 1][0].vlc :
112 (0x1f80 | (run - 1))) << size;
113 size += (run < 16) ? dv_vlc_map[run - 1][0].size : 13;
120 static av_always_inline int dv_rl2vlc_size(int run, int level)
124 if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {
125 size = dv_vlc_map[run][level].size;
127 size = (level < DV_VLC_MAP_LEV_SIZE) ? dv_vlc_map[0][level].size : 16;
129 size += (run < 16) ? dv_vlc_map[run - 1][0].size : 13;
134 static av_always_inline int dv_rl2vlc(int run, int l, int sign, uint32_t *vlc)
136 *vlc = dv_vlc_map[run][l].vlc | sign;
137 return dv_vlc_map[run][l].size;
140 static av_always_inline int dv_rl2vlc_size(int run, int l)
142 return dv_vlc_map[run][l].size;
146 typedef struct EncBlockInfo {
156 uint8_t partial_bit_count;
157 uint32_t partial_bit_buffer; /* we can't use uint16_t here */
160 static av_always_inline PutBitContext *dv_encode_ac(EncBlockInfo *bi,
161 PutBitContext *pb_pool,
162 PutBitContext *pb_end)
165 PutBitContext *pb = pb_pool;
166 int size = bi->partial_bit_count;
167 uint32_t vlc = bi->partial_bit_buffer;
169 bi->partial_bit_count =
170 bi->partial_bit_buffer = 0;
172 /* Find suitable storage space */
173 for (; size > (bits_left = put_bits_left(pb)); pb++) {
176 put_bits(pb, bits_left, vlc >> size);
177 vlc = av_mod_uintp2(vlc, size);
179 if (pb + 1 >= pb_end) {
180 bi->partial_bit_count = size;
181 bi->partial_bit_buffer = vlc;
187 put_bits(pb, size, vlc);
189 if (bi->cur_ac >= 64)
192 /* Construct the next VLC */
194 bi->cur_ac = bi->next[prev];
195 if (bi->cur_ac < 64) {
196 size = dv_rl2vlc(bi->cur_ac - prev - 1, bi->mb[bi->cur_ac],
197 bi->sign[bi->cur_ac], &vlc);
200 vlc = 6; /* End Of Block stamp */
206 static av_always_inline int dv_guess_dct_mode(DVVideoContext *s, uint8_t *data,
209 if (s->avctx->flags & AV_CODEC_FLAG_INTERLACED_DCT) {
210 int ps = s->ildct_cmp(NULL, data, NULL, linesize, 8) - 400;
212 int is = s->ildct_cmp(NULL, data, NULL, linesize << 1, 4) +
213 s->ildct_cmp(NULL, data + linesize, NULL, linesize << 1, 4);
221 static const int dv_weight_bits = 18;
222 static const int dv_weight_88[64] = {
223 131072, 257107, 257107, 242189, 252167, 242189, 235923, 237536,
224 237536, 235923, 229376, 231390, 223754, 231390, 229376, 222935,
225 224969, 217965, 217965, 224969, 222935, 200636, 218652, 211916,
226 212325, 211916, 218652, 200636, 188995, 196781, 205965, 206433,
227 206433, 205965, 196781, 188995, 185364, 185364, 200636, 200704,
228 200636, 185364, 185364, 174609, 180568, 195068, 195068, 180568,
229 174609, 170091, 175557, 189591, 175557, 170091, 165371, 170627,
230 170627, 165371, 160727, 153560, 160727, 144651, 144651, 136258,
232 static const int dv_weight_248[64] = {
233 131072, 262144, 257107, 257107, 242189, 242189, 242189, 242189,
234 237536, 237536, 229376, 229376, 200636, 200636, 224973, 224973,
235 223754, 223754, 235923, 235923, 229376, 229376, 217965, 217965,
236 211916, 211916, 196781, 196781, 185364, 185364, 206433, 206433,
237 211916, 211916, 222935, 222935, 200636, 200636, 205964, 205964,
238 200704, 200704, 180568, 180568, 175557, 175557, 195068, 195068,
239 185364, 185364, 188995, 188995, 174606, 174606, 175557, 175557,
240 170627, 170627, 153560, 153560, 165371, 165371, 144651, 144651,
243 static av_always_inline int dv_init_enc_block(EncBlockInfo *bi, uint8_t *data,
245 DVVideoContext *s, int bias)
248 const uint8_t *zigzag_scan;
249 LOCAL_ALIGNED_16(int16_t, blk, [64]);
251 /* We offer two different methods for class number assignment: the
252 * method suggested in SMPTE 314M Table 22, and an improved
253 * method. The SMPTE method is very conservative; it assigns class
254 * 3 (i.e. severe quantization) to any block where the largest AC
255 * component is greater than 36. FFmpeg's DV encoder tracks AC bit
256 * consumption precisely, so there is no need to bias most blocks
257 * towards strongly lossy compression. Instead, we assign class 2
258 * to most blocks, and use class 3 only when strictly necessary
259 * (for blocks whose largest AC component exceeds 255). */
261 #if 0 /* SMPTE spec method */
262 static const int classes[] = { 12, 24, 36, 0xffff };
263 #else /* improved FFmpeg method */
264 static const int classes[] = { -1, -1, 255, 0xffff };
266 int max = classes[0];
269 av_assert2((((int) blk) & 15) == 0);
275 bi->partial_bit_count = 0;
276 bi->partial_bit_buffer = 0;
279 bi->dct_mode = dv_guess_dct_mode(s, data, linesize);
280 s->get_pixels(blk, data, linesize);
281 s->fdct[bi->dct_mode](blk);
283 /* We rely on the fact that encoding all zeros leads to an immediate
284 * EOB, which is precisely what the spec calls for in the "dummy"
286 memset(blk, 0, 64 * sizeof(*blk));
291 zigzag_scan = bi->dct_mode ? ff_dv_zigzag248_direct : ff_zigzag_direct;
292 weight = bi->dct_mode ? dv_weight_248 : dv_weight_88;
294 for (area = 0; area < 4; area++) {
295 bi->prev[area] = prev;
296 bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
297 for (i = mb_area_start[area]; i < mb_area_start[area + 1]; i++) {
298 int level = blk[zigzag_scan[i]];
300 if (level + 15 > 30U) {
301 bi->sign[i] = (level >> 31) & 1;
302 /* Weight it and shift down into range, adding for rounding.
303 * The extra division by a factor of 2^4 reverses the 8x
304 * expansion of the DCT AND the 2x doubling of the weights. */
305 level = (FFABS(level) * weight[i] + (1 << (dv_weight_bits + 3))) >>
306 (dv_weight_bits + 4);
310 bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, level);
317 for (bi->cno = 0; max > classes[bi->cno]; bi->cno++)
326 for (area = 0; area < 4; area++) {
327 bi->prev[area] = prev;
328 bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
329 for (; i < mb_area_start[area + 1]; i = bi->next[i]) {
333 bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, bi->mb[i]);
342 return bi->bit_size[0] + bi->bit_size[1] +
343 bi->bit_size[2] + bi->bit_size[3];
346 static inline void dv_guess_qnos(EncBlockInfo *blks, int *qnos)
349 int i, j, k, a, prev, a2;
359 for (i = 0; i < 5; i++) {
365 for (j = 0; j < 6; j++, b++) {
366 for (a = 0; a < 4; a++) {
367 if (b->area_q[a] != ff_dv_quant_shifts[qnos[i] + ff_dv_quant_offset[b->cno]][a]) {
368 b->bit_size[a] = 1; // 4 areas 4 bits for EOB :)
371 av_assert2(b->next[prev] >= mb_area_start[a + 1] || b->mb[prev]);
372 for (k = b->next[prev]; k < mb_area_start[a + 1]; k = b->next[k]) {
375 b->bit_size[a] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
378 if (b->next[k] >= mb_area_start[a + 1] && b->next[k] < 64) {
379 for (a2 = a + 1; b->next[k] >= mb_area_start[a2 + 1]; a2++)
382 av_assert2(b->mb[b->next[k]]);
383 b->bit_size[a2] += dv_rl2vlc_size(b->next[k] - prev - 1, b->mb[b->next[k]]) -
384 dv_rl2vlc_size(b->next[k] - k - 1, b->mb[b->next[k]]);
385 av_assert2(b->prev[a2] == k && (a2 + 1 >= 4 || b->prev[a2 + 1] != k));
388 b->next[prev] = b->next[k];
391 b->prev[a + 1] = prev;
393 size[i] += b->bit_size[a];
396 if (vs_total_ac_bits >= size[0] + size[1] + size[2] + size[3] + size[4])
399 } while (qnos[0] | qnos[1] | qnos[2] | qnos[3] | qnos[4]);
401 for (a = 2; a == 2 || vs_total_ac_bits < size[0]; a += a) {
403 size[0] = 5 * 6 * 4; // EOB
404 for (j = 0; j < 6 * 5; j++, b++) {
406 for (k = b->next[prev]; k < 64; k = b->next[k]) {
407 if (b->mb[k] < a && b->mb[k] > -a) {
408 b->next[prev] = b->next[k];
410 size[0] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
418 static int dv_encode_video_segment(AVCodecContext *avctx, void *arg)
420 DVVideoContext *s = avctx->priv_data;
421 DVwork_chunk *work_chunk = arg;
423 int mb_x, mb_y, c_offset;
424 ptrdiff_t linesize, y_stride;
427 LOCAL_ALIGNED_8(uint8_t, scratch, [128]);
428 EncBlockInfo enc_blks[5 * DV_MAX_BPM];
429 PutBitContext pbs[5 * DV_MAX_BPM];
431 EncBlockInfo *enc_blk;
433 int qnos[5] = { 15, 15, 15, 15, 15 }; /* No quantization */
434 int *qnosp = &qnos[0];
436 dif = &s->buf[work_chunk->buf_offset * 80];
437 enc_blk = &enc_blks[0];
438 for (mb_index = 0; mb_index < 5; mb_index++) {
439 dv_calculate_mb_xy(s, work_chunk, mb_index, &mb_x, &mb_y);
441 /* initializing luminance blocks */
442 if ((s->sys->pix_fmt == AV_PIX_FMT_YUV420P) ||
443 (s->sys->pix_fmt == AV_PIX_FMT_YUV411P && mb_x >= (704 / 8)) ||
444 (s->sys->height >= 720 && mb_y != 134)) {
445 y_stride = s->frame->linesize[0] << 3;
449 y_ptr = s->frame->data[0] +
450 ((mb_y * s->frame->linesize[0] + mb_x) << 3);
451 linesize = s->frame->linesize[0];
453 if (s->sys->video_stype == 4) { /* SD 422 */
455 dv_init_enc_block(enc_blk + 0, y_ptr, linesize, s, 0) +
456 dv_init_enc_block(enc_blk + 1, NULL, linesize, s, 0) +
457 dv_init_enc_block(enc_blk + 2, y_ptr + 8, linesize, s, 0) +
458 dv_init_enc_block(enc_blk + 3, NULL, linesize, s, 0);
461 dv_init_enc_block(enc_blk + 0, y_ptr, linesize, s, 0) +
462 dv_init_enc_block(enc_blk + 1, y_ptr + 8, linesize, s, 0) +
463 dv_init_enc_block(enc_blk + 2, y_ptr + y_stride, linesize, s, 0) +
464 dv_init_enc_block(enc_blk + 3, y_ptr + 8 + y_stride, linesize, s, 0);
468 /* initializing chrominance blocks */
469 c_offset = (((mb_y >> (s->sys->pix_fmt == AV_PIX_FMT_YUV420P)) * s->frame->linesize[1] +
470 (mb_x >> ((s->sys->pix_fmt == AV_PIX_FMT_YUV411P) ? 2 : 1))) << 3);
471 for (j = 2; j; j--) {
472 uint8_t *c_ptr = s->frame->data[j] + c_offset;
473 linesize = s->frame->linesize[j];
474 y_stride = (mb_y == 134) ? 8 : (s->frame->linesize[j] << 3);
475 if (s->sys->pix_fmt == AV_PIX_FMT_YUV411P && mb_x >= (704 / 8)) {
477 uint8_t *b = scratch;
478 for (i = 0; i < 8; i++) {
479 d = c_ptr + (linesize << 3);
495 vs_bit_size += dv_init_enc_block(enc_blk++, c_ptr, linesize, s, 1);
496 if (s->sys->bpm == 8)
497 vs_bit_size += dv_init_enc_block(enc_blk++, c_ptr + y_stride,
502 if (vs_total_ac_bits < vs_bit_size)
503 dv_guess_qnos(&enc_blks[0], qnosp);
505 /* DIF encoding process */
506 for (j = 0; j < 5 * s->sys->bpm;) {
512 /* First pass over individual cells only */
513 for (i = 0; i < s->sys->bpm; i++, j++) {
514 int sz = s->sys->block_sizes[i] >> 3;
516 init_put_bits(&pbs[j], dif, sz);
517 put_sbits(&pbs[j], 9, ((enc_blks[j].mb[0] >> 3) - 1024 + 2) >> 2);
518 put_bits(&pbs[j], 1, enc_blks[j].dct_mode);
519 put_bits(&pbs[j], 2, enc_blks[j].cno);
521 dv_encode_ac(&enc_blks[j], &pbs[j], &pbs[j + 1]);
525 /* Second pass over each MB space */
527 for (i = 0; i < s->sys->bpm; i++)
528 if (enc_blks[start_mb + i].partial_bit_count)
529 pb = dv_encode_ac(&enc_blks[start_mb + i], pb,
530 &pbs[start_mb + s->sys->bpm]);
533 /* Third and final pass over the whole video segment space */
535 for (j = 0; j < 5 * s->sys->bpm; j++) {
536 if (enc_blks[j].partial_bit_count)
537 pb = dv_encode_ac(&enc_blks[j], pb, &pbs[s->sys->bpm * 5]);
538 if (enc_blks[j].partial_bit_count)
539 av_log(avctx, AV_LOG_ERROR, "ac bitstream overflow\n");
542 for (j = 0; j < 5 * s->sys->bpm; j++) {
544 int size = pbs[j].size_in_bits >> 3;
545 flush_put_bits(&pbs[j]);
546 pos = put_bits_count(&pbs[j]) >> 3;
548 av_log(avctx, AV_LOG_ERROR,
549 "bitstream written beyond buffer size\n");
552 memset(pbs[j].buf + pos, 0xff, size - pos);
558 static inline int dv_write_pack(enum dv_pack_type pack_id, DVVideoContext *c,
562 * Here's what SMPTE314M says about these two:
563 * (page 6) APTn, AP1n, AP2n, AP3n: These data shall be identical
564 * as track application IDs (APTn = 001, AP1n =
565 * 001, AP2n = 001, AP3n = 001), if the source signal
566 * comes from a digital VCR. If the signal source is
567 * unknown, all bits for these data shall be set to 1.
568 * (page 12) STYPE: STYPE defines a signal type of video signal
569 * 00000b = 4:1:1 compression
570 * 00100b = 4:2:2 compression
572 * Now, I've got two problems with these statements:
573 * 1. it looks like APT == 111b should be a safe bet, but it isn't.
574 * It seems that for PAL as defined in IEC 61834 we have to set
575 * APT to 000 and for SMPTE314M to 001.
576 * 2. It is not at all clear what STYPE is used for 4:2:0 PAL
577 * compression scheme (if any).
579 int apt = (c->sys->pix_fmt == AV_PIX_FMT_YUV420P ? 0 : 1);
580 int fs = c->frame->top_field_first ? 0x00 : 0x40;
583 if ((int) (av_q2d(c->avctx->sample_aspect_ratio) *
584 c->avctx->width / c->avctx->height * 10) >= 17) /* 16:9 */
587 buf[0] = (uint8_t) pack_id;
589 case dv_header525: /* I can't imagine why these two weren't defined as real */
590 case dv_header625: /* packs in SMPTE314M -- they definitely look like ones */
591 buf[1] = 0xf8 | /* reserved -- always 1 */
592 (apt & 0x07); /* APT: Track application ID */
593 buf[2] = (0 << 7) | /* TF1: audio data is 0 - valid; 1 - invalid */
594 (0x0f << 3) | /* reserved -- always 1 */
595 (apt & 0x07); /* AP1: Audio application ID */
596 buf[3] = (0 << 7) | /* TF2: video data is 0 - valid; 1 - invalid */
597 (0x0f << 3) | /* reserved -- always 1 */
598 (apt & 0x07); /* AP2: Video application ID */
599 buf[4] = (0 << 7) | /* TF3: subcode(SSYB) is 0 - valid; 1 - invalid */
600 (0x0f << 3) | /* reserved -- always 1 */
601 (apt & 0x07); /* AP3: Subcode application ID */
603 case dv_video_source:
604 buf[1] = 0xff; /* reserved -- always 1 */
605 buf[2] = (1 << 7) | /* B/W: 0 - b/w, 1 - color */
606 (1 << 6) | /* following CLF is valid - 0, invalid - 1 */
607 (3 << 4) | /* CLF: color frames ID (see ITU-R BT.470-4) */
608 0xf; /* reserved -- always 1 */
609 buf[3] = (3 << 6) | /* reserved -- always 1 */
610 (c->sys->dsf << 5) | /* system: 60fields/50fields */
611 c->sys->video_stype; /* signal type video compression */
612 buf[4] = 0xff; /* VISC: 0xff -- no information */
614 case dv_video_control:
615 buf[1] = (0 << 6) | /* Copy generation management (CGMS) 0 -- free */
616 0x3f; /* reserved -- always 1 */
617 buf[2] = 0xc8 | /* reserved -- always b11001xxx */
619 buf[3] = (1 << 7) | /* frame/field flag 1 -- frame, 0 -- field */
620 fs | /* first/second field flag 0 -- field 2, 1 -- field 1 */
621 (1 << 5) | /* frame change flag 0 -- same picture as before, 1 -- different */
622 (1 << 4) | /* 1 - interlaced, 0 - noninterlaced */
623 0xc; /* reserved -- always b1100 */
624 buf[4] = 0xff; /* reserved -- always 1 */
635 static inline int dv_write_dif_id(enum dv_section_type t, uint8_t chan_num,
636 uint8_t seq_num, uint8_t dif_num,
639 buf[0] = (uint8_t) t; /* Section type */
640 buf[1] = (seq_num << 4) | /* DIF seq number 0-9 for 525/60; 0-11 for 625/50 */
641 (chan_num << 3) | /* FSC: for 50Mb/s 0 - first channel; 1 - second */
642 7; /* reserved -- always 1 */
643 buf[2] = dif_num; /* DIF block number Video: 0-134, Audio: 0-8 */
647 static inline int dv_write_ssyb_id(uint8_t syb_num, uint8_t fr, uint8_t *buf)
649 if (syb_num == 0 || syb_num == 6) {
650 buf[0] = (fr << 7) | /* FR ID 1 - first half of each channel; 0 - second */
651 (0 << 4) | /* AP3 (Subcode application ID) */
652 0x0f; /* reserved -- always 1 */
653 } else if (syb_num == 11) {
654 buf[0] = (fr << 7) | /* FR ID 1 - first half of each channel; 0 - second */
655 0x7f; /* reserved -- always 1 */
657 buf[0] = (fr << 7) | /* FR ID 1 - first half of each channel; 0 - second */
658 (0 << 4) | /* APT (Track application ID) */
659 0x0f; /* reserved -- always 1 */
661 buf[1] = 0xf0 | /* reserved -- always 1 */
662 (syb_num & 0x0f); /* SSYB number 0 - 11 */
663 buf[2] = 0xff; /* reserved -- always 1 */
667 static void dv_format_frame(DVVideoContext *c, uint8_t *buf)
671 for (chan = 0; chan < c->sys->n_difchan; chan++) {
672 for (i = 0; i < c->sys->difseg_size; i++) {
673 memset(buf, 0xff, 80 * 6); /* first 6 DIF blocks are for control data */
675 /* DV header: 1DIF */
676 buf += dv_write_dif_id(dv_sect_header, chan, i, 0, buf);
677 buf += dv_write_pack((c->sys->dsf ? dv_header625 : dv_header525),
679 buf += 72; /* unused bytes */
681 /* DV subcode: 2DIFs */
682 for (j = 0; j < 2; j++) {
683 buf += dv_write_dif_id(dv_sect_subcode, chan, i, j, buf);
684 for (k = 0; k < 6; k++)
685 buf += dv_write_ssyb_id(k, (i < c->sys->difseg_size / 2), buf) + 5;
686 buf += 29; /* unused bytes */
690 for (j = 0; j < 3; j++) {
691 buf += dv_write_dif_id(dv_sect_vaux, chan, i, j, buf);
692 buf += dv_write_pack(dv_video_source, c, buf);
693 buf += dv_write_pack(dv_video_control, c, buf);
695 buf += dv_write_pack(dv_video_source, c, buf);
696 buf += dv_write_pack(dv_video_control, c, buf);
697 buf += 4 * 5 + 2; /* unused bytes */
700 /* DV Audio/Video: 135 Video DIFs + 9 Audio DIFs */
701 for (j = 0; j < 135; j++) {
703 memset(buf, 0xff, 80);
704 buf += dv_write_dif_id(dv_sect_audio, chan, i, j / 15, buf);
705 buf += 77; /* audio control & shuffled PCM audio */
707 buf += dv_write_dif_id(dv_sect_video, chan, i, j, buf);
708 buf += 77; /* 1 video macroblock: 1 bytes control
709 * 4 * 14 bytes Y 8x8 data
710 * 10 bytes Cr 8x8 data
711 * 10 bytes Cb 8x8 data */
717 static int dvvideo_encode_frame(AVCodecContext *c, AVPacket *pkt,
718 const AVFrame *frame, int *got_packet)
720 DVVideoContext *s = c->priv_data;
723 if ((ret = ff_alloc_packet2(c, pkt, s->sys->frame_size, 0)) < 0)
726 c->pix_fmt = s->sys->pix_fmt;
728 #if FF_API_CODED_FRAME
729 FF_DISABLE_DEPRECATION_WARNINGS
730 c->coded_frame->key_frame = 1;
731 c->coded_frame->pict_type = AV_PICTURE_TYPE_I;
732 FF_ENABLE_DEPRECATION_WARNINGS
736 c->execute(c, dv_encode_video_segment, s->work_chunks, NULL,
737 dv_work_pool_size(s->sys), sizeof(DVwork_chunk));
741 dv_format_frame(s, pkt->data);
743 pkt->flags |= AV_PKT_FLAG_KEY;
749 AVCodec ff_dvvideo_encoder = {
751 .long_name = NULL_IF_CONFIG_SMALL("DV (Digital Video)"),
752 .type = AVMEDIA_TYPE_VIDEO,
753 .id = AV_CODEC_ID_DVVIDEO,
754 .priv_data_size = sizeof(DVVideoContext),
755 .init = dvvideo_encode_init,
756 .encode2 = dvvideo_encode_frame,
757 .capabilities = AV_CODEC_CAP_SLICE_THREADS | AV_CODEC_CAP_FRAME_THREADS | AV_CODEC_CAP_INTRA_ONLY,
758 .pix_fmts = (const enum AVPixelFormat[]) {
759 AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV422P,
760 AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE