3 * Copyright (c) 2003 Roman Shaposhnik
5 * This file is part of Libav.
7 * Libav 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 * Libav 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 Libav; 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_profile(avctx->width, avctx->height, avctx->pix_fmt);
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 ret = ff_dv_init_dynamic_tables(s, s->sys);
62 av_log(avctx, AV_LOG_ERROR, "Error initializing work tables.\n");
66 dv_vlc_map_tableinit();
68 ff_fdctdsp_init(&fdsp, avctx);
69 ff_me_cmp_init(&mecc, avctx);
70 ff_pixblockdsp_init(&pdsp, avctx);
71 ff_set_cmp(&mecc, mecc.ildct_cmp, avctx->ildct_cmp);
73 s->get_pixels = pdsp.get_pixels;
74 s->ildct_cmp = mecc.ildct_cmp[5];
76 s->fdct[0] = fdsp.fdct;
77 s->fdct[1] = fdsp.fdct248;
79 return ff_dvvideo_init(avctx);
82 /* bit budget for AC only in 5 MBs */
83 static const int vs_total_ac_bits = (100 * 4 + 68 * 2) * 5;
84 static const int mb_area_start[5] = { 1, 6, 21, 43, 64 };
87 /* Convert run and level (where level != 0) pair into VLC, returning bit size */
88 static av_always_inline int dv_rl2vlc(int run, int level, int sign,
92 if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {
93 *vlc = dv_vlc_map[run][level].vlc | sign;
94 size = dv_vlc_map[run][level].size;
96 if (level < DV_VLC_MAP_LEV_SIZE) {
97 *vlc = dv_vlc_map[0][level].vlc | sign;
98 size = dv_vlc_map[0][level].size;
100 *vlc = 0xfe00 | (level << 1) | sign;
104 *vlc |= ((run < 16) ? dv_vlc_map[run - 1][0].vlc :
105 (0x1f80 | (run - 1))) << size;
106 size += (run < 16) ? dv_vlc_map[run - 1][0].size : 13;
113 static av_always_inline int dv_rl2vlc_size(int run, int level)
117 if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {
118 size = dv_vlc_map[run][level].size;
120 size = (level < DV_VLC_MAP_LEV_SIZE) ? dv_vlc_map[0][level].size : 16;
122 size += (run < 16) ? dv_vlc_map[run - 1][0].size : 13;
127 static av_always_inline int dv_rl2vlc(int run, int l, int sign, uint32_t *vlc)
129 *vlc = dv_vlc_map[run][l].vlc | sign;
130 return dv_vlc_map[run][l].size;
133 static av_always_inline int dv_rl2vlc_size(int run, int l)
135 return dv_vlc_map[run][l].size;
139 typedef struct EncBlockInfo {
149 uint8_t partial_bit_count;
150 uint32_t partial_bit_buffer; /* we can't use uint16_t here */
153 static av_always_inline PutBitContext *dv_encode_ac(EncBlockInfo *bi,
154 PutBitContext *pb_pool,
155 PutBitContext *pb_end)
158 PutBitContext *pb = pb_pool;
159 int size = bi->partial_bit_count;
160 uint32_t vlc = bi->partial_bit_buffer;
162 bi->partial_bit_count =
163 bi->partial_bit_buffer = 0;
165 /* Find suitable storage space */
166 for (; size > (bits_left = put_bits_left(pb)); pb++) {
169 put_bits(pb, bits_left, vlc >> size);
170 vlc = vlc & ((1 << size) - 1);
172 if (pb + 1 >= pb_end) {
173 bi->partial_bit_count = size;
174 bi->partial_bit_buffer = vlc;
180 put_bits(pb, size, vlc);
182 if (bi->cur_ac >= 64)
185 /* Construct the next VLC */
187 bi->cur_ac = bi->next[prev];
188 if (bi->cur_ac < 64) {
189 size = dv_rl2vlc(bi->cur_ac - prev - 1, bi->mb[bi->cur_ac],
190 bi->sign[bi->cur_ac], &vlc);
193 vlc = 6; /* End Of Block stamp */
199 static av_always_inline int dv_guess_dct_mode(DVVideoContext *s, uint8_t *data,
202 if (s->avctx->flags & AV_CODEC_FLAG_INTERLACED_DCT) {
203 int ps = s->ildct_cmp(NULL, data, NULL, linesize, 8) - 400;
205 int is = s->ildct_cmp(NULL, data, NULL, linesize << 1, 4) +
206 s->ildct_cmp(NULL, data + linesize, NULL, linesize << 1, 4);
214 static const int dv_weight_bits = 18;
215 static const int dv_weight_88[64] = {
216 131072, 257107, 257107, 242189, 252167, 242189, 235923, 237536,
217 237536, 235923, 229376, 231390, 223754, 231390, 229376, 222935,
218 224969, 217965, 217965, 224969, 222935, 200636, 218652, 211916,
219 212325, 211916, 218652, 200636, 188995, 196781, 205965, 206433,
220 206433, 205965, 196781, 188995, 185364, 185364, 200636, 200704,
221 200636, 185364, 185364, 174609, 180568, 195068, 195068, 180568,
222 174609, 170091, 175557, 189591, 175557, 170091, 165371, 170627,
223 170627, 165371, 160727, 153560, 160727, 144651, 144651, 136258,
225 static const int dv_weight_248[64] = {
226 131072, 242189, 257107, 237536, 229376, 200636, 242189, 223754,
227 224969, 196781, 262144, 242189, 229376, 200636, 257107, 237536,
228 211916, 185364, 235923, 217965, 229376, 211916, 206433, 180568,
229 242189, 223754, 224969, 196781, 211916, 185364, 235923, 217965,
230 200704, 175557, 222935, 205965, 200636, 185364, 195068, 170627,
231 229376, 211916, 206433, 180568, 200704, 175557, 222935, 205965,
232 175557, 153560, 188995, 174609, 165371, 144651, 200636, 185364,
233 195068, 170627, 175557, 153560, 188995, 174609, 165371, 144651,
236 static av_always_inline int dv_init_enc_block(EncBlockInfo *bi, uint8_t *data,
237 int linesize, DVVideoContext *s,
241 const uint8_t *zigzag_scan;
242 LOCAL_ALIGNED_16(int16_t, blk, [64]);
244 /* We offer two different methods for class number assignment: the
245 * method suggested in SMPTE 314M Table 22, and an improved
246 * method. The SMPTE method is very conservative; it assigns class
247 * 3 (i.e. severe quantization) to any block where the largest AC
248 * component is greater than 36. Libav's DV encoder tracks AC bit
249 * consumption precisely, so there is no need to bias most blocks
250 * towards strongly lossy compression. Instead, we assign class 2
251 * to most blocks, and use class 3 only when strictly necessary
252 * (for blocks whose largest AC component exceeds 255). */
254 #if 0 /* SMPTE spec method */
255 static const int classes[] = { 12, 24, 36, 0xffff };
256 #else /* improved Libav method */
257 static const int classes[] = { -1, -1, 255, 0xffff };
259 int max = classes[0];
262 assert((((int) blk) & 15) == 0);
268 bi->partial_bit_count = 0;
269 bi->partial_bit_buffer = 0;
272 bi->dct_mode = dv_guess_dct_mode(s, data, linesize);
273 s->get_pixels(blk, data, linesize);
274 s->fdct[bi->dct_mode](blk);
276 /* We rely on the fact that encoding all zeros leads to an immediate
277 * EOB, which is precisely what the spec calls for in the "dummy"
279 memset(blk, 0, 64 * sizeof(*blk));
284 zigzag_scan = bi->dct_mode ? ff_dv_zigzag248_direct : ff_zigzag_direct;
285 weight = bi->dct_mode ? dv_weight_248 : dv_weight_88;
287 for (area = 0; area < 4; area++) {
288 bi->prev[area] = prev;
289 bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
290 for (i = mb_area_start[area]; i < mb_area_start[area + 1]; i++) {
291 int level = blk[zigzag_scan[i]];
293 if (level + 15 > 30U) {
294 bi->sign[i] = (level >> 31) & 1;
295 /* Weight it and and shift down into range, adding for rounding.
296 * The extra division by a factor of 2^4 reverses the 8x
297 * expansion of the DCT AND the 2x doubling of the weights. */
298 level = (FFABS(level) * weight[i] + (1 << (dv_weight_bits + 3))) >>
299 (dv_weight_bits + 4);
303 bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, level);
310 for (bi->cno = 0; max > classes[bi->cno]; bi->cno++)
319 for (area = 0; area < 4; area++) {
320 bi->prev[area] = prev;
321 bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
322 for (; i < mb_area_start[area + 1]; i = bi->next[i]) {
326 bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, bi->mb[i]);
335 return bi->bit_size[0] + bi->bit_size[1] +
336 bi->bit_size[2] + bi->bit_size[3];
339 static inline void dv_guess_qnos(EncBlockInfo *blks, int *qnos)
342 int i, j, k, a, prev, a2;
352 for (i = 0; i < 5; i++) {
358 for (j = 0; j < 6; j++, b++) {
359 for (a = 0; a < 4; a++) {
360 if (b->area_q[a] != ff_dv_quant_shifts[qnos[i] + ff_dv_quant_offset[b->cno]][a]) {
361 b->bit_size[a] = 1; // 4 areas 4 bits for EOB :)
364 assert(b->next[prev] >= mb_area_start[a + 1] || b->mb[prev]);
365 for (k = b->next[prev]; k < mb_area_start[a + 1]; k = b->next[k]) {
368 b->bit_size[a] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
371 if (b->next[k] >= mb_area_start[a + 1] && b->next[k] < 64) {
372 for (a2 = a + 1; b->next[k] >= mb_area_start[a2 + 1]; a2++)
375 assert(b->mb[b->next[k]]);
376 b->bit_size[a2] += dv_rl2vlc_size(b->next[k] - prev - 1, b->mb[b->next[k]]) -
377 dv_rl2vlc_size(b->next[k] - k - 1, b->mb[b->next[k]]);
378 assert(b->prev[a2] == k && (a2 + 1 >= 4 || b->prev[a2 + 1] != k));
381 b->next[prev] = b->next[k];
384 b->prev[a + 1] = prev;
386 size[i] += b->bit_size[a];
389 if (vs_total_ac_bits >= size[0] + size[1] + size[2] + size[3] + size[4])
392 } while (qnos[0] | qnos[1] | qnos[2] | qnos[3] | qnos[4]);
394 for (a = 2; a == 2 || vs_total_ac_bits < size[0]; a += a) {
396 size[0] = 5 * 6 * 4; // EOB
397 for (j = 0; j < 6 * 5; j++, b++) {
399 for (k = b->next[prev]; k < 64; k = b->next[k]) {
400 if (b->mb[k] < a && b->mb[k] > -a) {
401 b->next[prev] = b->next[k];
403 size[0] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
411 static int dv_encode_video_segment(AVCodecContext *avctx, void *arg)
413 DVVideoContext *s = avctx->priv_data;
414 DVwork_chunk *work_chunk = arg;
416 int mb_x, mb_y, c_offset, linesize, y_stride;
419 LOCAL_ALIGNED_8(uint8_t, scratch, [128]);
420 EncBlockInfo enc_blks[5 * DV_MAX_BPM];
421 PutBitContext pbs[5 * DV_MAX_BPM];
423 EncBlockInfo *enc_blk;
425 int qnos[5] = { 15, 15, 15, 15, 15 }; /* No quantization */
426 int *qnosp = &qnos[0];
428 dif = &s->buf[work_chunk->buf_offset * 80];
429 enc_blk = &enc_blks[0];
430 for (mb_index = 0; mb_index < 5; mb_index++) {
431 dv_calculate_mb_xy(s, work_chunk, mb_index, &mb_x, &mb_y);
433 /* initializing luminance blocks */
434 if ((s->sys->pix_fmt == AV_PIX_FMT_YUV420P) ||
435 (s->sys->pix_fmt == AV_PIX_FMT_YUV411P && mb_x >= (704 / 8)) ||
436 (s->sys->height >= 720 && mb_y != 134)) {
437 y_stride = s->frame->linesize[0] << 3;
441 y_ptr = s->frame->data[0] +
442 ((mb_y * s->frame->linesize[0] + mb_x) << 3);
443 linesize = s->frame->linesize[0];
445 if (s->sys->video_stype == 4) { /* SD 422 */
447 dv_init_enc_block(enc_blk + 0, y_ptr, linesize, s, 0) +
448 dv_init_enc_block(enc_blk + 1, NULL, linesize, s, 0) +
449 dv_init_enc_block(enc_blk + 2, y_ptr + 8, linesize, s, 0) +
450 dv_init_enc_block(enc_blk + 3, NULL, linesize, s, 0);
453 dv_init_enc_block(enc_blk + 0, y_ptr, linesize, s, 0) +
454 dv_init_enc_block(enc_blk + 1, y_ptr + 8, linesize, s, 0) +
455 dv_init_enc_block(enc_blk + 2, y_ptr + y_stride, linesize, s, 0) +
456 dv_init_enc_block(enc_blk + 3, y_ptr + 8 + y_stride, linesize, s, 0);
460 /* initializing chrominance blocks */
461 c_offset = (((mb_y >> (s->sys->pix_fmt == AV_PIX_FMT_YUV420P)) * s->frame->linesize[1] +
462 (mb_x >> ((s->sys->pix_fmt == AV_PIX_FMT_YUV411P) ? 2 : 1))) << 3);
463 for (j = 2; j; j--) {
464 uint8_t *c_ptr = s->frame->data[j] + c_offset;
465 linesize = s->frame->linesize[j];
466 y_stride = (mb_y == 134) ? 8 : (s->frame->linesize[j] << 3);
467 if (s->sys->pix_fmt == AV_PIX_FMT_YUV411P && mb_x >= (704 / 8)) {
469 uint8_t *b = scratch;
470 for (i = 0; i < 8; i++) {
471 d = c_ptr + (linesize << 3);
487 vs_bit_size += dv_init_enc_block(enc_blk++, c_ptr, linesize, s, 1);
488 if (s->sys->bpm == 8)
489 vs_bit_size += dv_init_enc_block(enc_blk++, c_ptr + y_stride,
494 if (vs_total_ac_bits < vs_bit_size)
495 dv_guess_qnos(&enc_blks[0], qnosp);
497 /* DIF encoding process */
498 for (j = 0; j < 5 * s->sys->bpm;) {
504 /* First pass over individual cells only */
505 for (i = 0; i < s->sys->bpm; i++, j++) {
506 int sz = s->sys->block_sizes[i] >> 3;
508 init_put_bits(&pbs[j], dif, sz);
509 put_sbits(&pbs[j], 9, ((enc_blks[j].mb[0] >> 3) - 1024 + 2) >> 2);
510 put_bits(&pbs[j], 1, enc_blks[j].dct_mode);
511 put_bits(&pbs[j], 2, enc_blks[j].cno);
513 dv_encode_ac(&enc_blks[j], &pbs[j], &pbs[j + 1]);
517 /* Second pass over each MB space */
519 for (i = 0; i < s->sys->bpm; i++)
520 if (enc_blks[start_mb + i].partial_bit_count)
521 pb = dv_encode_ac(&enc_blks[start_mb + i], pb,
522 &pbs[start_mb + s->sys->bpm]);
525 /* Third and final pass over the whole video segment space */
527 for (j = 0; j < 5 * s->sys->bpm; j++) {
528 if (enc_blks[j].partial_bit_count)
529 pb = dv_encode_ac(&enc_blks[j], pb, &pbs[s->sys->bpm * 5]);
530 if (enc_blks[j].partial_bit_count)
531 av_log(avctx, AV_LOG_ERROR, "ac bitstream overflow\n");
534 for (j = 0; j < 5 * s->sys->bpm; j++) {
536 int size = pbs[j].size_in_bits >> 3;
537 flush_put_bits(&pbs[j]);
538 pos = put_bits_count(&pbs[j]) >> 3;
540 av_log(avctx, AV_LOG_ERROR,
541 "bitstream written beyond buffer size\n");
544 memset(pbs[j].buf + pos, 0xff, size - pos);
550 static inline int dv_write_pack(enum dv_pack_type pack_id, DVVideoContext *c,
554 * Here's what SMPTE314M says about these two:
555 * (page 6) APTn, AP1n, AP2n, AP3n: These data shall be identical
556 * as track application IDs (APTn = 001, AP1n =
557 * 001, AP2n = 001, AP3n = 001), if the source signal
558 * comes from a digital VCR. If the signal source is
559 * unknown, all bits for these data shall be set to 1.
560 * (page 12) STYPE: STYPE defines a signal type of video signal
561 * 00000b = 4:1:1 compression
562 * 00100b = 4:2:2 compression
564 * Now, I've got two problems with these statements:
565 * 1. it looks like APT == 111b should be a safe bet, but it isn't.
566 * It seems that for PAL as defined in IEC 61834 we have to set
567 * APT to 000 and for SMPTE314M to 001.
568 * 2. It is not at all clear what STYPE is used for 4:2:0 PAL
569 * compression scheme (if any).
571 int apt = (c->sys->pix_fmt == AV_PIX_FMT_YUV420P ? 0 : 1);
574 if ((int) (av_q2d(c->avctx->sample_aspect_ratio) *
575 c->avctx->width / c->avctx->height * 10) >= 17) /* 16:9 */
578 buf[0] = (uint8_t) pack_id;
580 case dv_header525: /* I can't imagine why these two weren't defined as real */
581 case dv_header625: /* packs in SMPTE314M -- they definitely look like ones */
582 buf[1] = 0xf8 | /* reserved -- always 1 */
583 (apt & 0x07); /* APT: Track application ID */
584 buf[2] = (0 << 7) | /* TF1: audio data is 0 - valid; 1 - invalid */
585 (0x0f << 3) | /* reserved -- always 1 */
586 (apt & 0x07); /* AP1: Audio application ID */
587 buf[3] = (0 << 7) | /* TF2: video data is 0 - valid; 1 - invalid */
588 (0x0f << 3) | /* reserved -- always 1 */
589 (apt & 0x07); /* AP2: Video application ID */
590 buf[4] = (0 << 7) | /* TF3: subcode(SSYB) is 0 - valid; 1 - invalid */
591 (0x0f << 3) | /* reserved -- always 1 */
592 (apt & 0x07); /* AP3: Subcode application ID */
594 case dv_video_source:
595 buf[1] = 0xff; /* reserved -- always 1 */
596 buf[2] = (1 << 7) | /* B/W: 0 - b/w, 1 - color */
597 (1 << 6) | /* following CLF is valid - 0, invalid - 1 */
598 (3 << 4) | /* CLF: color frames ID (see ITU-R BT.470-4) */
599 0xf; /* reserved -- always 1 */
600 buf[3] = (3 << 6) | /* reserved -- always 1 */
601 (c->sys->dsf << 5) | /* system: 60fields/50fields */
602 c->sys->video_stype; /* signal type video compression */
603 buf[4] = 0xff; /* VISC: 0xff -- no information */
605 case dv_video_control:
606 buf[1] = (0 << 6) | /* Copy generation management (CGMS) 0 -- free */
607 0x3f; /* reserved -- always 1 */
608 buf[2] = 0xc8 | /* reserved -- always b11001xxx */
610 buf[3] = (1 << 7) | /* frame/field flag 1 -- frame, 0 -- field */
611 (1 << 6) | /* first/second field flag 0 -- field 2, 1 -- field 1 */
612 (1 << 5) | /* frame change flag 0 -- same picture as before, 1 -- different */
613 (1 << 4) | /* 1 - interlaced, 0 - noninterlaced */
614 0xc; /* reserved -- always b1100 */
615 buf[4] = 0xff; /* reserved -- always 1 */
626 static inline int dv_write_dif_id(enum dv_section_type t, uint8_t chan_num,
627 uint8_t seq_num, uint8_t dif_num,
630 buf[0] = (uint8_t) t; /* Section type */
631 buf[1] = (seq_num << 4) | /* DIF seq number 0-9 for 525/60; 0-11 for 625/50 */
632 (chan_num << 3) | /* FSC: for 50Mb/s 0 - first channel; 1 - second */
633 7; /* reserved -- always 1 */
634 buf[2] = dif_num; /* DIF block number Video: 0-134, Audio: 0-8 */
638 static inline int dv_write_ssyb_id(uint8_t syb_num, uint8_t fr, uint8_t *buf)
640 if (syb_num == 0 || syb_num == 6) {
641 buf[0] = (fr << 7) | /* FR ID 1 - first half of each channel; 0 - second */
642 (0 << 4) | /* AP3 (Subcode application ID) */
643 0x0f; /* reserved -- always 1 */
644 } else if (syb_num == 11) {
645 buf[0] = (fr << 7) | /* FR ID 1 - first half of each channel; 0 - second */
646 0x7f; /* reserved -- always 1 */
648 buf[0] = (fr << 7) | /* FR ID 1 - first half of each channel; 0 - second */
649 (0 << 4) | /* APT (Track application ID) */
650 0x0f; /* reserved -- always 1 */
652 buf[1] = 0xf0 | /* reserved -- always 1 */
653 (syb_num & 0x0f); /* SSYB number 0 - 11 */
654 buf[2] = 0xff; /* reserved -- always 1 */
658 static void dv_format_frame(DVVideoContext *c, uint8_t *buf)
662 for (chan = 0; chan < c->sys->n_difchan; chan++) {
663 for (i = 0; i < c->sys->difseg_size; i++) {
664 memset(buf, 0xff, 80 * 6); /* first 6 DIF blocks are for control data */
666 /* DV header: 1DIF */
667 buf += dv_write_dif_id(dv_sect_header, chan, i, 0, buf);
668 buf += dv_write_pack((c->sys->dsf ? dv_header625 : dv_header525),
670 buf += 72; /* unused bytes */
672 /* DV subcode: 2DIFs */
673 for (j = 0; j < 2; j++) {
674 buf += dv_write_dif_id(dv_sect_subcode, chan, i, j, buf);
675 for (k = 0; k < 6; k++)
676 buf += dv_write_ssyb_id(k, (i < c->sys->difseg_size / 2), buf) + 5;
677 buf += 29; /* unused bytes */
681 for (j = 0; j < 3; j++) {
682 buf += dv_write_dif_id(dv_sect_vaux, chan, i, j, buf);
683 buf += dv_write_pack(dv_video_source, c, buf);
684 buf += dv_write_pack(dv_video_control, c, buf);
686 buf += dv_write_pack(dv_video_source, c, buf);
687 buf += dv_write_pack(dv_video_control, c, buf);
688 buf += 4 * 5 + 2; /* unused bytes */
691 /* DV Audio/Video: 135 Video DIFs + 9 Audio DIFs */
692 for (j = 0; j < 135; j++) {
694 memset(buf, 0xff, 80);
695 buf += dv_write_dif_id(dv_sect_audio, chan, i, j / 15, buf);
696 buf += 77; /* audio control & shuffled PCM audio */
698 buf += dv_write_dif_id(dv_sect_video, chan, i, j, buf);
699 buf += 77; /* 1 video macroblock: 1 bytes control
700 * 4 * 14 bytes Y 8x8 data
701 * 10 bytes Cr 8x8 data
702 * 10 bytes Cb 8x8 data */
708 static int dvvideo_encode_frame(AVCodecContext *c, AVPacket *pkt,
709 const AVFrame *frame, int *got_packet)
711 DVVideoContext *s = c->priv_data;
714 if ((ret = ff_alloc_packet(pkt, s->sys->frame_size)) < 0) {
715 av_log(c, AV_LOG_ERROR, "Error getting output packet.\n");
719 c->pix_fmt = s->sys->pix_fmt;
721 #if FF_API_CODED_FRAME
722 FF_DISABLE_DEPRECATION_WARNINGS
723 c->coded_frame->key_frame = 1;
724 c->coded_frame->pict_type = AV_PICTURE_TYPE_I;
725 FF_ENABLE_DEPRECATION_WARNINGS
729 c->execute(c, dv_encode_video_segment, s->work_chunks, NULL,
730 dv_work_pool_size(s->sys), sizeof(DVwork_chunk));
734 dv_format_frame(s, pkt->data);
736 pkt->flags |= AV_PKT_FLAG_KEY;
742 AVCodec ff_dvvideo_encoder = {
744 .long_name = NULL_IF_CONFIG_SMALL("DV (Digital Video)"),
745 .type = AVMEDIA_TYPE_VIDEO,
746 .id = AV_CODEC_ID_DVVIDEO,
747 .priv_data_size = sizeof(DVVideoContext),
748 .init = dvvideo_encode_init,
749 .encode2 = dvvideo_encode_frame,
750 .capabilities = AV_CODEC_CAP_SLICE_THREADS,
751 .pix_fmts = (const enum AVPixelFormat[]) {
752 AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV422P,
753 AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE