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
27 #include "libavutil/attributes.h"
28 #include "libavutil/pixdesc.h"
34 #include "dv_tablegen.h"
36 static av_cold int dvvideo_encode_init(AVCodecContext *avctx)
38 if (!avpriv_dv_codec_profile(avctx)) {
39 av_log(avctx, AV_LOG_ERROR, "Found no DV profile for %ix%i %s video. "
40 "Valid DV profiles are:\n",
41 avctx->width, avctx->height, av_get_pix_fmt_name(avctx->pix_fmt));
42 ff_dv_print_profiles(avctx, AV_LOG_ERROR);
43 return AVERROR(EINVAL);
46 avctx->coded_frame = av_frame_alloc();
47 if (!avctx->coded_frame)
48 return AVERROR(ENOMEM);
50 dv_vlc_map_tableinit();
52 return ff_dvvideo_init(avctx);
55 /* bit budget for AC only in 5 MBs */
56 static const int vs_total_ac_bits = (100 * 4 + 68*2) * 5;
57 static const int mb_area_start[5] = { 1, 6, 21, 43, 64 };
60 /* Converts run and level (where level != 0) pair into VLC, returning bit size */
61 static av_always_inline int dv_rl2vlc(int run, int level, int sign, uint32_t* vlc)
64 if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {
65 *vlc = dv_vlc_map[run][level].vlc | sign;
66 size = dv_vlc_map[run][level].size;
69 if (level < DV_VLC_MAP_LEV_SIZE) {
70 *vlc = dv_vlc_map[0][level].vlc | sign;
71 size = dv_vlc_map[0][level].size;
73 *vlc = 0xfe00 | (level << 1) | sign;
77 *vlc |= ((run < 16) ? dv_vlc_map[run-1][0].vlc :
78 (0x1f80 | (run - 1))) << size;
79 size += (run < 16) ? dv_vlc_map[run-1][0].size : 13;
86 static av_always_inline int dv_rl2vlc_size(int run, int level)
90 if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {
91 size = dv_vlc_map[run][level].size;
94 size = (level < DV_VLC_MAP_LEV_SIZE) ? dv_vlc_map[0][level].size : 16;
96 size += (run < 16) ? dv_vlc_map[run-1][0].size : 13;
102 static av_always_inline int dv_rl2vlc(int run, int l, int sign, uint32_t* vlc)
104 *vlc = dv_vlc_map[run][l].vlc | sign;
105 return dv_vlc_map[run][l].size;
108 static av_always_inline int dv_rl2vlc_size(int run, int l)
110 return dv_vlc_map[run][l].size;
114 typedef struct EncBlockInfo {
124 uint8_t partial_bit_count;
125 uint32_t partial_bit_buffer; /* we can't use uint16_t here */
128 static av_always_inline PutBitContext* dv_encode_ac(EncBlockInfo* bi,
129 PutBitContext* pb_pool,
130 PutBitContext* pb_end)
133 PutBitContext* pb = pb_pool;
134 int size = bi->partial_bit_count;
135 uint32_t vlc = bi->partial_bit_buffer;
137 bi->partial_bit_count = bi->partial_bit_buffer = 0;
139 /* Find suitable storage space */
140 for (; size > (bits_left = put_bits_left(pb)); pb++) {
143 put_bits(pb, bits_left, vlc >> size);
144 vlc = vlc & ((1 << size) - 1);
146 if (pb + 1 >= pb_end) {
147 bi->partial_bit_count = size;
148 bi->partial_bit_buffer = vlc;
154 put_bits(pb, size, vlc);
156 if (bi->cur_ac >= 64)
159 /* Construct the next VLC */
161 bi->cur_ac = bi->next[prev];
162 if (bi->cur_ac < 64){
163 size = dv_rl2vlc(bi->cur_ac - prev - 1, bi->mb[bi->cur_ac], bi->sign[bi->cur_ac], &vlc);
165 size = 4; vlc = 6; /* End Of Block stamp */
171 static av_always_inline int dv_guess_dct_mode(DVVideoContext *s, uint8_t *data, int linesize) {
172 if (s->avctx->flags & CODEC_FLAG_INTERLACED_DCT) {
173 int ps = s->ildct_cmp(NULL, data, NULL, linesize, 8) - 400;
175 int is = s->ildct_cmp(NULL, data , NULL, linesize<<1, 4) +
176 s->ildct_cmp(NULL, data + linesize, NULL, linesize<<1, 4);
184 static const int dv_weight_bits = 18;
185 static const int dv_weight_88[64] = {
186 131072, 257107, 257107, 242189, 252167, 242189, 235923, 237536,
187 237536, 235923, 229376, 231390, 223754, 231390, 229376, 222935,
188 224969, 217965, 217965, 224969, 222935, 200636, 218652, 211916,
189 212325, 211916, 218652, 200636, 188995, 196781, 205965, 206433,
190 206433, 205965, 196781, 188995, 185364, 185364, 200636, 200704,
191 200636, 185364, 185364, 174609, 180568, 195068, 195068, 180568,
192 174609, 170091, 175557, 189591, 175557, 170091, 165371, 170627,
193 170627, 165371, 160727, 153560, 160727, 144651, 144651, 136258,
195 static const int dv_weight_248[64] = {
196 131072, 242189, 257107, 237536, 229376, 200636, 242189, 223754,
197 224969, 196781, 262144, 242189, 229376, 200636, 257107, 237536,
198 211916, 185364, 235923, 217965, 229376, 211916, 206433, 180568,
199 242189, 223754, 224969, 196781, 211916, 185364, 235923, 217965,
200 200704, 175557, 222935, 205965, 200636, 185364, 195068, 170627,
201 229376, 211916, 206433, 180568, 200704, 175557, 222935, 205965,
202 175557, 153560, 188995, 174609, 165371, 144651, 200636, 185364,
203 195068, 170627, 175557, 153560, 188995, 174609, 165371, 144651,
206 static av_always_inline int dv_init_enc_block(EncBlockInfo* bi, uint8_t *data, int linesize, DVVideoContext *s, int bias)
209 const uint8_t* zigzag_scan;
210 LOCAL_ALIGNED_16(int16_t, blk, [64]);
212 /* We offer two different methods for class number assignment: the
213 method suggested in SMPTE 314M Table 22, and an improved
214 method. The SMPTE method is very conservative; it assigns class
215 3 (i.e. severe quantization) to any block where the largest AC
216 component is greater than 36. Libav's DV encoder tracks AC bit
217 consumption precisely, so there is no need to bias most blocks
218 towards strongly lossy compression. Instead, we assign class 2
219 to most blocks, and use class 3 only when strictly necessary
220 (for blocks whose largest AC component exceeds 255). */
222 #if 0 /* SMPTE spec method */
223 static const int classes[] = {12, 24, 36, 0xffff};
224 #else /* improved Libav method */
225 static const int classes[] = {-1, -1, 255, 0xffff};
227 int max = classes[0];
230 assert((((int)blk) & 15) == 0);
232 bi->area_q[0] = bi->area_q[1] = bi->area_q[2] = bi->area_q[3] = 0;
233 bi->partial_bit_count = 0;
234 bi->partial_bit_buffer = 0;
237 bi->dct_mode = dv_guess_dct_mode(s, data, linesize);
238 s->get_pixels(blk, data, linesize);
239 s->fdct[bi->dct_mode](blk);
241 /* We rely on the fact that encoding all zeros leads to an immediate EOB,
242 which is precisely what the spec calls for in the "dummy" blocks. */
243 memset(blk, 0, 64*sizeof(*blk));
248 zigzag_scan = bi->dct_mode ? ff_zigzag248_direct : ff_zigzag_direct;
249 weight = bi->dct_mode ? dv_weight_248 : dv_weight_88;
251 for (area = 0; area < 4; area++) {
252 bi->prev[area] = prev;
253 bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
254 for (i = mb_area_start[area]; i < mb_area_start[area+1]; i++) {
255 int level = blk[zigzag_scan[i]];
257 if (level + 15 > 30U) {
258 bi->sign[i] = (level >> 31) & 1;
259 /* weight it and and shift down into range, adding for rounding */
260 /* the extra division by a factor of 2^4 reverses the 8x expansion of the DCT
261 AND the 2x doubling of the weights */
262 level = (FFABS(level) * weight[i] + (1 << (dv_weight_bits+3))) >> (dv_weight_bits+4);
266 bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, level);
273 for (bi->cno = 0; max > classes[bi->cno]; bi->cno++);
281 for (area = 0; area < 4; area++) {
282 bi->prev[area] = prev;
283 bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
284 for (; i < mb_area_start[area+1]; i = bi->next[i]) {
288 bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, bi->mb[i]);
297 return bi->bit_size[0] + bi->bit_size[1] + bi->bit_size[2] + bi->bit_size[3];
300 static inline void dv_guess_qnos(EncBlockInfo* blks, int* qnos)
303 int i, j, k, a, prev, a2;
306 size[0] = size[1] = size[2] = size[3] = size[4] = 1 << 24;
309 for (i = 0; i < 5; i++) {
315 for (j = 0; j < 6; j++, b++) {
316 for (a = 0; a < 4; a++) {
317 if (b->area_q[a] != ff_dv_quant_shifts[qnos[i] + ff_dv_quant_offset[b->cno]][a]) {
318 b->bit_size[a] = 1; // 4 areas 4 bits for EOB :)
321 assert(b->next[prev] >= mb_area_start[a+1] || b->mb[prev]);
322 for (k = b->next[prev] ; k < mb_area_start[a+1]; k = b->next[k]) {
325 b->bit_size[a] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
328 if (b->next[k] >= mb_area_start[a+1] && b->next[k]<64){
329 for (a2 = a + 1; b->next[k] >= mb_area_start[a2+1]; a2++)
332 assert(b->mb[b->next[k]]);
333 b->bit_size[a2] += dv_rl2vlc_size(b->next[k] - prev - 1, b->mb[b->next[k]])
334 -dv_rl2vlc_size(b->next[k] - k - 1, b->mb[b->next[k]]);
335 assert(b->prev[a2] == k && (a2 + 1 >= 4 || b->prev[a2+1] != k));
338 b->next[prev] = b->next[k];
343 size[i] += b->bit_size[a];
346 if (vs_total_ac_bits >= size[0] + size[1] + size[2] + size[3] + size[4])
349 } while (qnos[0]|qnos[1]|qnos[2]|qnos[3]|qnos[4]);
352 for (a = 2; a == 2 || vs_total_ac_bits < size[0]; a += a){
354 size[0] = 5 * 6 * 4; //EOB
355 for (j = 0; j < 6 *5; j++, b++) {
357 for (k = b->next[prev]; k < 64; k = b->next[k]) {
358 if (b->mb[k] < a && b->mb[k] > -a){
359 b->next[prev] = b->next[k];
361 size[0] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
369 static int dv_encode_video_segment(AVCodecContext *avctx, void *arg)
371 DVVideoContext *s = avctx->priv_data;
372 DVwork_chunk *work_chunk = arg;
374 int mb_x, mb_y, c_offset, linesize, y_stride;
377 LOCAL_ALIGNED_8(uint8_t, scratch, [128]);
378 EncBlockInfo enc_blks[5*DV_MAX_BPM];
379 PutBitContext pbs[5*DV_MAX_BPM];
381 EncBlockInfo* enc_blk;
383 int qnos[5] = {15, 15, 15, 15, 15}; /* No quantization */
384 int* qnosp = &qnos[0];
386 dif = &s->buf[work_chunk->buf_offset*80];
387 enc_blk = &enc_blks[0];
388 for (mb_index = 0; mb_index < 5; mb_index++) {
389 dv_calculate_mb_xy(s, work_chunk, mb_index, &mb_x, &mb_y);
391 /* initializing luminance blocks */
392 if ((s->sys->pix_fmt == AV_PIX_FMT_YUV420P) ||
393 (s->sys->pix_fmt == AV_PIX_FMT_YUV411P && mb_x >= (704 / 8)) ||
394 (s->sys->height >= 720 && mb_y != 134)) {
395 y_stride = s->frame->linesize[0] << 3;
399 y_ptr = s->frame->data[0] + ((mb_y * s->frame->linesize[0] + mb_x) << 3);
400 linesize = s->frame->linesize[0];
402 if (s->sys->video_stype == 4) { /* SD 422 */
404 dv_init_enc_block(enc_blk+0, y_ptr , linesize, s, 0) +
405 dv_init_enc_block(enc_blk+1, NULL , linesize, s, 0) +
406 dv_init_enc_block(enc_blk+2, y_ptr + 8 , linesize, s, 0) +
407 dv_init_enc_block(enc_blk+3, NULL , linesize, s, 0);
410 dv_init_enc_block(enc_blk+0, y_ptr , linesize, s, 0) +
411 dv_init_enc_block(enc_blk+1, y_ptr + 8 , linesize, s, 0) +
412 dv_init_enc_block(enc_blk+2, y_ptr + y_stride, linesize, s, 0) +
413 dv_init_enc_block(enc_blk+3, y_ptr + 8 + y_stride, linesize, s, 0);
417 /* initializing chrominance blocks */
418 c_offset = (((mb_y >> (s->sys->pix_fmt == AV_PIX_FMT_YUV420P)) * s->frame->linesize[1] +
419 (mb_x >> ((s->sys->pix_fmt == AV_PIX_FMT_YUV411P) ? 2 : 1))) << 3);
420 for (j = 2; j; j--) {
421 uint8_t *c_ptr = s->frame->data[j] + c_offset;
422 linesize = s->frame->linesize[j];
423 y_stride = (mb_y == 134) ? 8 : (s->frame->linesize[j] << 3);
424 if (s->sys->pix_fmt == AV_PIX_FMT_YUV411P && mb_x >= (704 / 8)) {
426 uint8_t* b = scratch;
427 for (i = 0; i < 8; i++) {
428 d = c_ptr + (linesize << 3);
429 b[0] = c_ptr[0]; b[1] = c_ptr[1]; b[2] = c_ptr[2]; b[3] = c_ptr[3];
430 b[4] = d[0]; b[5] = d[1]; b[6] = d[2]; b[7] = d[3];
438 vs_bit_size += dv_init_enc_block( enc_blk++, c_ptr , linesize, s, 1);
439 if (s->sys->bpm == 8) {
440 vs_bit_size += dv_init_enc_block(enc_blk++, c_ptr + y_stride, linesize, s, 1);
445 if (vs_total_ac_bits < vs_bit_size)
446 dv_guess_qnos(&enc_blks[0], qnosp);
448 /* DIF encoding process */
449 for (j=0; j<5*s->sys->bpm;) {
455 /* First pass over individual cells only */
456 for (i=0; i<s->sys->bpm; i++, j++) {
457 int sz = s->sys->block_sizes[i]>>3;
459 init_put_bits(&pbs[j], dif, sz);
460 put_sbits(&pbs[j], 9, ((enc_blks[j].mb[0] >> 3) - 1024 + 2) >> 2);
461 put_bits(&pbs[j], 1, enc_blks[j].dct_mode);
462 put_bits(&pbs[j], 2, enc_blks[j].cno);
464 dv_encode_ac(&enc_blks[j], &pbs[j], &pbs[j+1]);
468 /* Second pass over each MB space */
470 for (i=0; i<s->sys->bpm; i++) {
471 if (enc_blks[start_mb+i].partial_bit_count)
472 pb = dv_encode_ac(&enc_blks[start_mb+i], pb, &pbs[start_mb+s->sys->bpm]);
476 /* Third and final pass over the whole video segment space */
478 for (j=0; j<5*s->sys->bpm; j++) {
479 if (enc_blks[j].partial_bit_count)
480 pb = dv_encode_ac(&enc_blks[j], pb, &pbs[s->sys->bpm*5]);
481 if (enc_blks[j].partial_bit_count)
482 av_log(avctx, AV_LOG_ERROR, "ac bitstream overflow\n");
485 for (j=0; j<5*s->sys->bpm; j++) {
487 int size = pbs[j].size_in_bits >> 3;
488 flush_put_bits(&pbs[j]);
489 pos = put_bits_count(&pbs[j]) >> 3;
491 av_log(avctx, AV_LOG_ERROR, "bitstream written beyond buffer size\n");
494 memset(pbs[j].buf + pos, 0xff, size - pos);
500 static inline int dv_write_pack(enum dv_pack_type pack_id, DVVideoContext *c,
504 * Here's what SMPTE314M says about these two:
505 * (page 6) APTn, AP1n, AP2n, AP3n: These data shall be identical
506 * as track application IDs (APTn = 001, AP1n =
507 * 001, AP2n = 001, AP3n = 001), if the source signal
508 * comes from a digital VCR. If the signal source is
509 * unknown, all bits for these data shall be set to 1.
510 * (page 12) STYPE: STYPE defines a signal type of video signal
511 * 00000b = 4:1:1 compression
512 * 00100b = 4:2:2 compression
514 * Now, I've got two problems with these statements:
515 * 1. it looks like APT == 111b should be a safe bet, but it isn't.
516 * It seems that for PAL as defined in IEC 61834 we have to set
517 * APT to 000 and for SMPTE314M to 001.
518 * 2. It is not at all clear what STYPE is used for 4:2:0 PAL
519 * compression scheme (if any).
521 int apt = (c->sys->pix_fmt == AV_PIX_FMT_YUV420P ? 0 : 1);
524 if ((int)(av_q2d(c->avctx->sample_aspect_ratio) * c->avctx->width / c->avctx->height * 10) >= 17) /* 16:9 */
527 buf[0] = (uint8_t)pack_id;
529 case dv_header525: /* I can't imagine why these two weren't defined as real */
530 case dv_header625: /* packs in SMPTE314M -- they definitely look like ones */
531 buf[1] = 0xf8 | /* reserved -- always 1 */
532 (apt & 0x07); /* APT: Track application ID */
533 buf[2] = (0 << 7) | /* TF1: audio data is 0 - valid; 1 - invalid */
534 (0x0f << 3) | /* reserved -- always 1 */
535 (apt & 0x07); /* AP1: Audio application ID */
536 buf[3] = (0 << 7) | /* TF2: video data is 0 - valid; 1 - invalid */
537 (0x0f << 3) | /* reserved -- always 1 */
538 (apt & 0x07); /* AP2: Video application ID */
539 buf[4] = (0 << 7) | /* TF3: subcode(SSYB) is 0 - valid; 1 - invalid */
540 (0x0f << 3) | /* reserved -- always 1 */
541 (apt & 0x07); /* AP3: Subcode application ID */
543 case dv_video_source:
544 buf[1] = 0xff; /* reserved -- always 1 */
545 buf[2] = (1 << 7) | /* B/W: 0 - b/w, 1 - color */
546 (1 << 6) | /* following CLF is valid - 0, invalid - 1 */
547 (3 << 4) | /* CLF: color frames ID (see ITU-R BT.470-4) */
548 0xf; /* reserved -- always 1 */
549 buf[3] = (3 << 6) | /* reserved -- always 1 */
550 (c->sys->dsf << 5) | /* system: 60fields/50fields */
551 c->sys->video_stype; /* signal type video compression */
552 buf[4] = 0xff; /* VISC: 0xff -- no information */
554 case dv_video_control:
555 buf[1] = (0 << 6) | /* Copy generation management (CGMS) 0 -- free */
556 0x3f; /* reserved -- always 1 */
557 buf[2] = 0xc8 | /* reserved -- always b11001xxx */
559 buf[3] = (1 << 7) | /* frame/field flag 1 -- frame, 0 -- field */
560 (1 << 6) | /* first/second field flag 0 -- field 2, 1 -- field 1 */
561 (1 << 5) | /* frame change flag 0 -- same picture as before, 1 -- different */
562 (1 << 4) | /* 1 - interlaced, 0 - noninterlaced */
563 0xc; /* reserved -- always b1100 */
564 buf[4] = 0xff; /* reserved -- always 1 */
567 buf[1] = buf[2] = buf[3] = buf[4] = 0xff;
572 static inline int dv_write_dif_id(enum dv_section_type t, uint8_t chan_num,
573 uint8_t seq_num, uint8_t dif_num,
576 buf[0] = (uint8_t)t; /* Section type */
577 buf[1] = (seq_num << 4) | /* DIF seq number 0-9 for 525/60; 0-11 for 625/50 */
578 (chan_num << 3) | /* FSC: for 50Mb/s 0 - first channel; 1 - second */
579 7; /* reserved -- always 1 */
580 buf[2] = dif_num; /* DIF block number Video: 0-134, Audio: 0-8 */
585 static inline int dv_write_ssyb_id(uint8_t syb_num, uint8_t fr, uint8_t* buf)
587 if (syb_num == 0 || syb_num == 6) {
588 buf[0] = (fr << 7) | /* FR ID 1 - first half of each channel; 0 - second */
589 (0 << 4) | /* AP3 (Subcode application ID) */
590 0x0f; /* reserved -- always 1 */
592 else if (syb_num == 11) {
593 buf[0] = (fr << 7) | /* FR ID 1 - first half of each channel; 0 - second */
594 0x7f; /* reserved -- always 1 */
597 buf[0] = (fr << 7) | /* FR ID 1 - first half of each channel; 0 - second */
598 (0 << 4) | /* APT (Track application ID) */
599 0x0f; /* reserved -- always 1 */
601 buf[1] = 0xf0 | /* reserved -- always 1 */
602 (syb_num & 0x0f); /* SSYB number 0 - 11 */
603 buf[2] = 0xff; /* reserved -- always 1 */
607 static void dv_format_frame(DVVideoContext* c, uint8_t* buf)
611 for (chan = 0; chan < c->sys->n_difchan; chan++) {
612 for (i = 0; i < c->sys->difseg_size; i++) {
613 memset(buf, 0xff, 80 * 6); /* first 6 DIF blocks are for control data */
615 /* DV header: 1DIF */
616 buf += dv_write_dif_id(dv_sect_header, chan, i, 0, buf);
617 buf += dv_write_pack((c->sys->dsf ? dv_header625 : dv_header525), c, buf);
618 buf += 72; /* unused bytes */
620 /* DV subcode: 2DIFs */
621 for (j = 0; j < 2; j++) {
622 buf += dv_write_dif_id(dv_sect_subcode, chan, i, j, buf);
623 for (k = 0; k < 6; k++)
624 buf += dv_write_ssyb_id(k, (i < c->sys->difseg_size/2), buf) + 5;
625 buf += 29; /* unused bytes */
629 for (j = 0; j < 3; j++) {
630 buf += dv_write_dif_id(dv_sect_vaux, chan, i, j, buf);
631 buf += dv_write_pack(dv_video_source, c, buf);
632 buf += dv_write_pack(dv_video_control, c, buf);
634 buf += dv_write_pack(dv_video_source, c, buf);
635 buf += dv_write_pack(dv_video_control, c, buf);
636 buf += 4*5 + 2; /* unused bytes */
639 /* DV Audio/Video: 135 Video DIFs + 9 Audio DIFs */
640 for (j = 0; j < 135; j++) {
642 memset(buf, 0xff, 80);
643 buf += dv_write_dif_id(dv_sect_audio, chan, i, j/15, buf);
644 buf += 77; /* audio control & shuffled PCM audio */
646 buf += dv_write_dif_id(dv_sect_video, chan, i, j, buf);
647 buf += 77; /* 1 video macroblock: 1 bytes control
648 4 * 14 bytes Y 8x8 data
650 10 bytes Cb 8x8 data */
657 static int dvvideo_encode_frame(AVCodecContext *c, AVPacket *pkt,
658 const AVFrame *frame, int *got_packet)
660 DVVideoContext *s = c->priv_data;
663 s->sys = avpriv_dv_codec_profile(c);
664 if (!s->sys || ff_dv_init_dynamic_tables(s->sys))
666 if ((ret = ff_alloc_packet(pkt, s->sys->frame_size)) < 0) {
667 av_log(c, AV_LOG_ERROR, "Error getting output packet.\n");
671 c->pix_fmt = s->sys->pix_fmt;
673 c->coded_frame->key_frame = 1;
674 c->coded_frame->pict_type = AV_PICTURE_TYPE_I;
677 c->execute(c, dv_encode_video_segment, s->sys->work_chunks, NULL,
678 dv_work_pool_size(s->sys), sizeof(DVwork_chunk));
682 dv_format_frame(s, pkt->data);
684 pkt->flags |= AV_PKT_FLAG_KEY;
690 static int dvvideo_encode_close(AVCodecContext *avctx)
692 av_frame_free(&avctx->coded_frame);
696 AVCodec ff_dvvideo_encoder = {
698 .long_name = NULL_IF_CONFIG_SMALL("DV (Digital Video)"),
699 .type = AVMEDIA_TYPE_VIDEO,
700 .id = AV_CODEC_ID_DVVIDEO,
701 .priv_data_size = sizeof(DVVideoContext),
702 .init = dvvideo_encode_init,
703 .encode2 = dvvideo_encode_frame,
704 .close = dvvideo_encode_close,
705 .capabilities = CODEC_CAP_SLICE_THREADS,
706 .pix_fmts = (const enum AVPixelFormat[]) {
707 AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE