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
27 #include "libavutil/attributes.h"
28 #include "libavutil/pixdesc.h"
34 #include "pixblockdsp.h"
37 #include "dv_tablegen.h"
38 #include "dv_profile_internal.h"
40 static av_cold int dvvideo_encode_init(AVCodecContext *avctx)
42 DVVideoContext *s = avctx->priv_data;
45 PixblockDSPContext pdsp;
48 s->sys = av_dv_codec_profile(avctx->width, avctx->height, avctx->pix_fmt);
50 av_log(avctx, AV_LOG_ERROR, "Found no DV profile for %ix%i %s video. "
51 "Valid DV profiles are:\n",
52 avctx->width, avctx->height, av_get_pix_fmt_name(avctx->pix_fmt));
53 ff_dv_print_profiles(avctx, AV_LOG_ERROR);
54 return AVERROR(EINVAL);
56 if (avctx->height > 576) {
57 av_log(avctx, AV_LOG_ERROR, "DVCPRO HD encoding is not supported.\n");
58 return AVERROR_PATCHWELCOME;
60 ret = ff_dv_init_dynamic_tables(s, s->sys);
62 av_log(avctx, AV_LOG_ERROR, "Error initializing work tables.\n");
66 avctx->coded_frame = av_frame_alloc();
67 if (!avctx->coded_frame)
68 return AVERROR(ENOMEM);
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 /* Converts 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, uint32_t* vlc)
98 if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {
99 *vlc = dv_vlc_map[run][level].vlc | sign;
100 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;
128 size = (level < DV_VLC_MAP_LEV_SIZE) ? dv_vlc_map[0][level].size : 16;
130 size += (run < 16) ? dv_vlc_map[run-1][0].size : 13;
136 static av_always_inline int dv_rl2vlc(int run, int l, int sign, uint32_t* vlc)
138 *vlc = dv_vlc_map[run][l].vlc | sign;
139 return dv_vlc_map[run][l].size;
142 static av_always_inline int dv_rl2vlc_size(int run, int l)
144 return dv_vlc_map[run][l].size;
148 typedef struct EncBlockInfo {
158 uint8_t partial_bit_count;
159 uint32_t partial_bit_buffer; /* we can't use uint16_t here */
162 static av_always_inline PutBitContext* dv_encode_ac(EncBlockInfo* bi,
163 PutBitContext* pb_pool,
164 PutBitContext* pb_end)
167 PutBitContext* pb = pb_pool;
168 int size = bi->partial_bit_count;
169 uint32_t vlc = bi->partial_bit_buffer;
171 bi->partial_bit_count = bi->partial_bit_buffer = 0;
173 /* Find suitable storage space */
174 for (; size > (bits_left = put_bits_left(pb)); pb++) {
177 put_bits(pb, bits_left, vlc >> size);
178 vlc = vlc & ((1 << size) - 1);
180 if (pb + 1 >= pb_end) {
181 bi->partial_bit_count = size;
182 bi->partial_bit_buffer = vlc;
188 put_bits(pb, size, vlc);
190 if (bi->cur_ac >= 64)
193 /* Construct the next VLC */
195 bi->cur_ac = bi->next[prev];
196 if (bi->cur_ac < 64){
197 size = dv_rl2vlc(bi->cur_ac - prev - 1, bi->mb[bi->cur_ac], bi->sign[bi->cur_ac], &vlc);
199 size = 4; vlc = 6; /* End Of Block stamp */
205 static av_always_inline int dv_guess_dct_mode(DVVideoContext *s, uint8_t *data, int linesize) {
206 if (s->avctx->flags & CODEC_FLAG_INTERLACED_DCT) {
207 int ps = s->ildct_cmp(NULL, data, NULL, linesize, 8) - 400;
209 int is = s->ildct_cmp(NULL, data , NULL, linesize<<1, 4) +
210 s->ildct_cmp(NULL, data + linesize, NULL, linesize<<1, 4);
218 static const int dv_weight_bits = 18;
219 static const int dv_weight_88[64] = {
220 131072, 257107, 257107, 242189, 252167, 242189, 235923, 237536,
221 237536, 235923, 229376, 231390, 223754, 231390, 229376, 222935,
222 224969, 217965, 217965, 224969, 222935, 200636, 218652, 211916,
223 212325, 211916, 218652, 200636, 188995, 196781, 205965, 206433,
224 206433, 205965, 196781, 188995, 185364, 185364, 200636, 200704,
225 200636, 185364, 185364, 174609, 180568, 195068, 195068, 180568,
226 174609, 170091, 175557, 189591, 175557, 170091, 165371, 170627,
227 170627, 165371, 160727, 153560, 160727, 144651, 144651, 136258,
229 static const int dv_weight_248[64] = {
230 131072, 242189, 257107, 237536, 229376, 200636, 242189, 223754,
231 224969, 196781, 262144, 242189, 229376, 200636, 257107, 237536,
232 211916, 185364, 235923, 217965, 229376, 211916, 206433, 180568,
233 242189, 223754, 224969, 196781, 211916, 185364, 235923, 217965,
234 200704, 175557, 222935, 205965, 200636, 185364, 195068, 170627,
235 229376, 211916, 206433, 180568, 200704, 175557, 222935, 205965,
236 175557, 153560, 188995, 174609, 165371, 144651, 200636, 185364,
237 195068, 170627, 175557, 153560, 188995, 174609, 165371, 144651,
240 static av_always_inline int dv_init_enc_block(EncBlockInfo* bi, uint8_t *data, int linesize, DVVideoContext *s, int bias)
243 const uint8_t* zigzag_scan;
244 LOCAL_ALIGNED_16(int16_t, blk, [64]);
246 /* We offer two different methods for class number assignment: the
247 method suggested in SMPTE 314M Table 22, and an improved
248 method. The SMPTE method is very conservative; it assigns class
249 3 (i.e. severe quantization) to any block where the largest AC
250 component is greater than 36. FFmpeg's DV encoder tracks AC bit
251 consumption precisely, so there is no need to bias most blocks
252 towards strongly lossy compression. Instead, we assign class 2
253 to most blocks, and use class 3 only when strictly necessary
254 (for blocks whose largest AC component exceeds 255). */
256 #if 0 /* SMPTE spec method */
257 static const int classes[] = {12, 24, 36, 0xffff};
258 #else /* improved FFmpeg method */
259 static const int classes[] = {-1, -1, 255, 0xffff};
261 int max = classes[0];
264 av_assert2((((int)blk) & 15) == 0);
266 bi->area_q[0] = bi->area_q[1] = bi->area_q[2] = bi->area_q[3] = 0;
267 bi->partial_bit_count = 0;
268 bi->partial_bit_buffer = 0;
271 bi->dct_mode = dv_guess_dct_mode(s, data, linesize);
272 s->get_pixels(blk, data, linesize);
273 s->fdct[bi->dct_mode](blk);
275 /* We rely on the fact that encoding all zeros leads to an immediate EOB,
276 which is precisely what the spec calls for in the "dummy" blocks. */
277 memset(blk, 0, 64*sizeof(*blk));
282 zigzag_scan = bi->dct_mode ? ff_dv_zigzag248_direct : ff_zigzag_direct;
283 weight = bi->dct_mode ? dv_weight_248 : dv_weight_88;
285 for (area = 0; area < 4; area++) {
286 bi->prev[area] = prev;
287 bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
288 for (i = mb_area_start[area]; i < mb_area_start[area+1]; i++) {
289 int level = blk[zigzag_scan[i]];
291 if (level + 15 > 30U) {
292 bi->sign[i] = (level >> 31) & 1;
293 /* weight it and shift down into range, adding for rounding */
294 /* the extra division by a factor of 2^4 reverses the 8x expansion of the DCT
295 AND the 2x doubling of the weights */
296 level = (FFABS(level) * weight[i] + (1 << (dv_weight_bits+3))) >> (dv_weight_bits+4);
300 bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, level);
307 for (bi->cno = 0; max > classes[bi->cno]; bi->cno++);
315 for (area = 0; area < 4; area++) {
316 bi->prev[area] = prev;
317 bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
318 for (; i < mb_area_start[area+1]; i = bi->next[i]) {
322 bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, bi->mb[i]);
331 return bi->bit_size[0] + bi->bit_size[1] + bi->bit_size[2] + bi->bit_size[3];
334 static inline void dv_guess_qnos(EncBlockInfo* blks, int* qnos)
337 int i, j, k, a, prev, a2;
340 size[0] = size[1] = size[2] = size[3] = size[4] = 1 << 24;
343 for (i = 0; i < 5; i++) {
349 for (j = 0; j < 6; j++, b++) {
350 for (a = 0; a < 4; a++) {
351 if (b->area_q[a] != ff_dv_quant_shifts[qnos[i] + ff_dv_quant_offset[b->cno]][a]) {
352 b->bit_size[a] = 1; // 4 areas 4 bits for EOB :)
355 av_assert2(b->next[prev] >= mb_area_start[a+1] || b->mb[prev]);
356 for (k = b->next[prev] ; k < mb_area_start[a+1]; k = b->next[k]) {
359 b->bit_size[a] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
362 if (b->next[k] >= mb_area_start[a+1] && b->next[k]<64){
363 for (a2 = a + 1; b->next[k] >= mb_area_start[a2+1]; a2++)
366 av_assert2(b->mb[b->next[k]]);
367 b->bit_size[a2] += dv_rl2vlc_size(b->next[k] - prev - 1, b->mb[b->next[k]])
368 -dv_rl2vlc_size(b->next[k] - k - 1, b->mb[b->next[k]]);
369 av_assert2(b->prev[a2] == k && (a2 + 1 >= 4 || b->prev[a2+1] != k));
372 b->next[prev] = b->next[k];
377 size[i] += b->bit_size[a];
380 if (vs_total_ac_bits >= size[0] + size[1] + size[2] + size[3] + size[4])
383 } while (qnos[0]|qnos[1]|qnos[2]|qnos[3]|qnos[4]);
386 for (a = 2; a == 2 || vs_total_ac_bits < size[0]; a += a){
388 size[0] = 5 * 6 * 4; //EOB
389 for (j = 0; j < 6 *5; j++, b++) {
391 for (k = b->next[prev]; k < 64; k = b->next[k]) {
392 if (b->mb[k] < a && b->mb[k] > -a){
393 b->next[prev] = b->next[k];
395 size[0] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
403 static int dv_encode_video_segment(AVCodecContext *avctx, void *arg)
405 DVVideoContext *s = avctx->priv_data;
406 DVwork_chunk *work_chunk = arg;
408 int mb_x, mb_y, c_offset, linesize, y_stride;
411 LOCAL_ALIGNED_8(uint8_t, scratch, [128]);
412 EncBlockInfo enc_blks[5*DV_MAX_BPM];
413 PutBitContext pbs[5*DV_MAX_BPM];
415 EncBlockInfo* enc_blk;
417 int qnos[5] = {15, 15, 15, 15, 15}; /* No quantization */
418 int* qnosp = &qnos[0];
420 dif = &s->buf[work_chunk->buf_offset*80];
421 enc_blk = &enc_blks[0];
422 for (mb_index = 0; mb_index < 5; mb_index++) {
423 dv_calculate_mb_xy(s, work_chunk, mb_index, &mb_x, &mb_y);
425 /* initializing luminance blocks */
426 if ((s->sys->pix_fmt == AV_PIX_FMT_YUV420P) ||
427 (s->sys->pix_fmt == AV_PIX_FMT_YUV411P && mb_x >= (704 / 8)) ||
428 (s->sys->height >= 720 && mb_y != 134)) {
429 y_stride = s->frame->linesize[0] << 3;
433 y_ptr = s->frame->data[0] + ((mb_y * s->frame->linesize[0] + mb_x) << 3);
434 linesize = s->frame->linesize[0];
436 if (s->sys->video_stype == 4) { /* SD 422 */
438 dv_init_enc_block(enc_blk+0, y_ptr , linesize, s, 0) +
439 dv_init_enc_block(enc_blk+1, NULL , linesize, s, 0) +
440 dv_init_enc_block(enc_blk+2, y_ptr + 8 , linesize, s, 0) +
441 dv_init_enc_block(enc_blk+3, NULL , linesize, s, 0);
444 dv_init_enc_block(enc_blk+0, y_ptr , linesize, s, 0) +
445 dv_init_enc_block(enc_blk+1, y_ptr + 8 , linesize, s, 0) +
446 dv_init_enc_block(enc_blk+2, y_ptr + y_stride, linesize, s, 0) +
447 dv_init_enc_block(enc_blk+3, y_ptr + 8 + y_stride, linesize, s, 0);
451 /* initializing chrominance blocks */
452 c_offset = (((mb_y >> (s->sys->pix_fmt == AV_PIX_FMT_YUV420P)) * s->frame->linesize[1] +
453 (mb_x >> ((s->sys->pix_fmt == AV_PIX_FMT_YUV411P) ? 2 : 1))) << 3);
454 for (j = 2; j; j--) {
455 uint8_t *c_ptr = s->frame->data[j] + c_offset;
456 linesize = s->frame->linesize[j];
457 y_stride = (mb_y == 134) ? 8 : (s->frame->linesize[j] << 3);
458 if (s->sys->pix_fmt == AV_PIX_FMT_YUV411P && mb_x >= (704 / 8)) {
460 uint8_t* b = scratch;
461 for (i = 0; i < 8; i++) {
462 d = c_ptr + (linesize << 3);
463 b[0] = c_ptr[0]; b[1] = c_ptr[1]; b[2] = c_ptr[2]; b[3] = c_ptr[3];
464 b[4] = d[0]; b[5] = d[1]; b[6] = d[2]; b[7] = d[3];
472 vs_bit_size += dv_init_enc_block( enc_blk++, c_ptr , linesize, s, 1);
473 if (s->sys->bpm == 8) {
474 vs_bit_size += dv_init_enc_block(enc_blk++, c_ptr + y_stride, linesize, s, 1);
479 if (vs_total_ac_bits < vs_bit_size)
480 dv_guess_qnos(&enc_blks[0], qnosp);
482 /* DIF encoding process */
483 for (j=0; j<5*s->sys->bpm;) {
489 /* First pass over individual cells only */
490 for (i=0; i<s->sys->bpm; i++, j++) {
491 int sz = s->sys->block_sizes[i]>>3;
493 init_put_bits(&pbs[j], dif, sz);
494 put_sbits(&pbs[j], 9, ((enc_blks[j].mb[0] >> 3) - 1024 + 2) >> 2);
495 put_bits(&pbs[j], 1, enc_blks[j].dct_mode);
496 put_bits(&pbs[j], 2, enc_blks[j].cno);
498 dv_encode_ac(&enc_blks[j], &pbs[j], &pbs[j+1]);
502 /* Second pass over each MB space */
504 for (i=0; i<s->sys->bpm; i++) {
505 if (enc_blks[start_mb+i].partial_bit_count)
506 pb = dv_encode_ac(&enc_blks[start_mb+i], pb, &pbs[start_mb+s->sys->bpm]);
510 /* Third and final pass over the whole video segment space */
512 for (j=0; j<5*s->sys->bpm; j++) {
513 if (enc_blks[j].partial_bit_count)
514 pb = dv_encode_ac(&enc_blks[j], pb, &pbs[s->sys->bpm*5]);
515 if (enc_blks[j].partial_bit_count)
516 av_log(avctx, AV_LOG_ERROR, "ac bitstream overflow\n");
519 for (j=0; j<5*s->sys->bpm; j++) {
521 int size = pbs[j].size_in_bits >> 3;
522 flush_put_bits(&pbs[j]);
523 pos = put_bits_count(&pbs[j]) >> 3;
525 av_log(avctx, AV_LOG_ERROR, "bitstream written beyond buffer size\n");
528 memset(pbs[j].buf + pos, 0xff, size - pos);
534 static inline int dv_write_pack(enum dv_pack_type pack_id, DVVideoContext *c,
538 * Here's what SMPTE314M says about these two:
539 * (page 6) APTn, AP1n, AP2n, AP3n: These data shall be identical
540 * as track application IDs (APTn = 001, AP1n =
541 * 001, AP2n = 001, AP3n = 001), if the source signal
542 * comes from a digital VCR. If the signal source is
543 * unknown, all bits for these data shall be set to 1.
544 * (page 12) STYPE: STYPE defines a signal type of video signal
545 * 00000b = 4:1:1 compression
546 * 00100b = 4:2:2 compression
548 * Now, I've got two problems with these statements:
549 * 1. it looks like APT == 111b should be a safe bet, but it isn't.
550 * It seems that for PAL as defined in IEC 61834 we have to set
551 * APT to 000 and for SMPTE314M to 001.
552 * 2. It is not at all clear what STYPE is used for 4:2:0 PAL
553 * compression scheme (if any).
555 int apt = (c->sys->pix_fmt == AV_PIX_FMT_YUV420P ? 0 : 1);
556 int fs = c->frame->top_field_first ? 0x00 : 0x40;
559 if ((int)(av_q2d(c->avctx->sample_aspect_ratio) * c->avctx->width / c->avctx->height * 10) >= 17) /* 16:9 */
562 buf[0] = (uint8_t)pack_id;
564 case dv_header525: /* I can't imagine why these two weren't defined as real */
565 case dv_header625: /* packs in SMPTE314M -- they definitely look like ones */
566 buf[1] = 0xf8 | /* reserved -- always 1 */
567 (apt & 0x07); /* APT: Track application ID */
568 buf[2] = (0 << 7) | /* TF1: audio data is 0 - valid; 1 - invalid */
569 (0x0f << 3) | /* reserved -- always 1 */
570 (apt & 0x07); /* AP1: Audio application ID */
571 buf[3] = (0 << 7) | /* TF2: video data is 0 - valid; 1 - invalid */
572 (0x0f << 3) | /* reserved -- always 1 */
573 (apt & 0x07); /* AP2: Video application ID */
574 buf[4] = (0 << 7) | /* TF3: subcode(SSYB) is 0 - valid; 1 - invalid */
575 (0x0f << 3) | /* reserved -- always 1 */
576 (apt & 0x07); /* AP3: Subcode application ID */
578 case dv_video_source:
579 buf[1] = 0xff; /* reserved -- always 1 */
580 buf[2] = (1 << 7) | /* B/W: 0 - b/w, 1 - color */
581 (1 << 6) | /* following CLF is valid - 0, invalid - 1 */
582 (3 << 4) | /* CLF: color frames ID (see ITU-R BT.470-4) */
583 0xf; /* reserved -- always 1 */
584 buf[3] = (3 << 6) | /* reserved -- always 1 */
585 (c->sys->dsf << 5) | /* system: 60fields/50fields */
586 c->sys->video_stype; /* signal type video compression */
587 buf[4] = 0xff; /* VISC: 0xff -- no information */
589 case dv_video_control:
590 buf[1] = (0 << 6) | /* Copy generation management (CGMS) 0 -- free */
591 0x3f; /* reserved -- always 1 */
592 buf[2] = 0xc8 | /* reserved -- always b11001xxx */
594 buf[3] = (1 << 7) | /* frame/field flag 1 -- frame, 0 -- field */
595 fs | /* first/second field flag 0 -- field 2, 1 -- field 1 */
596 (1 << 5) | /* frame change flag 0 -- same picture as before, 1 -- different */
597 (1 << 4) | /* 1 - interlaced, 0 - noninterlaced */
598 0xc; /* reserved -- always b1100 */
599 buf[4] = 0xff; /* reserved -- always 1 */
602 buf[1] = buf[2] = buf[3] = buf[4] = 0xff;
607 static inline int dv_write_dif_id(enum dv_section_type t, uint8_t chan_num,
608 uint8_t seq_num, uint8_t dif_num,
611 buf[0] = (uint8_t)t; /* Section type */
612 buf[1] = (seq_num << 4) | /* DIF seq number 0-9 for 525/60; 0-11 for 625/50 */
613 (chan_num << 3) | /* FSC: for 50Mb/s 0 - first channel; 1 - second */
614 7; /* reserved -- always 1 */
615 buf[2] = dif_num; /* DIF block number Video: 0-134, Audio: 0-8 */
620 static inline int dv_write_ssyb_id(uint8_t syb_num, uint8_t fr, uint8_t* buf)
622 if (syb_num == 0 || syb_num == 6) {
623 buf[0] = (fr << 7) | /* FR ID 1 - first half of each channel; 0 - second */
624 (0 << 4) | /* AP3 (Subcode application ID) */
625 0x0f; /* reserved -- always 1 */
627 else if (syb_num == 11) {
628 buf[0] = (fr << 7) | /* FR ID 1 - first half of each channel; 0 - second */
629 0x7f; /* reserved -- always 1 */
632 buf[0] = (fr << 7) | /* FR ID 1 - first half of each channel; 0 - second */
633 (0 << 4) | /* APT (Track application ID) */
634 0x0f; /* reserved -- always 1 */
636 buf[1] = 0xf0 | /* reserved -- always 1 */
637 (syb_num & 0x0f); /* SSYB number 0 - 11 */
638 buf[2] = 0xff; /* reserved -- always 1 */
642 static void dv_format_frame(DVVideoContext* c, uint8_t* buf)
646 for (chan = 0; chan < c->sys->n_difchan; chan++) {
647 for (i = 0; i < c->sys->difseg_size; i++) {
648 memset(buf, 0xff, 80 * 6); /* first 6 DIF blocks are for control data */
650 /* DV header: 1DIF */
651 buf += dv_write_dif_id(dv_sect_header, chan, i, 0, buf);
652 buf += dv_write_pack((c->sys->dsf ? dv_header625 : dv_header525), c, buf);
653 buf += 72; /* unused bytes */
655 /* DV subcode: 2DIFs */
656 for (j = 0; j < 2; j++) {
657 buf += dv_write_dif_id(dv_sect_subcode, chan, i, j, buf);
658 for (k = 0; k < 6; k++)
659 buf += dv_write_ssyb_id(k, (i < c->sys->difseg_size/2), buf) + 5;
660 buf += 29; /* unused bytes */
664 for (j = 0; j < 3; j++) {
665 buf += dv_write_dif_id(dv_sect_vaux, chan, i, j, buf);
666 buf += dv_write_pack(dv_video_source, c, buf);
667 buf += dv_write_pack(dv_video_control, c, buf);
669 buf += dv_write_pack(dv_video_source, c, buf);
670 buf += dv_write_pack(dv_video_control, c, buf);
671 buf += 4*5 + 2; /* unused bytes */
674 /* DV Audio/Video: 135 Video DIFs + 9 Audio DIFs */
675 for (j = 0; j < 135; j++) {
677 memset(buf, 0xff, 80);
678 buf += dv_write_dif_id(dv_sect_audio, chan, i, j/15, buf);
679 buf += 77; /* audio control & shuffled PCM audio */
681 buf += dv_write_dif_id(dv_sect_video, chan, i, j, buf);
682 buf += 77; /* 1 video macroblock: 1 bytes control
683 4 * 14 bytes Y 8x8 data
685 10 bytes Cb 8x8 data */
692 static int dvvideo_encode_frame(AVCodecContext *c, AVPacket *pkt,
693 const AVFrame *frame, int *got_packet)
695 DVVideoContext *s = c->priv_data;
698 if ((ret = ff_alloc_packet2(c, pkt, s->sys->frame_size)) < 0)
701 c->pix_fmt = s->sys->pix_fmt;
703 c->coded_frame->key_frame = 1;
704 c->coded_frame->pict_type = AV_PICTURE_TYPE_I;
707 c->execute(c, dv_encode_video_segment, s->work_chunks, NULL,
708 dv_work_pool_size(s->sys), sizeof(DVwork_chunk));
712 dv_format_frame(s, pkt->data);
714 pkt->flags |= AV_PKT_FLAG_KEY;
720 static int dvvideo_encode_close(AVCodecContext *avctx)
722 av_frame_free(&avctx->coded_frame);
726 AVCodec ff_dvvideo_encoder = {
728 .long_name = NULL_IF_CONFIG_SMALL("DV (Digital Video)"),
729 .type = AVMEDIA_TYPE_VIDEO,
730 .id = AV_CODEC_ID_DVVIDEO,
731 .priv_data_size = sizeof(DVVideoContext),
732 .init = dvvideo_encode_init,
733 .encode2 = dvvideo_encode_frame,
734 .close = dvvideo_encode_close,
735 .capabilities = CODEC_CAP_SLICE_THREADS,
736 .pix_fmts = (const enum AVPixelFormat[]) {
737 AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE