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 "dv_tablegen.h"
36 static av_cold int dvvideo_init_encoder(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);
45 if (avctx->height > 576) {
46 av_log(avctx, AV_LOG_ERROR, "DVCPRO HD encoding is not supported.\n");
47 return AVERROR_PATCHWELCOME;
50 avctx->coded_frame = av_frame_alloc();
51 if (!avctx->coded_frame)
52 return AVERROR(ENOMEM);
54 dv_vlc_map_tableinit();
56 return ff_dvvideo_init(avctx);
59 /* bit budget for AC only in 5 MBs */
60 static const int vs_total_ac_bits = (100 * 4 + 68*2) * 5;
61 static const int mb_area_start[5] = { 1, 6, 21, 43, 64 };
64 /* Converts run and level (where level != 0) pair into VLC, returning bit size */
65 static av_always_inline int dv_rl2vlc(int run, int level, int sign, uint32_t* vlc)
68 if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {
69 *vlc = dv_vlc_map[run][level].vlc | sign;
70 size = dv_vlc_map[run][level].size;
73 if (level < DV_VLC_MAP_LEV_SIZE) {
74 *vlc = dv_vlc_map[0][level].vlc | sign;
75 size = dv_vlc_map[0][level].size;
77 *vlc = 0xfe00 | (level << 1) | sign;
81 *vlc |= ((run < 16) ? dv_vlc_map[run-1][0].vlc :
82 (0x1f80 | (run - 1))) << size;
83 size += (run < 16) ? dv_vlc_map[run-1][0].size : 13;
90 static av_always_inline int dv_rl2vlc_size(int run, int level)
94 if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {
95 size = dv_vlc_map[run][level].size;
98 size = (level < DV_VLC_MAP_LEV_SIZE) ? dv_vlc_map[0][level].size : 16;
100 size += (run < 16) ? dv_vlc_map[run-1][0].size : 13;
106 static av_always_inline int dv_rl2vlc(int run, int l, int sign, uint32_t* vlc)
108 *vlc = dv_vlc_map[run][l].vlc | sign;
109 return dv_vlc_map[run][l].size;
112 static av_always_inline int dv_rl2vlc_size(int run, int l)
114 return dv_vlc_map[run][l].size;
118 typedef struct EncBlockInfo {
128 uint8_t partial_bit_count;
129 uint32_t partial_bit_buffer; /* we can't use uint16_t here */
132 static av_always_inline PutBitContext* dv_encode_ac(EncBlockInfo* bi,
133 PutBitContext* pb_pool,
134 PutBitContext* pb_end)
137 PutBitContext* pb = pb_pool;
138 int size = bi->partial_bit_count;
139 uint32_t vlc = bi->partial_bit_buffer;
141 bi->partial_bit_count = bi->partial_bit_buffer = 0;
143 /* Find suitable storage space */
144 for (; size > (bits_left = put_bits_left(pb)); pb++) {
147 put_bits(pb, bits_left, vlc >> size);
148 vlc = vlc & ((1 << size) - 1);
150 if (pb + 1 >= pb_end) {
151 bi->partial_bit_count = size;
152 bi->partial_bit_buffer = vlc;
158 put_bits(pb, size, vlc);
160 if (bi->cur_ac >= 64)
163 /* Construct the next VLC */
165 bi->cur_ac = bi->next[prev];
166 if (bi->cur_ac < 64){
167 size = dv_rl2vlc(bi->cur_ac - prev - 1, bi->mb[bi->cur_ac], bi->sign[bi->cur_ac], &vlc);
169 size = 4; vlc = 6; /* End Of Block stamp */
175 static av_always_inline int dv_guess_dct_mode(DVVideoContext *s, uint8_t *data, int linesize) {
176 if (s->avctx->flags & CODEC_FLAG_INTERLACED_DCT) {
177 int ps = s->ildct_cmp(NULL, data, NULL, linesize, 8) - 400;
179 int is = s->ildct_cmp(NULL, data , NULL, linesize<<1, 4) +
180 s->ildct_cmp(NULL, data + linesize, NULL, linesize<<1, 4);
188 static const int dv_weight_bits = 18;
189 static const int dv_weight_88[64] = {
190 131072, 257107, 257107, 242189, 252167, 242189, 235923, 237536,
191 237536, 235923, 229376, 231390, 223754, 231390, 229376, 222935,
192 224969, 217965, 217965, 224969, 222935, 200636, 218652, 211916,
193 212325, 211916, 218652, 200636, 188995, 196781, 205965, 206433,
194 206433, 205965, 196781, 188995, 185364, 185364, 200636, 200704,
195 200636, 185364, 185364, 174609, 180568, 195068, 195068, 180568,
196 174609, 170091, 175557, 189591, 175557, 170091, 165371, 170627,
197 170627, 165371, 160727, 153560, 160727, 144651, 144651, 136258,
199 static const int dv_weight_248[64] = {
200 131072, 242189, 257107, 237536, 229376, 200636, 242189, 223754,
201 224969, 196781, 262144, 242189, 229376, 200636, 257107, 237536,
202 211916, 185364, 235923, 217965, 229376, 211916, 206433, 180568,
203 242189, 223754, 224969, 196781, 211916, 185364, 235923, 217965,
204 200704, 175557, 222935, 205965, 200636, 185364, 195068, 170627,
205 229376, 211916, 206433, 180568, 200704, 175557, 222935, 205965,
206 175557, 153560, 188995, 174609, 165371, 144651, 200636, 185364,
207 195068, 170627, 175557, 153560, 188995, 174609, 165371, 144651,
210 static av_always_inline int dv_init_enc_block(EncBlockInfo* bi, uint8_t *data, int linesize, DVVideoContext *s, int bias)
213 const uint8_t* zigzag_scan;
214 LOCAL_ALIGNED_16(int16_t, blk, [64]);
216 /* We offer two different methods for class number assignment: the
217 method suggested in SMPTE 314M Table 22, and an improved
218 method. The SMPTE method is very conservative; it assigns class
219 3 (i.e. severe quantization) to any block where the largest AC
220 component is greater than 36. FFmpeg's DV encoder tracks AC bit
221 consumption precisely, so there is no need to bias most blocks
222 towards strongly lossy compression. Instead, we assign class 2
223 to most blocks, and use class 3 only when strictly necessary
224 (for blocks whose largest AC component exceeds 255). */
226 #if 0 /* SMPTE spec method */
227 static const int classes[] = {12, 24, 36, 0xffff};
228 #else /* improved FFmpeg method */
229 static const int classes[] = {-1, -1, 255, 0xffff};
231 int max = classes[0];
234 av_assert2((((int)blk) & 15) == 0);
236 bi->area_q[0] = bi->area_q[1] = bi->area_q[2] = bi->area_q[3] = 0;
237 bi->partial_bit_count = 0;
238 bi->partial_bit_buffer = 0;
241 bi->dct_mode = dv_guess_dct_mode(s, data, linesize);
242 s->get_pixels(blk, data, linesize);
243 s->fdct[bi->dct_mode](blk);
245 /* We rely on the fact that encoding all zeros leads to an immediate EOB,
246 which is precisely what the spec calls for in the "dummy" blocks. */
247 memset(blk, 0, 64*sizeof(*blk));
252 zigzag_scan = bi->dct_mode ? ff_zigzag248_direct : ff_zigzag_direct;
253 weight = bi->dct_mode ? dv_weight_248 : dv_weight_88;
255 for (area = 0; area < 4; area++) {
256 bi->prev[area] = prev;
257 bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
258 for (i = mb_area_start[area]; i < mb_area_start[area+1]; i++) {
259 int level = blk[zigzag_scan[i]];
261 if (level + 15 > 30U) {
262 bi->sign[i] = (level >> 31) & 1;
263 /* weight it and shift down into range, adding for rounding */
264 /* the extra division by a factor of 2^4 reverses the 8x expansion of the DCT
265 AND the 2x doubling of the weights */
266 level = (FFABS(level) * weight[i] + (1 << (dv_weight_bits+3))) >> (dv_weight_bits+4);
270 bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, level);
277 for (bi->cno = 0; max > classes[bi->cno]; bi->cno++);
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+1]; i = bi->next[i]) {
292 bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, bi->mb[i]);
301 return bi->bit_size[0] + bi->bit_size[1] + bi->bit_size[2] + bi->bit_size[3];
304 static inline void dv_guess_qnos(EncBlockInfo* blks, int* qnos)
307 int i, j, k, a, prev, a2;
310 size[0] = size[1] = size[2] = size[3] = size[4] = 1 << 24;
313 for (i = 0; i < 5; i++) {
319 for (j = 0; j < 6; j++, b++) {
320 for (a = 0; a < 4; a++) {
321 if (b->area_q[a] != ff_dv_quant_shifts[qnos[i] + ff_dv_quant_offset[b->cno]][a]) {
322 b->bit_size[a] = 1; // 4 areas 4 bits for EOB :)
325 av_assert2(b->next[prev] >= mb_area_start[a+1] || b->mb[prev]);
326 for (k = b->next[prev] ; k < mb_area_start[a+1]; k = b->next[k]) {
329 b->bit_size[a] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
332 if (b->next[k] >= mb_area_start[a+1] && b->next[k]<64){
333 for (a2 = a + 1; b->next[k] >= mb_area_start[a2+1]; a2++)
336 av_assert2(b->mb[b->next[k]]);
337 b->bit_size[a2] += dv_rl2vlc_size(b->next[k] - prev - 1, b->mb[b->next[k]])
338 -dv_rl2vlc_size(b->next[k] - k - 1, b->mb[b->next[k]]);
339 av_assert2(b->prev[a2] == k && (a2 + 1 >= 4 || b->prev[a2+1] != k));
342 b->next[prev] = b->next[k];
347 size[i] += b->bit_size[a];
350 if (vs_total_ac_bits >= size[0] + size[1] + size[2] + size[3] + size[4])
353 } while (qnos[0]|qnos[1]|qnos[2]|qnos[3]|qnos[4]);
356 for (a = 2; a == 2 || vs_total_ac_bits < size[0]; a += a){
358 size[0] = 5 * 6 * 4; //EOB
359 for (j = 0; j < 6 *5; j++, b++) {
361 for (k = b->next[prev]; k < 64; k = b->next[k]) {
362 if (b->mb[k] < a && b->mb[k] > -a){
363 b->next[prev] = b->next[k];
365 size[0] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
373 static int dv_encode_video_segment(AVCodecContext *avctx, void *arg)
375 DVVideoContext *s = avctx->priv_data;
376 DVwork_chunk *work_chunk = arg;
378 int mb_x, mb_y, c_offset, linesize, y_stride;
381 LOCAL_ALIGNED_8(uint8_t, scratch, [128]);
382 EncBlockInfo enc_blks[5*DV_MAX_BPM];
383 PutBitContext pbs[5*DV_MAX_BPM];
385 EncBlockInfo* enc_blk;
387 int qnos[5] = {15, 15, 15, 15, 15}; /* No quantization */
388 int* qnosp = &qnos[0];
390 dif = &s->buf[work_chunk->buf_offset*80];
391 enc_blk = &enc_blks[0];
392 for (mb_index = 0; mb_index < 5; mb_index++) {
393 dv_calculate_mb_xy(s, work_chunk, mb_index, &mb_x, &mb_y);
395 /* initializing luminance blocks */
396 if ((s->sys->pix_fmt == AV_PIX_FMT_YUV420P) ||
397 (s->sys->pix_fmt == AV_PIX_FMT_YUV411P && mb_x >= (704 / 8)) ||
398 (s->sys->height >= 720 && mb_y != 134)) {
399 y_stride = s->frame->linesize[0] << 3;
403 y_ptr = s->frame->data[0] + ((mb_y * s->frame->linesize[0] + mb_x) << 3);
404 linesize = s->frame->linesize[0];
406 if (s->sys->video_stype == 4) { /* SD 422 */
408 dv_init_enc_block(enc_blk+0, y_ptr , linesize, s, 0) +
409 dv_init_enc_block(enc_blk+1, NULL , linesize, s, 0) +
410 dv_init_enc_block(enc_blk+2, y_ptr + 8 , linesize, s, 0) +
411 dv_init_enc_block(enc_blk+3, NULL , linesize, s, 0);
414 dv_init_enc_block(enc_blk+0, y_ptr , linesize, s, 0) +
415 dv_init_enc_block(enc_blk+1, y_ptr + 8 , linesize, s, 0) +
416 dv_init_enc_block(enc_blk+2, y_ptr + y_stride, linesize, s, 0) +
417 dv_init_enc_block(enc_blk+3, y_ptr + 8 + y_stride, linesize, s, 0);
421 /* initializing chrominance blocks */
422 c_offset = (((mb_y >> (s->sys->pix_fmt == AV_PIX_FMT_YUV420P)) * s->frame->linesize[1] +
423 (mb_x >> ((s->sys->pix_fmt == AV_PIX_FMT_YUV411P) ? 2 : 1))) << 3);
424 for (j = 2; j; j--) {
425 uint8_t *c_ptr = s->frame->data[j] + c_offset;
426 linesize = s->frame->linesize[j];
427 y_stride = (mb_y == 134) ? 8 : (s->frame->linesize[j] << 3);
428 if (s->sys->pix_fmt == AV_PIX_FMT_YUV411P && mb_x >= (704 / 8)) {
430 uint8_t* b = scratch;
431 for (i = 0; i < 8; i++) {
432 d = c_ptr + (linesize << 3);
433 b[0] = c_ptr[0]; b[1] = c_ptr[1]; b[2] = c_ptr[2]; b[3] = c_ptr[3];
434 b[4] = d[0]; b[5] = d[1]; b[6] = d[2]; b[7] = d[3];
442 vs_bit_size += dv_init_enc_block( enc_blk++, c_ptr , linesize, s, 1);
443 if (s->sys->bpm == 8) {
444 vs_bit_size += dv_init_enc_block(enc_blk++, c_ptr + y_stride, linesize, s, 1);
449 if (vs_total_ac_bits < vs_bit_size)
450 dv_guess_qnos(&enc_blks[0], qnosp);
452 /* DIF encoding process */
453 for (j=0; j<5*s->sys->bpm;) {
459 /* First pass over individual cells only */
460 for (i=0; i<s->sys->bpm; i++, j++) {
461 int sz = s->sys->block_sizes[i]>>3;
463 init_put_bits(&pbs[j], dif, sz);
464 put_sbits(&pbs[j], 9, ((enc_blks[j].mb[0] >> 3) - 1024 + 2) >> 2);
465 put_bits(&pbs[j], 1, enc_blks[j].dct_mode);
466 put_bits(&pbs[j], 2, enc_blks[j].cno);
468 dv_encode_ac(&enc_blks[j], &pbs[j], &pbs[j+1]);
472 /* Second pass over each MB space */
474 for (i=0; i<s->sys->bpm; i++) {
475 if (enc_blks[start_mb+i].partial_bit_count)
476 pb = dv_encode_ac(&enc_blks[start_mb+i], pb, &pbs[start_mb+s->sys->bpm]);
480 /* Third and final pass over the whole video segment space */
482 for (j=0; j<5*s->sys->bpm; j++) {
483 if (enc_blks[j].partial_bit_count)
484 pb = dv_encode_ac(&enc_blks[j], pb, &pbs[s->sys->bpm*5]);
485 if (enc_blks[j].partial_bit_count)
486 av_log(avctx, AV_LOG_ERROR, "ac bitstream overflow\n");
489 for (j=0; j<5*s->sys->bpm; j++) {
491 int size = pbs[j].size_in_bits >> 3;
492 flush_put_bits(&pbs[j]);
493 pos = put_bits_count(&pbs[j]) >> 3;
495 av_log(avctx, AV_LOG_ERROR, "bitstream written beyond buffer size\n");
498 memset(pbs[j].buf + pos, 0xff, size - pos);
504 static inline int dv_write_pack(enum dv_pack_type pack_id, DVVideoContext *c,
508 * Here's what SMPTE314M says about these two:
509 * (page 6) APTn, AP1n, AP2n, AP3n: These data shall be identical
510 * as track application IDs (APTn = 001, AP1n =
511 * 001, AP2n = 001, AP3n = 001), if the source signal
512 * comes from a digital VCR. If the signal source is
513 * unknown, all bits for these data shall be set to 1.
514 * (page 12) STYPE: STYPE defines a signal type of video signal
515 * 00000b = 4:1:1 compression
516 * 00100b = 4:2:2 compression
518 * Now, I've got two problems with these statements:
519 * 1. it looks like APT == 111b should be a safe bet, but it isn't.
520 * It seems that for PAL as defined in IEC 61834 we have to set
521 * APT to 000 and for SMPTE314M to 001.
522 * 2. It is not at all clear what STYPE is used for 4:2:0 PAL
523 * compression scheme (if any).
525 int apt = (c->sys->pix_fmt == AV_PIX_FMT_YUV420P ? 0 : 1);
526 int fs = c->frame->top_field_first ? 0x00 : 0x40;
529 if ((int)(av_q2d(c->avctx->sample_aspect_ratio) * c->avctx->width / c->avctx->height * 10) >= 17) /* 16:9 */
532 buf[0] = (uint8_t)pack_id;
534 case dv_header525: /* I can't imagine why these two weren't defined as real */
535 case dv_header625: /* packs in SMPTE314M -- they definitely look like ones */
536 buf[1] = 0xf8 | /* reserved -- always 1 */
537 (apt & 0x07); /* APT: Track application ID */
538 buf[2] = (0 << 7) | /* TF1: audio data is 0 - valid; 1 - invalid */
539 (0x0f << 3) | /* reserved -- always 1 */
540 (apt & 0x07); /* AP1: Audio application ID */
541 buf[3] = (0 << 7) | /* TF2: video data is 0 - valid; 1 - invalid */
542 (0x0f << 3) | /* reserved -- always 1 */
543 (apt & 0x07); /* AP2: Video application ID */
544 buf[4] = (0 << 7) | /* TF3: subcode(SSYB) is 0 - valid; 1 - invalid */
545 (0x0f << 3) | /* reserved -- always 1 */
546 (apt & 0x07); /* AP3: Subcode application ID */
548 case dv_video_source:
549 buf[1] = 0xff; /* reserved -- always 1 */
550 buf[2] = (1 << 7) | /* B/W: 0 - b/w, 1 - color */
551 (1 << 6) | /* following CLF is valid - 0, invalid - 1 */
552 (3 << 4) | /* CLF: color frames ID (see ITU-R BT.470-4) */
553 0xf; /* reserved -- always 1 */
554 buf[3] = (3 << 6) | /* reserved -- always 1 */
555 (c->sys->dsf << 5) | /* system: 60fields/50fields */
556 c->sys->video_stype; /* signal type video compression */
557 buf[4] = 0xff; /* VISC: 0xff -- no information */
559 case dv_video_control:
560 buf[1] = (0 << 6) | /* Copy generation management (CGMS) 0 -- free */
561 0x3f; /* reserved -- always 1 */
562 buf[2] = 0xc8 | /* reserved -- always b11001xxx */
564 buf[3] = (1 << 7) | /* frame/field flag 1 -- frame, 0 -- field */
565 fs | /* first/second field flag 0 -- field 2, 1 -- field 1 */
566 (1 << 5) | /* frame change flag 0 -- same picture as before, 1 -- different */
567 (1 << 4) | /* 1 - interlaced, 0 - noninterlaced */
568 0xc; /* reserved -- always b1100 */
569 buf[4] = 0xff; /* reserved -- always 1 */
572 buf[1] = buf[2] = buf[3] = buf[4] = 0xff;
577 static inline int dv_write_dif_id(enum dv_section_type t, uint8_t chan_num,
578 uint8_t seq_num, uint8_t dif_num,
581 buf[0] = (uint8_t)t; /* Section type */
582 buf[1] = (seq_num << 4) | /* DIF seq number 0-9 for 525/60; 0-11 for 625/50 */
583 (chan_num << 3) | /* FSC: for 50Mb/s 0 - first channel; 1 - second */
584 7; /* reserved -- always 1 */
585 buf[2] = dif_num; /* DIF block number Video: 0-134, Audio: 0-8 */
590 static inline int dv_write_ssyb_id(uint8_t syb_num, uint8_t fr, uint8_t* buf)
592 if (syb_num == 0 || syb_num == 6) {
593 buf[0] = (fr << 7) | /* FR ID 1 - first half of each channel; 0 - second */
594 (0 << 4) | /* AP3 (Subcode application ID) */
595 0x0f; /* reserved -- always 1 */
597 else if (syb_num == 11) {
598 buf[0] = (fr << 7) | /* FR ID 1 - first half of each channel; 0 - second */
599 0x7f; /* reserved -- always 1 */
602 buf[0] = (fr << 7) | /* FR ID 1 - first half of each channel; 0 - second */
603 (0 << 4) | /* APT (Track application ID) */
604 0x0f; /* reserved -- always 1 */
606 buf[1] = 0xf0 | /* reserved -- always 1 */
607 (syb_num & 0x0f); /* SSYB number 0 - 11 */
608 buf[2] = 0xff; /* reserved -- always 1 */
612 static void dv_format_frame(DVVideoContext* c, uint8_t* buf)
616 for (chan = 0; chan < c->sys->n_difchan; chan++) {
617 for (i = 0; i < c->sys->difseg_size; i++) {
618 memset(buf, 0xff, 80 * 6); /* first 6 DIF blocks are for control data */
620 /* DV header: 1DIF */
621 buf += dv_write_dif_id(dv_sect_header, chan, i, 0, buf);
622 buf += dv_write_pack((c->sys->dsf ? dv_header625 : dv_header525), c, buf);
623 buf += 72; /* unused bytes */
625 /* DV subcode: 2DIFs */
626 for (j = 0; j < 2; j++) {
627 buf += dv_write_dif_id(dv_sect_subcode, chan, i, j, buf);
628 for (k = 0; k < 6; k++)
629 buf += dv_write_ssyb_id(k, (i < c->sys->difseg_size/2), buf) + 5;
630 buf += 29; /* unused bytes */
634 for (j = 0; j < 3; j++) {
635 buf += dv_write_dif_id(dv_sect_vaux, chan, i, j, buf);
636 buf += dv_write_pack(dv_video_source, c, buf);
637 buf += dv_write_pack(dv_video_control, c, buf);
639 buf += dv_write_pack(dv_video_source, c, buf);
640 buf += dv_write_pack(dv_video_control, c, buf);
641 buf += 4*5 + 2; /* unused bytes */
644 /* DV Audio/Video: 135 Video DIFs + 9 Audio DIFs */
645 for (j = 0; j < 135; j++) {
647 memset(buf, 0xff, 80);
648 buf += dv_write_dif_id(dv_sect_audio, chan, i, j/15, buf);
649 buf += 77; /* audio control & shuffled PCM audio */
651 buf += dv_write_dif_id(dv_sect_video, chan, i, j, buf);
652 buf += 77; /* 1 video macroblock: 1 bytes control
653 4 * 14 bytes Y 8x8 data
655 10 bytes Cb 8x8 data */
662 static int dvvideo_encode_frame(AVCodecContext *c, AVPacket *pkt,
663 const AVFrame *frame, int *got_packet)
665 DVVideoContext *s = c->priv_data;
668 s->sys = avpriv_dv_codec_profile(c);
669 if (!s->sys || ff_dv_init_dynamic_tables(s->sys))
671 if ((ret = ff_alloc_packet2(c, pkt, s->sys->frame_size)) < 0)
674 c->pix_fmt = s->sys->pix_fmt;
676 c->coded_frame->key_frame = 1;
677 c->coded_frame->pict_type = AV_PICTURE_TYPE_I;
680 c->execute(c, dv_encode_video_segment, s->sys->work_chunks, NULL,
681 dv_work_pool_size(s->sys), sizeof(DVwork_chunk));
685 dv_format_frame(s, pkt->data);
687 pkt->flags |= AV_PKT_FLAG_KEY;
693 static int dvvideo_encode_close(AVCodecContext *avctx)
695 av_frame_free(&avctx->coded_frame);
699 AVCodec ff_dvvideo_encoder = {
701 .long_name = NULL_IF_CONFIG_SMALL("DV (Digital Video)"),
702 .type = AVMEDIA_TYPE_VIDEO,
703 .id = AV_CODEC_ID_DVVIDEO,
704 .priv_data_size = sizeof(DVVideoContext),
705 .init = dvvideo_init_encoder,
706 .encode2 = dvvideo_encode_frame,
707 .close = dvvideo_encode_close,
708 .capabilities = CODEC_CAP_SLICE_THREADS,
709 .pix_fmts = (const enum AVPixelFormat[]) {
710 AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE