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 DVVideoContext *s = avctx->priv_data;
41 s->sys = avpriv_dv_codec_profile(avctx);
43 av_log(avctx, AV_LOG_ERROR, "Found no DV profile for %ix%i %s video. "
44 "Valid DV profiles are:\n",
45 avctx->width, avctx->height, av_get_pix_fmt_name(avctx->pix_fmt));
46 ff_dv_print_profiles(avctx, AV_LOG_ERROR);
47 return AVERROR(EINVAL);
49 ret = ff_dv_init_dynamic_tables(s, s->sys);
51 av_log(avctx, AV_LOG_ERROR, "Error initializing work tables.\n");
55 avctx->coded_frame = av_frame_alloc();
56 if (!avctx->coded_frame)
57 return AVERROR(ENOMEM);
59 dv_vlc_map_tableinit();
61 return ff_dvvideo_init(avctx);
64 /* bit budget for AC only in 5 MBs */
65 static const int vs_total_ac_bits = (100 * 4 + 68*2) * 5;
66 static const int mb_area_start[5] = { 1, 6, 21, 43, 64 };
69 /* Converts run and level (where level != 0) pair into VLC, returning bit size */
70 static av_always_inline int dv_rl2vlc(int run, int level, int sign, uint32_t* vlc)
73 if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {
74 *vlc = dv_vlc_map[run][level].vlc | sign;
75 size = dv_vlc_map[run][level].size;
78 if (level < DV_VLC_MAP_LEV_SIZE) {
79 *vlc = dv_vlc_map[0][level].vlc | sign;
80 size = dv_vlc_map[0][level].size;
82 *vlc = 0xfe00 | (level << 1) | sign;
86 *vlc |= ((run < 16) ? dv_vlc_map[run-1][0].vlc :
87 (0x1f80 | (run - 1))) << size;
88 size += (run < 16) ? dv_vlc_map[run-1][0].size : 13;
95 static av_always_inline int dv_rl2vlc_size(int run, int level)
99 if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {
100 size = dv_vlc_map[run][level].size;
103 size = (level < DV_VLC_MAP_LEV_SIZE) ? dv_vlc_map[0][level].size : 16;
105 size += (run < 16) ? dv_vlc_map[run-1][0].size : 13;
111 static av_always_inline int dv_rl2vlc(int run, int l, int sign, uint32_t* vlc)
113 *vlc = dv_vlc_map[run][l].vlc | sign;
114 return dv_vlc_map[run][l].size;
117 static av_always_inline int dv_rl2vlc_size(int run, int l)
119 return dv_vlc_map[run][l].size;
123 typedef struct EncBlockInfo {
133 uint8_t partial_bit_count;
134 uint32_t partial_bit_buffer; /* we can't use uint16_t here */
137 static av_always_inline PutBitContext* dv_encode_ac(EncBlockInfo* bi,
138 PutBitContext* pb_pool,
139 PutBitContext* pb_end)
142 PutBitContext* pb = pb_pool;
143 int size = bi->partial_bit_count;
144 uint32_t vlc = bi->partial_bit_buffer;
146 bi->partial_bit_count = bi->partial_bit_buffer = 0;
148 /* Find suitable storage space */
149 for (; size > (bits_left = put_bits_left(pb)); pb++) {
152 put_bits(pb, bits_left, vlc >> size);
153 vlc = vlc & ((1 << size) - 1);
155 if (pb + 1 >= pb_end) {
156 bi->partial_bit_count = size;
157 bi->partial_bit_buffer = vlc;
163 put_bits(pb, size, vlc);
165 if (bi->cur_ac >= 64)
168 /* Construct the next VLC */
170 bi->cur_ac = bi->next[prev];
171 if (bi->cur_ac < 64){
172 size = dv_rl2vlc(bi->cur_ac - prev - 1, bi->mb[bi->cur_ac], bi->sign[bi->cur_ac], &vlc);
174 size = 4; vlc = 6; /* End Of Block stamp */
180 static av_always_inline int dv_guess_dct_mode(DVVideoContext *s, uint8_t *data, int linesize) {
181 if (s->avctx->flags & CODEC_FLAG_INTERLACED_DCT) {
182 int ps = s->ildct_cmp(NULL, data, NULL, linesize, 8) - 400;
184 int is = s->ildct_cmp(NULL, data , NULL, linesize<<1, 4) +
185 s->ildct_cmp(NULL, data + linesize, NULL, linesize<<1, 4);
193 static const int dv_weight_bits = 18;
194 static const int dv_weight_88[64] = {
195 131072, 257107, 257107, 242189, 252167, 242189, 235923, 237536,
196 237536, 235923, 229376, 231390, 223754, 231390, 229376, 222935,
197 224969, 217965, 217965, 224969, 222935, 200636, 218652, 211916,
198 212325, 211916, 218652, 200636, 188995, 196781, 205965, 206433,
199 206433, 205965, 196781, 188995, 185364, 185364, 200636, 200704,
200 200636, 185364, 185364, 174609, 180568, 195068, 195068, 180568,
201 174609, 170091, 175557, 189591, 175557, 170091, 165371, 170627,
202 170627, 165371, 160727, 153560, 160727, 144651, 144651, 136258,
204 static const int dv_weight_248[64] = {
205 131072, 242189, 257107, 237536, 229376, 200636, 242189, 223754,
206 224969, 196781, 262144, 242189, 229376, 200636, 257107, 237536,
207 211916, 185364, 235923, 217965, 229376, 211916, 206433, 180568,
208 242189, 223754, 224969, 196781, 211916, 185364, 235923, 217965,
209 200704, 175557, 222935, 205965, 200636, 185364, 195068, 170627,
210 229376, 211916, 206433, 180568, 200704, 175557, 222935, 205965,
211 175557, 153560, 188995, 174609, 165371, 144651, 200636, 185364,
212 195068, 170627, 175557, 153560, 188995, 174609, 165371, 144651,
215 static av_always_inline int dv_init_enc_block(EncBlockInfo* bi, uint8_t *data, int linesize, DVVideoContext *s, int bias)
218 const uint8_t* zigzag_scan;
219 LOCAL_ALIGNED_16(int16_t, blk, [64]);
221 /* We offer two different methods for class number assignment: the
222 method suggested in SMPTE 314M Table 22, and an improved
223 method. The SMPTE method is very conservative; it assigns class
224 3 (i.e. severe quantization) to any block where the largest AC
225 component is greater than 36. Libav's DV encoder tracks AC bit
226 consumption precisely, so there is no need to bias most blocks
227 towards strongly lossy compression. Instead, we assign class 2
228 to most blocks, and use class 3 only when strictly necessary
229 (for blocks whose largest AC component exceeds 255). */
231 #if 0 /* SMPTE spec method */
232 static const int classes[] = {12, 24, 36, 0xffff};
233 #else /* improved Libav method */
234 static const int classes[] = {-1, -1, 255, 0xffff};
236 int max = classes[0];
239 assert((((int)blk) & 15) == 0);
241 bi->area_q[0] = bi->area_q[1] = bi->area_q[2] = bi->area_q[3] = 0;
242 bi->partial_bit_count = 0;
243 bi->partial_bit_buffer = 0;
246 bi->dct_mode = dv_guess_dct_mode(s, data, linesize);
247 s->get_pixels(blk, data, linesize);
248 s->fdct[bi->dct_mode](blk);
250 /* We rely on the fact that encoding all zeros leads to an immediate EOB,
251 which is precisely what the spec calls for in the "dummy" blocks. */
252 memset(blk, 0, 64*sizeof(*blk));
257 zigzag_scan = bi->dct_mode ? ff_dv_zigzag248_direct : ff_zigzag_direct;
258 weight = bi->dct_mode ? dv_weight_248 : dv_weight_88;
260 for (area = 0; area < 4; area++) {
261 bi->prev[area] = prev;
262 bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
263 for (i = mb_area_start[area]; i < mb_area_start[area+1]; i++) {
264 int level = blk[zigzag_scan[i]];
266 if (level + 15 > 30U) {
267 bi->sign[i] = (level >> 31) & 1;
268 /* weight it and and shift down into range, adding for rounding */
269 /* the extra division by a factor of 2^4 reverses the 8x expansion of the DCT
270 AND the 2x doubling of the weights */
271 level = (FFABS(level) * weight[i] + (1 << (dv_weight_bits+3))) >> (dv_weight_bits+4);
275 bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, level);
282 for (bi->cno = 0; max > classes[bi->cno]; bi->cno++);
290 for (area = 0; area < 4; area++) {
291 bi->prev[area] = prev;
292 bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
293 for (; i < mb_area_start[area+1]; i = bi->next[i]) {
297 bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, bi->mb[i]);
306 return bi->bit_size[0] + bi->bit_size[1] + bi->bit_size[2] + bi->bit_size[3];
309 static inline void dv_guess_qnos(EncBlockInfo* blks, int* qnos)
312 int i, j, k, a, prev, a2;
315 size[0] = size[1] = size[2] = size[3] = size[4] = 1 << 24;
318 for (i = 0; i < 5; i++) {
324 for (j = 0; j < 6; j++, b++) {
325 for (a = 0; a < 4; a++) {
326 if (b->area_q[a] != ff_dv_quant_shifts[qnos[i] + ff_dv_quant_offset[b->cno]][a]) {
327 b->bit_size[a] = 1; // 4 areas 4 bits for EOB :)
330 assert(b->next[prev] >= mb_area_start[a+1] || b->mb[prev]);
331 for (k = b->next[prev] ; k < mb_area_start[a+1]; k = b->next[k]) {
334 b->bit_size[a] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
337 if (b->next[k] >= mb_area_start[a+1] && b->next[k]<64){
338 for (a2 = a + 1; b->next[k] >= mb_area_start[a2+1]; a2++)
341 assert(b->mb[b->next[k]]);
342 b->bit_size[a2] += dv_rl2vlc_size(b->next[k] - prev - 1, b->mb[b->next[k]])
343 -dv_rl2vlc_size(b->next[k] - k - 1, b->mb[b->next[k]]);
344 assert(b->prev[a2] == k && (a2 + 1 >= 4 || b->prev[a2+1] != k));
347 b->next[prev] = b->next[k];
352 size[i] += b->bit_size[a];
355 if (vs_total_ac_bits >= size[0] + size[1] + size[2] + size[3] + size[4])
358 } while (qnos[0]|qnos[1]|qnos[2]|qnos[3]|qnos[4]);
361 for (a = 2; a == 2 || vs_total_ac_bits < size[0]; a += a){
363 size[0] = 5 * 6 * 4; //EOB
364 for (j = 0; j < 6 *5; j++, b++) {
366 for (k = b->next[prev]; k < 64; k = b->next[k]) {
367 if (b->mb[k] < a && b->mb[k] > -a){
368 b->next[prev] = b->next[k];
370 size[0] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
378 static int dv_encode_video_segment(AVCodecContext *avctx, void *arg)
380 DVVideoContext *s = avctx->priv_data;
381 DVwork_chunk *work_chunk = arg;
383 int mb_x, mb_y, c_offset, linesize, y_stride;
386 LOCAL_ALIGNED_8(uint8_t, scratch, [128]);
387 EncBlockInfo enc_blks[5*DV_MAX_BPM];
388 PutBitContext pbs[5*DV_MAX_BPM];
390 EncBlockInfo* enc_blk;
392 int qnos[5] = {15, 15, 15, 15, 15}; /* No quantization */
393 int* qnosp = &qnos[0];
395 dif = &s->buf[work_chunk->buf_offset*80];
396 enc_blk = &enc_blks[0];
397 for (mb_index = 0; mb_index < 5; mb_index++) {
398 dv_calculate_mb_xy(s, work_chunk, mb_index, &mb_x, &mb_y);
400 /* initializing luminance blocks */
401 if ((s->sys->pix_fmt == AV_PIX_FMT_YUV420P) ||
402 (s->sys->pix_fmt == AV_PIX_FMT_YUV411P && mb_x >= (704 / 8)) ||
403 (s->sys->height >= 720 && mb_y != 134)) {
404 y_stride = s->frame->linesize[0] << 3;
408 y_ptr = s->frame->data[0] + ((mb_y * s->frame->linesize[0] + mb_x) << 3);
409 linesize = s->frame->linesize[0];
411 if (s->sys->video_stype == 4) { /* SD 422 */
413 dv_init_enc_block(enc_blk+0, y_ptr , linesize, s, 0) +
414 dv_init_enc_block(enc_blk+1, NULL , linesize, s, 0) +
415 dv_init_enc_block(enc_blk+2, y_ptr + 8 , linesize, s, 0) +
416 dv_init_enc_block(enc_blk+3, NULL , linesize, s, 0);
419 dv_init_enc_block(enc_blk+0, y_ptr , linesize, s, 0) +
420 dv_init_enc_block(enc_blk+1, y_ptr + 8 , linesize, s, 0) +
421 dv_init_enc_block(enc_blk+2, y_ptr + y_stride, linesize, s, 0) +
422 dv_init_enc_block(enc_blk+3, y_ptr + 8 + y_stride, linesize, s, 0);
426 /* initializing chrominance blocks */
427 c_offset = (((mb_y >> (s->sys->pix_fmt == AV_PIX_FMT_YUV420P)) * s->frame->linesize[1] +
428 (mb_x >> ((s->sys->pix_fmt == AV_PIX_FMT_YUV411P) ? 2 : 1))) << 3);
429 for (j = 2; j; j--) {
430 uint8_t *c_ptr = s->frame->data[j] + c_offset;
431 linesize = s->frame->linesize[j];
432 y_stride = (mb_y == 134) ? 8 : (s->frame->linesize[j] << 3);
433 if (s->sys->pix_fmt == AV_PIX_FMT_YUV411P && mb_x >= (704 / 8)) {
435 uint8_t* b = scratch;
436 for (i = 0; i < 8; i++) {
437 d = c_ptr + (linesize << 3);
438 b[0] = c_ptr[0]; b[1] = c_ptr[1]; b[2] = c_ptr[2]; b[3] = c_ptr[3];
439 b[4] = d[0]; b[5] = d[1]; b[6] = d[2]; b[7] = d[3];
447 vs_bit_size += dv_init_enc_block( enc_blk++, c_ptr , linesize, s, 1);
448 if (s->sys->bpm == 8) {
449 vs_bit_size += dv_init_enc_block(enc_blk++, c_ptr + y_stride, linesize, s, 1);
454 if (vs_total_ac_bits < vs_bit_size)
455 dv_guess_qnos(&enc_blks[0], qnosp);
457 /* DIF encoding process */
458 for (j=0; j<5*s->sys->bpm;) {
464 /* First pass over individual cells only */
465 for (i=0; i<s->sys->bpm; i++, j++) {
466 int sz = s->sys->block_sizes[i]>>3;
468 init_put_bits(&pbs[j], dif, sz);
469 put_sbits(&pbs[j], 9, ((enc_blks[j].mb[0] >> 3) - 1024 + 2) >> 2);
470 put_bits(&pbs[j], 1, enc_blks[j].dct_mode);
471 put_bits(&pbs[j], 2, enc_blks[j].cno);
473 dv_encode_ac(&enc_blks[j], &pbs[j], &pbs[j+1]);
477 /* Second pass over each MB space */
479 for (i=0; i<s->sys->bpm; i++) {
480 if (enc_blks[start_mb+i].partial_bit_count)
481 pb = dv_encode_ac(&enc_blks[start_mb+i], pb, &pbs[start_mb+s->sys->bpm]);
485 /* Third and final pass over the whole video segment space */
487 for (j=0; j<5*s->sys->bpm; j++) {
488 if (enc_blks[j].partial_bit_count)
489 pb = dv_encode_ac(&enc_blks[j], pb, &pbs[s->sys->bpm*5]);
490 if (enc_blks[j].partial_bit_count)
491 av_log(avctx, AV_LOG_ERROR, "ac bitstream overflow\n");
494 for (j=0; j<5*s->sys->bpm; j++) {
496 int size = pbs[j].size_in_bits >> 3;
497 flush_put_bits(&pbs[j]);
498 pos = put_bits_count(&pbs[j]) >> 3;
500 av_log(avctx, AV_LOG_ERROR, "bitstream written beyond buffer size\n");
503 memset(pbs[j].buf + pos, 0xff, size - pos);
509 static inline int dv_write_pack(enum dv_pack_type pack_id, DVVideoContext *c,
513 * Here's what SMPTE314M says about these two:
514 * (page 6) APTn, AP1n, AP2n, AP3n: These data shall be identical
515 * as track application IDs (APTn = 001, AP1n =
516 * 001, AP2n = 001, AP3n = 001), if the source signal
517 * comes from a digital VCR. If the signal source is
518 * unknown, all bits for these data shall be set to 1.
519 * (page 12) STYPE: STYPE defines a signal type of video signal
520 * 00000b = 4:1:1 compression
521 * 00100b = 4:2:2 compression
523 * Now, I've got two problems with these statements:
524 * 1. it looks like APT == 111b should be a safe bet, but it isn't.
525 * It seems that for PAL as defined in IEC 61834 we have to set
526 * APT to 000 and for SMPTE314M to 001.
527 * 2. It is not at all clear what STYPE is used for 4:2:0 PAL
528 * compression scheme (if any).
530 int apt = (c->sys->pix_fmt == AV_PIX_FMT_YUV420P ? 0 : 1);
533 if ((int)(av_q2d(c->avctx->sample_aspect_ratio) * c->avctx->width / c->avctx->height * 10) >= 17) /* 16:9 */
536 buf[0] = (uint8_t)pack_id;
538 case dv_header525: /* I can't imagine why these two weren't defined as real */
539 case dv_header625: /* packs in SMPTE314M -- they definitely look like ones */
540 buf[1] = 0xf8 | /* reserved -- always 1 */
541 (apt & 0x07); /* APT: Track application ID */
542 buf[2] = (0 << 7) | /* TF1: audio data is 0 - valid; 1 - invalid */
543 (0x0f << 3) | /* reserved -- always 1 */
544 (apt & 0x07); /* AP1: Audio application ID */
545 buf[3] = (0 << 7) | /* TF2: video data is 0 - valid; 1 - invalid */
546 (0x0f << 3) | /* reserved -- always 1 */
547 (apt & 0x07); /* AP2: Video application ID */
548 buf[4] = (0 << 7) | /* TF3: subcode(SSYB) is 0 - valid; 1 - invalid */
549 (0x0f << 3) | /* reserved -- always 1 */
550 (apt & 0x07); /* AP3: Subcode application ID */
552 case dv_video_source:
553 buf[1] = 0xff; /* reserved -- always 1 */
554 buf[2] = (1 << 7) | /* B/W: 0 - b/w, 1 - color */
555 (1 << 6) | /* following CLF is valid - 0, invalid - 1 */
556 (3 << 4) | /* CLF: color frames ID (see ITU-R BT.470-4) */
557 0xf; /* reserved -- always 1 */
558 buf[3] = (3 << 6) | /* reserved -- always 1 */
559 (c->sys->dsf << 5) | /* system: 60fields/50fields */
560 c->sys->video_stype; /* signal type video compression */
561 buf[4] = 0xff; /* VISC: 0xff -- no information */
563 case dv_video_control:
564 buf[1] = (0 << 6) | /* Copy generation management (CGMS) 0 -- free */
565 0x3f; /* reserved -- always 1 */
566 buf[2] = 0xc8 | /* reserved -- always b11001xxx */
568 buf[3] = (1 << 7) | /* frame/field flag 1 -- frame, 0 -- field */
569 (1 << 6) | /* first/second field flag 0 -- field 2, 1 -- field 1 */
570 (1 << 5) | /* frame change flag 0 -- same picture as before, 1 -- different */
571 (1 << 4) | /* 1 - interlaced, 0 - noninterlaced */
572 0xc; /* reserved -- always b1100 */
573 buf[4] = 0xff; /* reserved -- always 1 */
576 buf[1] = buf[2] = buf[3] = buf[4] = 0xff;
581 static inline int dv_write_dif_id(enum dv_section_type t, uint8_t chan_num,
582 uint8_t seq_num, uint8_t dif_num,
585 buf[0] = (uint8_t)t; /* Section type */
586 buf[1] = (seq_num << 4) | /* DIF seq number 0-9 for 525/60; 0-11 for 625/50 */
587 (chan_num << 3) | /* FSC: for 50Mb/s 0 - first channel; 1 - second */
588 7; /* reserved -- always 1 */
589 buf[2] = dif_num; /* DIF block number Video: 0-134, Audio: 0-8 */
594 static inline int dv_write_ssyb_id(uint8_t syb_num, uint8_t fr, uint8_t* buf)
596 if (syb_num == 0 || syb_num == 6) {
597 buf[0] = (fr << 7) | /* FR ID 1 - first half of each channel; 0 - second */
598 (0 << 4) | /* AP3 (Subcode application ID) */
599 0x0f; /* reserved -- always 1 */
601 else if (syb_num == 11) {
602 buf[0] = (fr << 7) | /* FR ID 1 - first half of each channel; 0 - second */
603 0x7f; /* reserved -- always 1 */
606 buf[0] = (fr << 7) | /* FR ID 1 - first half of each channel; 0 - second */
607 (0 << 4) | /* APT (Track application ID) */
608 0x0f; /* reserved -- always 1 */
610 buf[1] = 0xf0 | /* reserved -- always 1 */
611 (syb_num & 0x0f); /* SSYB number 0 - 11 */
612 buf[2] = 0xff; /* reserved -- always 1 */
616 static void dv_format_frame(DVVideoContext* c, uint8_t* buf)
620 for (chan = 0; chan < c->sys->n_difchan; chan++) {
621 for (i = 0; i < c->sys->difseg_size; i++) {
622 memset(buf, 0xff, 80 * 6); /* first 6 DIF blocks are for control data */
624 /* DV header: 1DIF */
625 buf += dv_write_dif_id(dv_sect_header, chan, i, 0, buf);
626 buf += dv_write_pack((c->sys->dsf ? dv_header625 : dv_header525), c, buf);
627 buf += 72; /* unused bytes */
629 /* DV subcode: 2DIFs */
630 for (j = 0; j < 2; j++) {
631 buf += dv_write_dif_id(dv_sect_subcode, chan, i, j, buf);
632 for (k = 0; k < 6; k++)
633 buf += dv_write_ssyb_id(k, (i < c->sys->difseg_size/2), buf) + 5;
634 buf += 29; /* unused bytes */
638 for (j = 0; j < 3; j++) {
639 buf += dv_write_dif_id(dv_sect_vaux, chan, i, j, buf);
640 buf += dv_write_pack(dv_video_source, c, buf);
641 buf += dv_write_pack(dv_video_control, c, buf);
643 buf += dv_write_pack(dv_video_source, c, buf);
644 buf += dv_write_pack(dv_video_control, c, buf);
645 buf += 4*5 + 2; /* unused bytes */
648 /* DV Audio/Video: 135 Video DIFs + 9 Audio DIFs */
649 for (j = 0; j < 135; j++) {
651 memset(buf, 0xff, 80);
652 buf += dv_write_dif_id(dv_sect_audio, chan, i, j/15, buf);
653 buf += 77; /* audio control & shuffled PCM audio */
655 buf += dv_write_dif_id(dv_sect_video, chan, i, j, buf);
656 buf += 77; /* 1 video macroblock: 1 bytes control
657 4 * 14 bytes Y 8x8 data
659 10 bytes Cb 8x8 data */
666 static int dvvideo_encode_frame(AVCodecContext *c, AVPacket *pkt,
667 const AVFrame *frame, int *got_packet)
669 DVVideoContext *s = c->priv_data;
672 if ((ret = ff_alloc_packet(pkt, s->sys->frame_size)) < 0) {
673 av_log(c, AV_LOG_ERROR, "Error getting output packet.\n");
677 c->pix_fmt = s->sys->pix_fmt;
679 c->coded_frame->key_frame = 1;
680 c->coded_frame->pict_type = AV_PICTURE_TYPE_I;
683 c->execute(c, dv_encode_video_segment, s->work_chunks, NULL,
684 dv_work_pool_size(s->sys), sizeof(DVwork_chunk));
688 dv_format_frame(s, pkt->data);
690 pkt->flags |= AV_PKT_FLAG_KEY;
696 static int dvvideo_encode_close(AVCodecContext *avctx)
698 av_frame_free(&avctx->coded_frame);
702 AVCodec ff_dvvideo_encoder = {
704 .long_name = NULL_IF_CONFIG_SMALL("DV (Digital Video)"),
705 .type = AVMEDIA_TYPE_VIDEO,
706 .id = AV_CODEC_ID_DVVIDEO,
707 .priv_data_size = sizeof(DVVideoContext),
708 .init = dvvideo_encode_init,
709 .encode2 = dvvideo_encode_frame,
710 .close = dvvideo_encode_close,
711 .capabilities = CODEC_CAP_SLICE_THREADS,
712 .pix_fmts = (const enum AVPixelFormat[]) {
713 AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE