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/pixdesc.h"
34 #include "dv_profile_internal.h"
35 #include "dv_tablegen.h"
39 #include "pixblockdsp.h"
42 static av_cold int dvvideo_encode_init(AVCodecContext *avctx)
44 DVVideoContext *s = avctx->priv_data;
47 PixblockDSPContext pdsp;
50 s->sys = av_dv_codec_profile2(avctx->width, avctx->height, avctx->pix_fmt, avctx->time_base);
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);
58 if (avctx->height > 576) {
59 av_log(avctx, AV_LOG_ERROR, "DVCPRO HD encoding is not supported.\n");
60 return AVERROR_PATCHWELCOME;
62 ret = ff_dv_init_dynamic_tables(s, s->sys);
64 av_log(avctx, AV_LOG_ERROR, "Error initializing work tables.\n");
68 dv_vlc_map_tableinit();
70 memset(&fdsp,0, sizeof(fdsp));
71 memset(&mecc,0, sizeof(mecc));
72 memset(&pdsp,0, sizeof(pdsp));
73 ff_fdctdsp_init(&fdsp, avctx);
74 ff_me_cmp_init(&mecc, avctx);
75 ff_pixblockdsp_init(&pdsp, avctx);
76 ff_set_cmp(&mecc, mecc.ildct_cmp, avctx->ildct_cmp);
78 s->get_pixels = pdsp.get_pixels;
79 s->ildct_cmp = mecc.ildct_cmp[5];
81 s->fdct[0] = fdsp.fdct;
82 s->fdct[1] = fdsp.fdct248;
84 return ff_dvvideo_init(avctx);
87 /* bit budget for AC only in 5 MBs */
88 static const int vs_total_ac_bits = (100 * 4 + 68 * 2) * 5;
89 static const int mb_area_start[5] = { 1, 6, 21, 43, 64 };
92 /* Convert run and level (where level != 0) pair into VLC, returning bit size */
93 static av_always_inline int dv_rl2vlc(int run, int level, int sign,
97 if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {
98 *vlc = dv_vlc_map[run][level].vlc | sign;
99 size = dv_vlc_map[run][level].size;
101 if (level < DV_VLC_MAP_LEV_SIZE) {
102 *vlc = dv_vlc_map[0][level].vlc | sign;
103 size = dv_vlc_map[0][level].size;
105 *vlc = 0xfe00 | (level << 1) | sign;
109 *vlc |= ((run < 16) ? dv_vlc_map[run - 1][0].vlc :
110 (0x1f80 | (run - 1))) << size;
111 size += (run < 16) ? dv_vlc_map[run - 1][0].size : 13;
118 static av_always_inline int dv_rl2vlc_size(int run, int level)
122 if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {
123 size = dv_vlc_map[run][level].size;
125 size = (level < DV_VLC_MAP_LEV_SIZE) ? dv_vlc_map[0][level].size : 16;
127 size += (run < 16) ? dv_vlc_map[run - 1][0].size : 13;
132 static av_always_inline int dv_rl2vlc(int run, int l, int sign, uint32_t *vlc)
134 *vlc = dv_vlc_map[run][l].vlc | sign;
135 return dv_vlc_map[run][l].size;
138 static av_always_inline int dv_rl2vlc_size(int run, int l)
140 return dv_vlc_map[run][l].size;
144 typedef struct EncBlockInfo {
154 uint8_t partial_bit_count;
155 uint32_t partial_bit_buffer; /* we can't use uint16_t here */
158 static av_always_inline PutBitContext *dv_encode_ac(EncBlockInfo *bi,
159 PutBitContext *pb_pool,
160 PutBitContext *pb_end)
163 PutBitContext *pb = pb_pool;
164 int size = bi->partial_bit_count;
165 uint32_t vlc = bi->partial_bit_buffer;
167 bi->partial_bit_count =
168 bi->partial_bit_buffer = 0;
170 /* Find suitable storage space */
171 for (; size > (bits_left = put_bits_left(pb)); pb++) {
174 put_bits(pb, bits_left, vlc >> size);
175 vlc = av_mod_uintp2(vlc, size);
177 if (pb + 1 >= pb_end) {
178 bi->partial_bit_count = size;
179 bi->partial_bit_buffer = vlc;
185 put_bits(pb, size, vlc);
187 if (bi->cur_ac >= 64)
190 /* Construct the next VLC */
192 bi->cur_ac = bi->next[prev];
193 if (bi->cur_ac < 64) {
194 size = dv_rl2vlc(bi->cur_ac - prev - 1, bi->mb[bi->cur_ac],
195 bi->sign[bi->cur_ac], &vlc);
198 vlc = 6; /* End Of Block stamp */
204 static av_always_inline int dv_guess_dct_mode(DVVideoContext *s, uint8_t *data,
207 if (s->avctx->flags & AV_CODEC_FLAG_INTERLACED_DCT) {
208 int ps = s->ildct_cmp(NULL, data, NULL, linesize, 8) - 400;
210 int is = s->ildct_cmp(NULL, data, NULL, linesize << 1, 4) +
211 s->ildct_cmp(NULL, data + linesize, NULL, linesize << 1, 4);
219 static const int dv_weight_bits = 18;
220 static const int dv_weight_88[64] = {
221 131072, 257107, 257107, 242189, 252167, 242189, 235923, 237536,
222 237536, 235923, 229376, 231390, 223754, 231390, 229376, 222935,
223 224969, 217965, 217965, 224969, 222935, 200636, 218652, 211916,
224 212325, 211916, 218652, 200636, 188995, 196781, 205965, 206433,
225 206433, 205965, 196781, 188995, 185364, 185364, 200636, 200704,
226 200636, 185364, 185364, 174609, 180568, 195068, 195068, 180568,
227 174609, 170091, 175557, 189591, 175557, 170091, 165371, 170627,
228 170627, 165371, 160727, 153560, 160727, 144651, 144651, 136258,
230 static const int dv_weight_248[64] = {
231 131072, 262144, 257107, 257107, 242189, 242189, 242189, 242189,
232 237536, 237536, 229376, 229376, 200636, 200636, 224973, 224973,
233 223754, 223754, 235923, 235923, 229376, 229376, 217965, 217965,
234 211916, 211916, 196781, 196781, 185364, 185364, 206433, 206433,
235 211916, 211916, 222935, 222935, 200636, 200636, 205964, 205964,
236 200704, 200704, 180568, 180568, 175557, 175557, 195068, 195068,
237 185364, 185364, 188995, 188995, 174606, 174606, 175557, 175557,
238 170627, 170627, 153560, 153560, 165371, 165371, 144651, 144651,
241 static av_always_inline int dv_init_enc_block(EncBlockInfo *bi, uint8_t *data,
242 int linesize, DVVideoContext *s,
246 const uint8_t *zigzag_scan;
247 LOCAL_ALIGNED_16(int16_t, blk, [64]);
249 /* We offer two different methods for class number assignment: the
250 * method suggested in SMPTE 314M Table 22, and an improved
251 * method. The SMPTE method is very conservative; it assigns class
252 * 3 (i.e. severe quantization) to any block where the largest AC
253 * component is greater than 36. FFmpeg's DV encoder tracks AC bit
254 * consumption precisely, so there is no need to bias most blocks
255 * towards strongly lossy compression. Instead, we assign class 2
256 * to most blocks, and use class 3 only when strictly necessary
257 * (for blocks whose largest AC component exceeds 255). */
259 #if 0 /* SMPTE spec method */
260 static const int classes[] = { 12, 24, 36, 0xffff };
261 #else /* improved FFmpeg method */
262 static const int classes[] = { -1, -1, 255, 0xffff };
264 int max = classes[0];
267 av_assert2((((int) blk) & 15) == 0);
273 bi->partial_bit_count = 0;
274 bi->partial_bit_buffer = 0;
277 bi->dct_mode = dv_guess_dct_mode(s, data, linesize);
278 s->get_pixels(blk, data, linesize);
279 s->fdct[bi->dct_mode](blk);
281 /* We rely on the fact that encoding all zeros leads to an immediate
282 * EOB, which is precisely what the spec calls for in the "dummy"
284 memset(blk, 0, 64 * sizeof(*blk));
289 zigzag_scan = bi->dct_mode ? ff_dv_zigzag248_direct : ff_zigzag_direct;
290 weight = bi->dct_mode ? dv_weight_248 : dv_weight_88;
292 for (area = 0; area < 4; area++) {
293 bi->prev[area] = prev;
294 bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
295 for (i = mb_area_start[area]; i < mb_area_start[area + 1]; i++) {
296 int level = blk[zigzag_scan[i]];
298 if (level + 15 > 30U) {
299 bi->sign[i] = (level >> 31) & 1;
300 /* Weight it and shift down into range, adding for rounding.
301 * The extra division by a factor of 2^4 reverses the 8x
302 * expansion of the DCT AND the 2x doubling of the weights. */
303 level = (FFABS(level) * weight[i] + (1 << (dv_weight_bits + 3))) >>
304 (dv_weight_bits + 4);
308 bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, level);
315 for (bi->cno = 0; max > classes[bi->cno]; bi->cno++)
324 for (area = 0; area < 4; area++) {
325 bi->prev[area] = prev;
326 bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
327 for (; i < mb_area_start[area + 1]; i = bi->next[i]) {
331 bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, bi->mb[i]);
340 return bi->bit_size[0] + bi->bit_size[1] +
341 bi->bit_size[2] + bi->bit_size[3];
344 static inline void dv_guess_qnos(EncBlockInfo *blks, int *qnos)
347 int i, j, k, a, prev, a2;
357 for (i = 0; i < 5; i++) {
363 for (j = 0; j < 6; j++, b++) {
364 for (a = 0; a < 4; a++) {
365 if (b->area_q[a] != ff_dv_quant_shifts[qnos[i] + ff_dv_quant_offset[b->cno]][a]) {
366 b->bit_size[a] = 1; // 4 areas 4 bits for EOB :)
369 av_assert2(b->next[prev] >= mb_area_start[a + 1] || b->mb[prev]);
370 for (k = b->next[prev]; k < mb_area_start[a + 1]; k = b->next[k]) {
373 b->bit_size[a] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
376 if (b->next[k] >= mb_area_start[a + 1] && b->next[k] < 64) {
377 for (a2 = a + 1; b->next[k] >= mb_area_start[a2 + 1]; a2++)
380 av_assert2(b->mb[b->next[k]]);
381 b->bit_size[a2] += dv_rl2vlc_size(b->next[k] - prev - 1, b->mb[b->next[k]]) -
382 dv_rl2vlc_size(b->next[k] - k - 1, b->mb[b->next[k]]);
383 av_assert2(b->prev[a2] == k && (a2 + 1 >= 4 || b->prev[a2 + 1] != k));
386 b->next[prev] = b->next[k];
389 b->prev[a + 1] = prev;
391 size[i] += b->bit_size[a];
394 if (vs_total_ac_bits >= size[0] + size[1] + size[2] + size[3] + size[4])
397 } while (qnos[0] | qnos[1] | qnos[2] | qnos[3] | qnos[4]);
399 for (a = 2; a == 2 || vs_total_ac_bits < size[0]; a += a) {
401 size[0] = 5 * 6 * 4; // EOB
402 for (j = 0; j < 6 * 5; j++, b++) {
404 for (k = b->next[prev]; k < 64; k = b->next[k]) {
405 if (b->mb[k] < a && b->mb[k] > -a) {
406 b->next[prev] = b->next[k];
408 size[0] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
416 static int dv_encode_video_segment(AVCodecContext *avctx, void *arg)
418 DVVideoContext *s = avctx->priv_data;
419 DVwork_chunk *work_chunk = arg;
421 int mb_x, mb_y, c_offset, linesize, y_stride;
424 LOCAL_ALIGNED_8(uint8_t, scratch, [128]);
425 EncBlockInfo enc_blks[5 * DV_MAX_BPM];
426 PutBitContext pbs[5 * DV_MAX_BPM];
428 EncBlockInfo *enc_blk;
430 int qnos[5] = { 15, 15, 15, 15, 15 }; /* No quantization */
431 int *qnosp = &qnos[0];
433 dif = &s->buf[work_chunk->buf_offset * 80];
434 enc_blk = &enc_blks[0];
435 for (mb_index = 0; mb_index < 5; mb_index++) {
436 dv_calculate_mb_xy(s, work_chunk, mb_index, &mb_x, &mb_y);
438 /* initializing luminance blocks */
439 if ((s->sys->pix_fmt == AV_PIX_FMT_YUV420P) ||
440 (s->sys->pix_fmt == AV_PIX_FMT_YUV411P && mb_x >= (704 / 8)) ||
441 (s->sys->height >= 720 && mb_y != 134)) {
442 y_stride = s->frame->linesize[0] << 3;
446 y_ptr = s->frame->data[0] +
447 ((mb_y * s->frame->linesize[0] + mb_x) << 3);
448 linesize = s->frame->linesize[0];
450 if (s->sys->video_stype == 4) { /* SD 422 */
452 dv_init_enc_block(enc_blk + 0, y_ptr, linesize, s, 0) +
453 dv_init_enc_block(enc_blk + 1, NULL, linesize, s, 0) +
454 dv_init_enc_block(enc_blk + 2, y_ptr + 8, linesize, s, 0) +
455 dv_init_enc_block(enc_blk + 3, NULL, linesize, s, 0);
458 dv_init_enc_block(enc_blk + 0, y_ptr, linesize, s, 0) +
459 dv_init_enc_block(enc_blk + 1, y_ptr + 8, linesize, s, 0) +
460 dv_init_enc_block(enc_blk + 2, y_ptr + y_stride, linesize, s, 0) +
461 dv_init_enc_block(enc_blk + 3, y_ptr + 8 + y_stride, linesize, s, 0);
465 /* initializing chrominance blocks */
466 c_offset = (((mb_y >> (s->sys->pix_fmt == AV_PIX_FMT_YUV420P)) * s->frame->linesize[1] +
467 (mb_x >> ((s->sys->pix_fmt == AV_PIX_FMT_YUV411P) ? 2 : 1))) << 3);
468 for (j = 2; j; j--) {
469 uint8_t *c_ptr = s->frame->data[j] + c_offset;
470 linesize = s->frame->linesize[j];
471 y_stride = (mb_y == 134) ? 8 : (s->frame->linesize[j] << 3);
472 if (s->sys->pix_fmt == AV_PIX_FMT_YUV411P && mb_x >= (704 / 8)) {
474 uint8_t *b = scratch;
475 for (i = 0; i < 8; i++) {
476 d = c_ptr + (linesize << 3);
492 vs_bit_size += dv_init_enc_block(enc_blk++, c_ptr, linesize, s, 1);
493 if (s->sys->bpm == 8)
494 vs_bit_size += dv_init_enc_block(enc_blk++, c_ptr + y_stride,
499 if (vs_total_ac_bits < vs_bit_size)
500 dv_guess_qnos(&enc_blks[0], qnosp);
502 /* DIF encoding process */
503 for (j = 0; j < 5 * s->sys->bpm;) {
509 /* First pass over individual cells only */
510 for (i = 0; i < s->sys->bpm; i++, j++) {
511 int sz = s->sys->block_sizes[i] >> 3;
513 init_put_bits(&pbs[j], dif, sz);
514 put_sbits(&pbs[j], 9, ((enc_blks[j].mb[0] >> 3) - 1024 + 2) >> 2);
515 put_bits(&pbs[j], 1, enc_blks[j].dct_mode);
516 put_bits(&pbs[j], 2, enc_blks[j].cno);
518 dv_encode_ac(&enc_blks[j], &pbs[j], &pbs[j + 1]);
522 /* Second pass over each MB space */
524 for (i = 0; i < s->sys->bpm; i++)
525 if (enc_blks[start_mb + i].partial_bit_count)
526 pb = dv_encode_ac(&enc_blks[start_mb + i], pb,
527 &pbs[start_mb + s->sys->bpm]);
530 /* Third and final pass over the whole video segment space */
532 for (j = 0; j < 5 * s->sys->bpm; j++) {
533 if (enc_blks[j].partial_bit_count)
534 pb = dv_encode_ac(&enc_blks[j], pb, &pbs[s->sys->bpm * 5]);
535 if (enc_blks[j].partial_bit_count)
536 av_log(avctx, AV_LOG_ERROR, "ac bitstream overflow\n");
539 for (j = 0; j < 5 * s->sys->bpm; j++) {
541 int size = pbs[j].size_in_bits >> 3;
542 flush_put_bits(&pbs[j]);
543 pos = put_bits_count(&pbs[j]) >> 3;
545 av_log(avctx, AV_LOG_ERROR,
546 "bitstream written beyond buffer size\n");
549 memset(pbs[j].buf + pos, 0xff, size - pos);
555 static inline int dv_write_pack(enum dv_pack_type pack_id, DVVideoContext *c,
559 * Here's what SMPTE314M says about these two:
560 * (page 6) APTn, AP1n, AP2n, AP3n: These data shall be identical
561 * as track application IDs (APTn = 001, AP1n =
562 * 001, AP2n = 001, AP3n = 001), if the source signal
563 * comes from a digital VCR. If the signal source is
564 * unknown, all bits for these data shall be set to 1.
565 * (page 12) STYPE: STYPE defines a signal type of video signal
566 * 00000b = 4:1:1 compression
567 * 00100b = 4:2:2 compression
569 * Now, I've got two problems with these statements:
570 * 1. it looks like APT == 111b should be a safe bet, but it isn't.
571 * It seems that for PAL as defined in IEC 61834 we have to set
572 * APT to 000 and for SMPTE314M to 001.
573 * 2. It is not at all clear what STYPE is used for 4:2:0 PAL
574 * compression scheme (if any).
576 int apt = (c->sys->pix_fmt == AV_PIX_FMT_YUV420P ? 0 : 1);
577 int fs = c->frame->top_field_first ? 0x00 : 0x40;
580 if ((int) (av_q2d(c->avctx->sample_aspect_ratio) *
581 c->avctx->width / c->avctx->height * 10) >= 17) /* 16:9 */
584 buf[0] = (uint8_t) pack_id;
586 case dv_header525: /* I can't imagine why these two weren't defined as real */
587 case dv_header625: /* packs in SMPTE314M -- they definitely look like ones */
588 buf[1] = 0xf8 | /* reserved -- always 1 */
589 (apt & 0x07); /* APT: Track application ID */
590 buf[2] = (0 << 7) | /* TF1: audio data is 0 - valid; 1 - invalid */
591 (0x0f << 3) | /* reserved -- always 1 */
592 (apt & 0x07); /* AP1: Audio application ID */
593 buf[3] = (0 << 7) | /* TF2: video data is 0 - valid; 1 - invalid */
594 (0x0f << 3) | /* reserved -- always 1 */
595 (apt & 0x07); /* AP2: Video application ID */
596 buf[4] = (0 << 7) | /* TF3: subcode(SSYB) is 0 - valid; 1 - invalid */
597 (0x0f << 3) | /* reserved -- always 1 */
598 (apt & 0x07); /* AP3: Subcode application ID */
600 case dv_video_source:
601 buf[1] = 0xff; /* reserved -- always 1 */
602 buf[2] = (1 << 7) | /* B/W: 0 - b/w, 1 - color */
603 (1 << 6) | /* following CLF is valid - 0, invalid - 1 */
604 (3 << 4) | /* CLF: color frames ID (see ITU-R BT.470-4) */
605 0xf; /* reserved -- always 1 */
606 buf[3] = (3 << 6) | /* reserved -- always 1 */
607 (c->sys->dsf << 5) | /* system: 60fields/50fields */
608 c->sys->video_stype; /* signal type video compression */
609 buf[4] = 0xff; /* VISC: 0xff -- no information */
611 case dv_video_control:
612 buf[1] = (0 << 6) | /* Copy generation management (CGMS) 0 -- free */
613 0x3f; /* reserved -- always 1 */
614 buf[2] = 0xc8 | /* reserved -- always b11001xxx */
616 buf[3] = (1 << 7) | /* frame/field flag 1 -- frame, 0 -- field */
617 fs | /* first/second field flag 0 -- field 2, 1 -- field 1 */
618 (1 << 5) | /* frame change flag 0 -- same picture as before, 1 -- different */
619 (1 << 4) | /* 1 - interlaced, 0 - noninterlaced */
620 0xc; /* reserved -- always b1100 */
621 buf[4] = 0xff; /* reserved -- always 1 */
632 static inline int dv_write_dif_id(enum dv_section_type t, uint8_t chan_num,
633 uint8_t seq_num, uint8_t dif_num,
636 buf[0] = (uint8_t) t; /* Section type */
637 buf[1] = (seq_num << 4) | /* DIF seq number 0-9 for 525/60; 0-11 for 625/50 */
638 (chan_num << 3) | /* FSC: for 50Mb/s 0 - first channel; 1 - second */
639 7; /* reserved -- always 1 */
640 buf[2] = dif_num; /* DIF block number Video: 0-134, Audio: 0-8 */
644 static inline int dv_write_ssyb_id(uint8_t syb_num, uint8_t fr, uint8_t *buf)
646 if (syb_num == 0 || syb_num == 6) {
647 buf[0] = (fr << 7) | /* FR ID 1 - first half of each channel; 0 - second */
648 (0 << 4) | /* AP3 (Subcode application ID) */
649 0x0f; /* reserved -- always 1 */
650 } else if (syb_num == 11) {
651 buf[0] = (fr << 7) | /* FR ID 1 - first half of each channel; 0 - second */
652 0x7f; /* reserved -- always 1 */
654 buf[0] = (fr << 7) | /* FR ID 1 - first half of each channel; 0 - second */
655 (0 << 4) | /* APT (Track application ID) */
656 0x0f; /* reserved -- always 1 */
658 buf[1] = 0xf0 | /* reserved -- always 1 */
659 (syb_num & 0x0f); /* SSYB number 0 - 11 */
660 buf[2] = 0xff; /* reserved -- always 1 */
664 static void dv_format_frame(DVVideoContext *c, uint8_t *buf)
668 for (chan = 0; chan < c->sys->n_difchan; chan++) {
669 for (i = 0; i < c->sys->difseg_size; i++) {
670 memset(buf, 0xff, 80 * 6); /* first 6 DIF blocks are for control data */
672 /* DV header: 1DIF */
673 buf += dv_write_dif_id(dv_sect_header, chan, i, 0, buf);
674 buf += dv_write_pack((c->sys->dsf ? dv_header625 : dv_header525),
676 buf += 72; /* unused bytes */
678 /* DV subcode: 2DIFs */
679 for (j = 0; j < 2; j++) {
680 buf += dv_write_dif_id(dv_sect_subcode, chan, i, j, buf);
681 for (k = 0; k < 6; k++)
682 buf += dv_write_ssyb_id(k, (i < c->sys->difseg_size / 2), buf) + 5;
683 buf += 29; /* unused bytes */
687 for (j = 0; j < 3; j++) {
688 buf += dv_write_dif_id(dv_sect_vaux, chan, i, j, buf);
689 buf += dv_write_pack(dv_video_source, c, buf);
690 buf += dv_write_pack(dv_video_control, c, buf);
692 buf += dv_write_pack(dv_video_source, c, buf);
693 buf += dv_write_pack(dv_video_control, c, buf);
694 buf += 4 * 5 + 2; /* unused bytes */
697 /* DV Audio/Video: 135 Video DIFs + 9 Audio DIFs */
698 for (j = 0; j < 135; j++) {
700 memset(buf, 0xff, 80);
701 buf += dv_write_dif_id(dv_sect_audio, chan, i, j / 15, buf);
702 buf += 77; /* audio control & shuffled PCM audio */
704 buf += dv_write_dif_id(dv_sect_video, chan, i, j, buf);
705 buf += 77; /* 1 video macroblock: 1 bytes control
706 * 4 * 14 bytes Y 8x8 data
707 * 10 bytes Cr 8x8 data
708 * 10 bytes Cb 8x8 data */
714 static int dvvideo_encode_frame(AVCodecContext *c, AVPacket *pkt,
715 const AVFrame *frame, int *got_packet)
717 DVVideoContext *s = c->priv_data;
720 if ((ret = ff_alloc_packet2(c, pkt, s->sys->frame_size, 0)) < 0)
723 c->pix_fmt = s->sys->pix_fmt;
725 #if FF_API_CODED_FRAME
726 FF_DISABLE_DEPRECATION_WARNINGS
727 c->coded_frame->key_frame = 1;
728 c->coded_frame->pict_type = AV_PICTURE_TYPE_I;
729 FF_ENABLE_DEPRECATION_WARNINGS
733 c->execute(c, dv_encode_video_segment, s->work_chunks, NULL,
734 dv_work_pool_size(s->sys), sizeof(DVwork_chunk));
738 dv_format_frame(s, pkt->data);
740 pkt->flags |= AV_PKT_FLAG_KEY;
746 AVCodec ff_dvvideo_encoder = {
748 .long_name = NULL_IF_CONFIG_SMALL("DV (Digital Video)"),
749 .type = AVMEDIA_TYPE_VIDEO,
750 .id = AV_CODEC_ID_DVVIDEO,
751 .priv_data_size = sizeof(DVVideoContext),
752 .init = dvvideo_encode_init,
753 .encode2 = dvvideo_encode_frame,
754 .capabilities = AV_CODEC_CAP_SLICE_THREADS | AV_CODEC_CAP_FRAME_THREADS | AV_CODEC_CAP_INTRA_ONLY,
755 .pix_fmts = (const enum AVPixelFormat[]) {
756 AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV422P,
757 AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE