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
29 #include "libavutil/attributes.h"
30 #include "libavutil/pixdesc.h"
34 #include "dv_profile_internal.h"
35 #include "dv_tablegen.h"
39 #include "pixblockdsp.h"
42 static av_cold
int dvvideo_encode_init(AVCodecContext
*avctx
)
44 DVVideoContext
*s
= avctx
->priv_data
;
47 PixblockDSPContext pdsp
;
50 s
->sys
= av_dv_codec_profile(avctx
->width
, avctx
->height
, avctx
->pix_fmt
);
52 av_log(avctx
, AV_LOG_ERROR
, "Found no DV profile for %ix%i %s video. "
53 "Valid DV profiles are:\n",
54 avctx
->width
, avctx
->height
, av_get_pix_fmt_name(avctx
->pix_fmt
));
55 ff_dv_print_profiles(avctx
, AV_LOG_ERROR
);
56 return AVERROR(EINVAL
);
58 if (avctx
->height
> 576) {
59 av_log(avctx
, AV_LOG_ERROR
, "DVCPRO HD encoding is not supported.\n");
60 return AVERROR_PATCHWELCOME
;
62 ret
= ff_dv_init_dynamic_tables(s
, s
->sys
);
64 av_log(avctx
, AV_LOG_ERROR
, "Error initializing work tables.\n");
68 avctx
->coded_frame
= av_frame_alloc();
69 if (!avctx
->coded_frame
)
70 return AVERROR(ENOMEM
);
72 dv_vlc_map_tableinit();
74 memset(&fdsp
,0, sizeof(fdsp
));
75 memset(&mecc
,0, sizeof(mecc
));
76 memset(&pdsp
,0, sizeof(pdsp
));
77 ff_fdctdsp_init(&fdsp
, avctx
);
78 ff_me_cmp_init(&mecc
, avctx
);
79 ff_pixblockdsp_init(&pdsp
, avctx
);
80 ff_set_cmp(&mecc
, mecc
.ildct_cmp
, avctx
->ildct_cmp
);
82 s
->get_pixels
= pdsp
.get_pixels
;
83 s
->ildct_cmp
= mecc
.ildct_cmp
[5];
85 s
->fdct
[0] = fdsp
.fdct
;
86 s
->fdct
[1] = fdsp
.fdct248
;
88 return ff_dvvideo_init(avctx
);
91 /* bit budget for AC only in 5 MBs */
92 static const int vs_total_ac_bits
= (100 * 4 + 68 * 2) * 5;
93 static const int mb_area_start
[5] = { 1, 6, 21, 43, 64 };
96 /* Convert run and level (where level != 0) pair into VLC, returning bit size */
97 static av_always_inline
int dv_rl2vlc(int run
, int level
, int sign
,
101 if (run
< DV_VLC_MAP_RUN_SIZE
&& level
< DV_VLC_MAP_LEV_SIZE
) {
102 *vlc
= dv_vlc_map
[run
][level
].vlc
| sign
;
103 size
= dv_vlc_map
[run
][level
].size
;
105 if (level
< DV_VLC_MAP_LEV_SIZE
) {
106 *vlc
= dv_vlc_map
[0][level
].vlc
| sign
;
107 size
= dv_vlc_map
[0][level
].size
;
109 *vlc
= 0xfe00 | (level
<< 1) | sign
;
113 *vlc
|= ((run
< 16) ? dv_vlc_map
[run
- 1][0].vlc
:
114 (0x1f80 | (run
- 1))) << size
;
115 size
+= (run
< 16) ? dv_vlc_map
[run
- 1][0].size
: 13;
122 static av_always_inline
int dv_rl2vlc_size(int run
, int level
)
126 if (run
< DV_VLC_MAP_RUN_SIZE
&& level
< DV_VLC_MAP_LEV_SIZE
) {
127 size
= dv_vlc_map
[run
][level
].size
;
129 size
= (level
< DV_VLC_MAP_LEV_SIZE
) ? dv_vlc_map
[0][level
].size
: 16;
131 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
=
172 bi
->partial_bit_buffer
= 0;
174 /* Find suitable storage space */
175 for (; size
> (bits_left
= put_bits_left(pb
)); pb
++) {
178 put_bits(pb
, bits_left
, vlc
>> size
);
179 vlc
= vlc
& ((1 << size
) - 1);
181 if (pb
+ 1 >= pb_end
) {
182 bi
->partial_bit_count
= size
;
183 bi
->partial_bit_buffer
= vlc
;
189 put_bits(pb
, size
, vlc
);
191 if (bi
->cur_ac
>= 64)
194 /* Construct the next VLC */
196 bi
->cur_ac
= bi
->next
[prev
];
197 if (bi
->cur_ac
< 64) {
198 size
= dv_rl2vlc(bi
->cur_ac
- prev
- 1, bi
->mb
[bi
->cur_ac
],
199 bi
->sign
[bi
->cur_ac
], &vlc
);
202 vlc
= 6; /* End Of Block stamp */
208 static av_always_inline
int dv_guess_dct_mode(DVVideoContext
*s
, uint8_t *data
,
211 if (s
->avctx
->flags
& CODEC_FLAG_INTERLACED_DCT
) {
212 int ps
= s
->ildct_cmp(NULL
, data
, NULL
, linesize
, 8) - 400;
214 int is
= s
->ildct_cmp(NULL
, data
, NULL
, linesize
<< 1, 4) +
215 s
->ildct_cmp(NULL
, data
+ linesize
, NULL
, linesize
<< 1, 4);
223 static const int dv_weight_bits
= 18;
224 static const int dv_weight_88
[64] = {
225 131072, 257107, 257107, 242189, 252167, 242189, 235923, 237536,
226 237536, 235923, 229376, 231390, 223754, 231390, 229376, 222935,
227 224969, 217965, 217965, 224969, 222935, 200636, 218652, 211916,
228 212325, 211916, 218652, 200636, 188995, 196781, 205965, 206433,
229 206433, 205965, 196781, 188995, 185364, 185364, 200636, 200704,
230 200636, 185364, 185364, 174609, 180568, 195068, 195068, 180568,
231 174609, 170091, 175557, 189591, 175557, 170091, 165371, 170627,
232 170627, 165371, 160727, 153560, 160727, 144651, 144651, 136258,
234 static const int dv_weight_248
[64] = {
235 131072, 242189, 257107, 237536, 229376, 200636, 242189, 223754,
236 224969, 196781, 262144, 242189, 229376, 200636, 257107, 237536,
237 211916, 185364, 235923, 217965, 229376, 211916, 206433, 180568,
238 242189, 223754, 224969, 196781, 211916, 185364, 235923, 217965,
239 200704, 175557, 222935, 205965, 200636, 185364, 195068, 170627,
240 229376, 211916, 206433, 180568, 200704, 175557, 222935, 205965,
241 175557, 153560, 188995, 174609, 165371, 144651, 200636, 185364,
242 195068, 170627, 175557, 153560, 188995, 174609, 165371, 144651,
245 static av_always_inline
int dv_init_enc_block(EncBlockInfo
*bi
, uint8_t *data
,
246 int linesize
, DVVideoContext
*s
,
250 const uint8_t *zigzag_scan
;
251 LOCAL_ALIGNED_16(int16_t, blk
, [64]);
253 /* We offer two different methods for class number assignment: the
254 * method suggested in SMPTE 314M Table 22, and an improved
255 * method. The SMPTE method is very conservative; it assigns class
256 * 3 (i.e. severe quantization) to any block where the largest AC
257 * component is greater than 36. FFmpeg's DV encoder tracks AC bit
258 * consumption precisely, so there is no need to bias most blocks
259 * towards strongly lossy compression. Instead, we assign class 2
260 * to most blocks, and use class 3 only when strictly necessary
261 * (for blocks whose largest AC component exceeds 255). */
263 #if 0 /* SMPTE spec method */
264 static const int classes
[] = { 12, 24, 36, 0xffff };
265 #else /* improved FFmpeg method */
266 static const int classes
[] = { -1, -1, 255, 0xffff };
268 int max
= classes
[0];
271 av_assert2((((int) blk
) & 15) == 0);
277 bi
->partial_bit_count
= 0;
278 bi
->partial_bit_buffer
= 0;
281 bi
->dct_mode
= dv_guess_dct_mode(s
, data
, linesize
);
282 s
->get_pixels(blk
, data
, linesize
);
283 s
->fdct
[bi
->dct_mode
](blk
);
285 /* We rely on the fact that encoding all zeros leads to an immediate
286 * EOB, which is precisely what the spec calls for in the "dummy"
288 memset(blk
, 0, 64 * sizeof(*blk
));
293 zigzag_scan
= bi
->dct_mode
? ff_dv_zigzag248_direct
: ff_zigzag_direct
;
294 weight
= bi
->dct_mode
? dv_weight_248
: dv_weight_88
;
296 for (area
= 0; area
< 4; area
++) {
297 bi
->prev
[area
] = prev
;
298 bi
->bit_size
[area
] = 1; // 4 areas 4 bits for EOB :)
299 for (i
= mb_area_start
[area
]; i
< mb_area_start
[area
+ 1]; i
++) {
300 int level
= blk
[zigzag_scan
[i
]];
302 if (level
+ 15 > 30U) {
303 bi
->sign
[i
] = (level
>> 31) & 1;
304 /* Weight it and shift down into range, adding for rounding.
305 * The extra division by a factor of 2^4 reverses the 8x
306 * expansion of the DCT AND the 2x doubling of the weights. */
307 level
= (FFABS(level
) * weight
[i
] + (1 << (dv_weight_bits
+ 3))) >>
308 (dv_weight_bits
+ 4);
312 bi
->bit_size
[area
] += dv_rl2vlc_size(i
- prev
- 1, level
);
319 for (bi
->cno
= 0; max
> classes
[bi
->cno
]; bi
->cno
++)
328 for (area
= 0; area
< 4; area
++) {
329 bi
->prev
[area
] = prev
;
330 bi
->bit_size
[area
] = 1; // 4 areas 4 bits for EOB :)
331 for (; i
< mb_area_start
[area
+ 1]; i
= bi
->next
[i
]) {
335 bi
->bit_size
[area
] += dv_rl2vlc_size(i
- prev
- 1, bi
->mb
[i
]);
344 return bi
->bit_size
[0] + bi
->bit_size
[1] +
345 bi
->bit_size
[2] + bi
->bit_size
[3];
348 static inline void dv_guess_qnos(EncBlockInfo
*blks
, int *qnos
)
351 int i
, j
, k
, a
, prev
, a2
;
361 for (i
= 0; i
< 5; i
++) {
367 for (j
= 0; j
< 6; j
++, b
++) {
368 for (a
= 0; a
< 4; a
++) {
369 if (b
->area_q
[a
] != ff_dv_quant_shifts
[qnos
[i
] + ff_dv_quant_offset
[b
->cno
]][a
]) {
370 b
->bit_size
[a
] = 1; // 4 areas 4 bits for EOB :)
373 av_assert2(b
->next
[prev
] >= mb_area_start
[a
+ 1] || b
->mb
[prev
]);
374 for (k
= b
->next
[prev
]; k
< mb_area_start
[a
+ 1]; k
= b
->next
[k
]) {
377 b
->bit_size
[a
] += dv_rl2vlc_size(k
- prev
- 1, b
->mb
[k
]);
380 if (b
->next
[k
] >= mb_area_start
[a
+ 1] && b
->next
[k
] < 64) {
381 for (a2
= a
+ 1; b
->next
[k
] >= mb_area_start
[a2
+ 1]; a2
++)
384 av_assert2(b
->mb
[b
->next
[k
]]);
385 b
->bit_size
[a2
] += dv_rl2vlc_size(b
->next
[k
] - prev
- 1, b
->mb
[b
->next
[k
]]) -
386 dv_rl2vlc_size(b
->next
[k
] - k
- 1, b
->mb
[b
->next
[k
]]);
387 av_assert2(b
->prev
[a2
] == k
&& (a2
+ 1 >= 4 || b
->prev
[a2
+ 1] != k
));
390 b
->next
[prev
] = b
->next
[k
];
393 b
->prev
[a
+ 1] = prev
;
395 size
[i
] += b
->bit_size
[a
];
398 if (vs_total_ac_bits
>= size
[0] + size
[1] + size
[2] + size
[3] + size
[4])
401 } while (qnos
[0] | qnos
[1] | qnos
[2] | qnos
[3] | qnos
[4]);
403 for (a
= 2; a
== 2 || vs_total_ac_bits
< size
[0]; a
+= a
) {
405 size
[0] = 5 * 6 * 4; // EOB
406 for (j
= 0; j
< 6 * 5; j
++, b
++) {
408 for (k
= b
->next
[prev
]; k
< 64; k
= b
->next
[k
]) {
409 if (b
->mb
[k
] < a
&& b
->mb
[k
] > -a
) {
410 b
->next
[prev
] = b
->next
[k
];
412 size
[0] += dv_rl2vlc_size(k
- prev
- 1, b
->mb
[k
]);
420 static int dv_encode_video_segment(AVCodecContext
*avctx
, void *arg
)
422 DVVideoContext
*s
= avctx
->priv_data
;
423 DVwork_chunk
*work_chunk
= arg
;
425 int mb_x
, mb_y
, c_offset
, linesize
, y_stride
;
428 LOCAL_ALIGNED_8(uint8_t, scratch
, [128]);
429 EncBlockInfo enc_blks
[5 * DV_MAX_BPM
];
430 PutBitContext pbs
[5 * DV_MAX_BPM
];
432 EncBlockInfo
*enc_blk
;
434 int qnos
[5] = { 15, 15, 15, 15, 15 }; /* No quantization */
435 int *qnosp
= &qnos
[0];
437 dif
= &s
->buf
[work_chunk
->buf_offset
* 80];
438 enc_blk
= &enc_blks
[0];
439 for (mb_index
= 0; mb_index
< 5; mb_index
++) {
440 dv_calculate_mb_xy(s
, work_chunk
, mb_index
, &mb_x
, &mb_y
);
442 /* initializing luminance blocks */
443 if ((s
->sys
->pix_fmt
== AV_PIX_FMT_YUV420P
) ||
444 (s
->sys
->pix_fmt
== AV_PIX_FMT_YUV411P
&& mb_x
>= (704 / 8)) ||
445 (s
->sys
->height
>= 720 && mb_y
!= 134)) {
446 y_stride
= s
->frame
->linesize
[0] << 3;
450 y_ptr
= s
->frame
->data
[0] +
451 ((mb_y
* s
->frame
->linesize
[0] + mb_x
) << 3);
452 linesize
= s
->frame
->linesize
[0];
454 if (s
->sys
->video_stype
== 4) { /* SD 422 */
456 dv_init_enc_block(enc_blk
+ 0, y_ptr
, linesize
, s
, 0) +
457 dv_init_enc_block(enc_blk
+ 1, NULL
, linesize
, s
, 0) +
458 dv_init_enc_block(enc_blk
+ 2, y_ptr
+ 8, linesize
, s
, 0) +
459 dv_init_enc_block(enc_blk
+ 3, NULL
, linesize
, s
, 0);
462 dv_init_enc_block(enc_blk
+ 0, y_ptr
, linesize
, s
, 0) +
463 dv_init_enc_block(enc_blk
+ 1, y_ptr
+ 8, linesize
, s
, 0) +
464 dv_init_enc_block(enc_blk
+ 2, y_ptr
+ y_stride
, linesize
, s
, 0) +
465 dv_init_enc_block(enc_blk
+ 3, y_ptr
+ 8 + y_stride
, linesize
, s
, 0);
469 /* initializing chrominance blocks */
470 c_offset
= (((mb_y
>> (s
->sys
->pix_fmt
== AV_PIX_FMT_YUV420P
)) * s
->frame
->linesize
[1] +
471 (mb_x
>> ((s
->sys
->pix_fmt
== AV_PIX_FMT_YUV411P
) ? 2 : 1))) << 3);
472 for (j
= 2; j
; j
--) {
473 uint8_t *c_ptr
= s
->frame
->data
[j
] + c_offset
;
474 linesize
= s
->frame
->linesize
[j
];
475 y_stride
= (mb_y
== 134) ? 8 : (s
->frame
->linesize
[j
] << 3);
476 if (s
->sys
->pix_fmt
== AV_PIX_FMT_YUV411P
&& mb_x
>= (704 / 8)) {
478 uint8_t *b
= scratch
;
479 for (i
= 0; i
< 8; i
++) {
480 d
= c_ptr
+ (linesize
<< 3);
496 vs_bit_size
+= dv_init_enc_block(enc_blk
++, c_ptr
, linesize
, s
, 1);
497 if (s
->sys
->bpm
== 8)
498 vs_bit_size
+= dv_init_enc_block(enc_blk
++, c_ptr
+ y_stride
,
503 if (vs_total_ac_bits
< vs_bit_size
)
504 dv_guess_qnos(&enc_blks
[0], qnosp
);
506 /* DIF encoding process */
507 for (j
= 0; j
< 5 * s
->sys
->bpm
;) {
513 /* First pass over individual cells only */
514 for (i
= 0; i
< s
->sys
->bpm
; i
++, j
++) {
515 int sz
= s
->sys
->block_sizes
[i
] >> 3;
517 init_put_bits(&pbs
[j
], dif
, sz
);
518 put_sbits(&pbs
[j
], 9, ((enc_blks
[j
].mb
[0] >> 3) - 1024 + 2) >> 2);
519 put_bits(&pbs
[j
], 1, enc_blks
[j
].dct_mode
);
520 put_bits(&pbs
[j
], 2, enc_blks
[j
].cno
);
522 dv_encode_ac(&enc_blks
[j
], &pbs
[j
], &pbs
[j
+ 1]);
526 /* Second pass over each MB space */
528 for (i
= 0; i
< s
->sys
->bpm
; i
++)
529 if (enc_blks
[start_mb
+ i
].partial_bit_count
)
530 pb
= dv_encode_ac(&enc_blks
[start_mb
+ i
], pb
,
531 &pbs
[start_mb
+ s
->sys
->bpm
]);
534 /* Third and final pass over the whole video segment space */
536 for (j
= 0; j
< 5 * s
->sys
->bpm
; j
++) {
537 if (enc_blks
[j
].partial_bit_count
)
538 pb
= dv_encode_ac(&enc_blks
[j
], pb
, &pbs
[s
->sys
->bpm
* 5]);
539 if (enc_blks
[j
].partial_bit_count
)
540 av_log(avctx
, AV_LOG_ERROR
, "ac bitstream overflow\n");
543 for (j
= 0; j
< 5 * s
->sys
->bpm
; j
++) {
545 int size
= pbs
[j
].size_in_bits
>> 3;
546 flush_put_bits(&pbs
[j
]);
547 pos
= put_bits_count(&pbs
[j
]) >> 3;
549 av_log(avctx
, AV_LOG_ERROR
,
550 "bitstream written beyond buffer size\n");
553 memset(pbs
[j
].buf
+ pos
, 0xff, size
- pos
);
559 static inline int dv_write_pack(enum dv_pack_type pack_id
, DVVideoContext
*c
,
563 * Here's what SMPTE314M says about these two:
564 * (page 6) APTn, AP1n, AP2n, AP3n: These data shall be identical
565 * as track application IDs (APTn = 001, AP1n =
566 * 001, AP2n = 001, AP3n = 001), if the source signal
567 * comes from a digital VCR. If the signal source is
568 * unknown, all bits for these data shall be set to 1.
569 * (page 12) STYPE: STYPE defines a signal type of video signal
570 * 00000b = 4:1:1 compression
571 * 00100b = 4:2:2 compression
573 * Now, I've got two problems with these statements:
574 * 1. it looks like APT == 111b should be a safe bet, but it isn't.
575 * It seems that for PAL as defined in IEC 61834 we have to set
576 * APT to 000 and for SMPTE314M to 001.
577 * 2. It is not at all clear what STYPE is used for 4:2:0 PAL
578 * compression scheme (if any).
580 int apt
= (c
->sys
->pix_fmt
== AV_PIX_FMT_YUV420P
? 0 : 1);
581 int fs
= c
->frame
->top_field_first
? 0x00 : 0x40;
584 if ((int) (av_q2d(c
->avctx
->sample_aspect_ratio
) *
585 c
->avctx
->width
/ c
->avctx
->height
* 10) >= 17) /* 16:9 */
588 buf
[0] = (uint8_t) pack_id
;
590 case dv_header525
: /* I can't imagine why these two weren't defined as real */
591 case dv_header625
: /* packs in SMPTE314M -- they definitely look like ones */
592 buf
[1] = 0xf8 | /* reserved -- always 1 */
593 (apt
& 0x07); /* APT: Track application ID */
594 buf
[2] = (0 << 7) | /* TF1: audio data is 0 - valid; 1 - invalid */
595 (0x0f << 3) | /* reserved -- always 1 */
596 (apt
& 0x07); /* AP1: Audio application ID */
597 buf
[3] = (0 << 7) | /* TF2: video data is 0 - valid; 1 - invalid */
598 (0x0f << 3) | /* reserved -- always 1 */
599 (apt
& 0x07); /* AP2: Video application ID */
600 buf
[4] = (0 << 7) | /* TF3: subcode(SSYB) is 0 - valid; 1 - invalid */
601 (0x0f << 3) | /* reserved -- always 1 */
602 (apt
& 0x07); /* AP3: Subcode application ID */
604 case dv_video_source
:
605 buf
[1] = 0xff; /* reserved -- always 1 */
606 buf
[2] = (1 << 7) | /* B/W: 0 - b/w, 1 - color */
607 (1 << 6) | /* following CLF is valid - 0, invalid - 1 */
608 (3 << 4) | /* CLF: color frames ID (see ITU-R BT.470-4) */
609 0xf; /* reserved -- always 1 */
610 buf
[3] = (3 << 6) | /* reserved -- always 1 */
611 (c
->sys
->dsf
<< 5) | /* system: 60fields/50fields */
612 c
->sys
->video_stype
; /* signal type video compression */
613 buf
[4] = 0xff; /* VISC: 0xff -- no information */
615 case dv_video_control
:
616 buf
[1] = (0 << 6) | /* Copy generation management (CGMS) 0 -- free */
617 0x3f; /* reserved -- always 1 */
618 buf
[2] = 0xc8 | /* reserved -- always b11001xxx */
620 buf
[3] = (1 << 7) | /* frame/field flag 1 -- frame, 0 -- field */
621 fs
| /* first/second field flag 0 -- field 2, 1 -- field 1 */
622 (1 << 5) | /* frame change flag 0 -- same picture as before, 1 -- different */
623 (1 << 4) | /* 1 - interlaced, 0 - noninterlaced */
624 0xc; /* reserved -- always b1100 */
625 buf
[4] = 0xff; /* reserved -- always 1 */
636 static inline int dv_write_dif_id(enum dv_section_type t
, uint8_t chan_num
,
637 uint8_t seq_num
, uint8_t dif_num
,
640 buf
[0] = (uint8_t) t
; /* Section type */
641 buf
[1] = (seq_num
<< 4) | /* DIF seq number 0-9 for 525/60; 0-11 for 625/50 */
642 (chan_num
<< 3) | /* FSC: for 50Mb/s 0 - first channel; 1 - second */
643 7; /* reserved -- always 1 */
644 buf
[2] = dif_num
; /* DIF block number Video: 0-134, Audio: 0-8 */
648 static inline int dv_write_ssyb_id(uint8_t syb_num
, uint8_t fr
, uint8_t *buf
)
650 if (syb_num
== 0 || syb_num
== 6) {
651 buf
[0] = (fr
<< 7) | /* FR ID 1 - first half of each channel; 0 - second */
652 (0 << 4) | /* AP3 (Subcode application ID) */
653 0x0f; /* reserved -- always 1 */
654 } else if (syb_num
== 11) {
655 buf
[0] = (fr
<< 7) | /* FR ID 1 - first half of each channel; 0 - second */
656 0x7f; /* reserved -- always 1 */
658 buf
[0] = (fr
<< 7) | /* FR ID 1 - first half of each channel; 0 - second */
659 (0 << 4) | /* APT (Track application ID) */
660 0x0f; /* reserved -- always 1 */
662 buf
[1] = 0xf0 | /* reserved -- always 1 */
663 (syb_num
& 0x0f); /* SSYB number 0 - 11 */
664 buf
[2] = 0xff; /* reserved -- always 1 */
668 static void dv_format_frame(DVVideoContext
*c
, uint8_t *buf
)
672 for (chan
= 0; chan
< c
->sys
->n_difchan
; chan
++) {
673 for (i
= 0; i
< c
->sys
->difseg_size
; i
++) {
674 memset(buf
, 0xff, 80 * 6); /* first 6 DIF blocks are for control data */
676 /* DV header: 1DIF */
677 buf
+= dv_write_dif_id(dv_sect_header
, chan
, i
, 0, buf
);
678 buf
+= dv_write_pack((c
->sys
->dsf
? dv_header625
: dv_header525
),
680 buf
+= 72; /* unused bytes */
682 /* DV subcode: 2DIFs */
683 for (j
= 0; j
< 2; j
++) {
684 buf
+= dv_write_dif_id(dv_sect_subcode
, chan
, i
, j
, buf
);
685 for (k
= 0; k
< 6; k
++)
686 buf
+= dv_write_ssyb_id(k
, (i
< c
->sys
->difseg_size
/ 2), buf
) + 5;
687 buf
+= 29; /* unused bytes */
691 for (j
= 0; j
< 3; j
++) {
692 buf
+= dv_write_dif_id(dv_sect_vaux
, chan
, i
, j
, buf
);
693 buf
+= dv_write_pack(dv_video_source
, c
, buf
);
694 buf
+= dv_write_pack(dv_video_control
, c
, buf
);
696 buf
+= dv_write_pack(dv_video_source
, c
, buf
);
697 buf
+= dv_write_pack(dv_video_control
, c
, buf
);
698 buf
+= 4 * 5 + 2; /* unused bytes */
701 /* DV Audio/Video: 135 Video DIFs + 9 Audio DIFs */
702 for (j
= 0; j
< 135; j
++) {
704 memset(buf
, 0xff, 80);
705 buf
+= dv_write_dif_id(dv_sect_audio
, chan
, i
, j
/ 15, buf
);
706 buf
+= 77; /* audio control & shuffled PCM audio */
708 buf
+= dv_write_dif_id(dv_sect_video
, chan
, i
, j
, buf
);
709 buf
+= 77; /* 1 video macroblock: 1 bytes control
710 * 4 * 14 bytes Y 8x8 data
711 * 10 bytes Cr 8x8 data
712 * 10 bytes Cb 8x8 data */
718 static int dvvideo_encode_frame(AVCodecContext
*c
, AVPacket
*pkt
,
719 const AVFrame
*frame
, int *got_packet
)
721 DVVideoContext
*s
= c
->priv_data
;
724 if ((ret
= ff_alloc_packet2(c
, pkt
, s
->sys
->frame_size
)) < 0)
727 c
->pix_fmt
= s
->sys
->pix_fmt
;
729 c
->coded_frame
->key_frame
= 1;
730 c
->coded_frame
->pict_type
= AV_PICTURE_TYPE_I
;
733 c
->execute(c
, dv_encode_video_segment
, s
->work_chunks
, NULL
,
734 dv_work_pool_size(s
->sys
), sizeof(DVwork_chunk
));
738 dv_format_frame(s
, pkt
->data
);
740 pkt
->flags
|= AV_PKT_FLAG_KEY
;
746 static int dvvideo_encode_close(AVCodecContext
*avctx
)
748 av_frame_free(&avctx
->coded_frame
);
752 AVCodec ff_dvvideo_encoder
= {
754 .long_name
= NULL_IF_CONFIG_SMALL("DV (Digital Video)"),
755 .type
= AVMEDIA_TYPE_VIDEO
,
756 .id
= AV_CODEC_ID_DVVIDEO
,
757 .priv_data_size
= sizeof(DVVideoContext
),
758 .init
= dvvideo_encode_init
,
759 .encode2
= dvvideo_encode_frame
,
760 .close
= dvvideo_encode_close
,
761 .capabilities
= CODEC_CAP_SLICE_THREADS
| CODEC_CAP_FRAME_THREADS
| CODEC_CAP_INTRA_ONLY
,
762 .pix_fmts
= (const enum AVPixelFormat
[]) {
763 AV_PIX_FMT_YUV411P
, AV_PIX_FMT_YUV422P
,
764 AV_PIX_FMT_YUV420P
, AV_PIX_FMT_NONE