3 * Copyright (c) 2002 Fabrice Bellard
4 * Copyright (c) 2004 Roman Shaposhnik
7 * Copyright (c) 2003 Roman Shaposhnik
9 * 50 Mbps (DVCPRO50) support
10 * Copyright (c) 2006 Daniel Maas <dmaas@maasdigital.com>
12 * 100 Mbps (DVCPRO HD) support
13 * Initial code by Daniel Maas <dmaas@maasdigital.com> (funded by BBC R&D)
14 * Final code by Roman Shaposhnik
16 * Many thanks to Dan Dennedy <dan@dennedy.org> for providing wealth
17 * of DV technical info.
19 * This file is part of FFmpeg.
21 * FFmpeg is free software; you can redistribute it and/or
22 * modify it under the terms of the GNU Lesser General Public
23 * License as published by the Free Software Foundation; either
24 * version 2.1 of the License, or (at your option) any later version.
26 * FFmpeg is distributed in the hope that it will be useful,
27 * but WITHOUT ANY WARRANTY; without even the implied warranty of
28 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
29 * Lesser General Public License for more details.
31 * You should have received a copy of the GNU Lesser General Public
32 * License along with FFmpeg; if not, write to the Free Software
33 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
41 #include "libavutil/pixdesc.h"
47 #include "simple_idct.h"
49 #include "dv_tablegen.h"
51 /* XXX: also include quantization */
52 RL_VLC_ELEM ff_dv_rl_vlc[1184];
54 static inline void dv_calc_mb_coordinates(const DVprofile *d, int chan, int seq, int slot,
57 static const uint8_t off[] = { 2, 6, 8, 0, 4 };
58 static const uint8_t shuf1[] = { 36, 18, 54, 0, 72 };
59 static const uint8_t shuf2[] = { 24, 12, 36, 0, 48 };
60 static const uint8_t shuf3[] = { 18, 9, 27, 0, 36 };
62 static const uint8_t l_start[] = {0, 4, 9, 13, 18, 22, 27, 31, 36, 40};
63 static const uint8_t l_start_shuffled[] = { 9, 4, 13, 0, 18 };
65 static const uint8_t serpent1[] = {0, 1, 2, 2, 1, 0,
70 static const uint8_t serpent2[] = {0, 1, 2, 3, 4, 5, 5, 4, 3, 2, 1, 0,
71 0, 1, 2, 3, 4, 5, 5, 4, 3, 2, 1, 0,
74 static const uint8_t remap[][2] = {{ 0, 0}, { 0, 0}, { 0, 0}, { 0, 0}, /* dummy */
75 { 0, 0}, { 0, 1}, { 0, 2}, { 0, 3}, {10, 0},
76 {10, 1}, {10, 2}, {10, 3}, {20, 0}, {20, 1},
77 {20, 2}, {20, 3}, {30, 0}, {30, 1}, {30, 2},
78 {30, 3}, {40, 0}, {40, 1}, {40, 2}, {40, 3},
79 {50, 0}, {50, 1}, {50, 2}, {50, 3}, {60, 0},
80 {60, 1}, {60, 2}, {60, 3}, {70, 0}, {70, 1},
81 {70, 2}, {70, 3}, { 0,64}, { 0,65}, { 0,66},
82 {10,64}, {10,65}, {10,66}, {20,64}, {20,65},
83 {20,66}, {30,64}, {30,65}, {30,66}, {40,64},
84 {40,65}, {40,66}, {50,64}, {50,65}, {50,66},
85 {60,64}, {60,65}, {60,66}, {70,64}, {70,65},
86 {70,66}, { 0,67}, {20,67}, {40,67}, {60,67}};
94 blk = (chan*11+seq)*27+slot;
96 if (chan == 0 && seq == 11) {
105 i = (4*chan + blk + off[m])%11;
108 x = shuf1[m] + (chan&1)*9 + k%9;
109 y = (i*3+k/9)*2 + (chan>>1) + 1;
111 tbl[m] = (x<<1)|(y<<9);
114 blk = (chan*10+seq)*27+slot;
116 i = (4*chan + (seq/5) + 2*blk + off[m])%10;
119 x = shuf1[m]+(chan&1)*9 + k%9;
120 y = (i*3+k/9)*2 + (chan>>1) + 4;
123 x = remap[y][0]+((x-80)<<(y>59));
126 tbl[m] = (x<<1)|(y<<9);
129 blk = (chan*10+seq)*27+slot;
131 i = (4*chan + (seq/5) + 2*blk + off[m])%10;
132 k = (blk/5)%27 + (i&1)*3;
134 x = shuf2[m] + k%6 + 6*(chan&1);
135 y = l_start[i] + k/6 + 45*(chan>>1);
136 tbl[m] = (x<<1)|(y<<9);
139 switch (d->pix_fmt) {
140 case PIX_FMT_YUV422P:
141 x = shuf3[m] + slot/3;
143 ((((seq + off[m]) % d->difseg_size)<<1) + chan)*3;
144 tbl[m] = (x<<1)|(y<<8);
146 case PIX_FMT_YUV420P:
147 x = shuf3[m] + slot/3;
149 ((seq + off[m]) % d->difseg_size)*3;
150 tbl[m] = (x<<1)|(y<<9);
152 case PIX_FMT_YUV411P:
153 i = (seq + off[m]) % d->difseg_size;
154 k = slot + ((m==1||m==2)?3:0);
156 x = l_start_shuffled[m] + k/6;
157 y = serpent2[k] + i*6;
160 tbl[m] = (x<<2)|(y<<8);
169 /* quantization quanta by QNO for DV100 */
170 static const uint8_t dv100_qstep[16] = {
171 1, /* QNO = 0 and 1 both have no quantization */
173 2, 3, 4, 5, 6, 7, 8, 16, 18, 20, 22, 24, 28, 52
176 static const uint8_t dv_quant_areas[4] = { 6, 21, 43, 64 };
178 int ff_dv_init_dynamic_tables(const DVprofile *d)
181 uint32_t *factor1, *factor2;
182 const int *iweight1, *iweight2;
184 if (!d->work_chunks[dv_work_pool_size(d)-1].buf_offset) {
186 for (c=0; c<d->n_difchan; c++) {
187 for (s=0; s<d->difseg_size; s++) {
189 for (j=0; j<27; j++) {
191 if (!(DV_PROFILE_IS_1080i50(d) && c != 0 && s == 11) &&
192 !(DV_PROFILE_IS_720p50(d) && s > 9)) {
193 dv_calc_mb_coordinates(d, c, s, j, &d->work_chunks[i].mb_coordinates[0]);
194 d->work_chunks[i++].buf_offset = p;
202 if (!d->idct_factor[DV_PROFILE_IS_HD(d)?8191:5631]) {
203 factor1 = &d->idct_factor[0];
204 factor2 = &d->idct_factor[DV_PROFILE_IS_HD(d)?4096:2816];
205 if (d->height == 720) {
206 iweight1 = &ff_dv_iweight_720_y[0];
207 iweight2 = &ff_dv_iweight_720_c[0];
209 iweight1 = &ff_dv_iweight_1080_y[0];
210 iweight2 = &ff_dv_iweight_1080_c[0];
212 if (DV_PROFILE_IS_HD(d)) {
213 for (c = 0; c < 4; c++) {
214 for (s = 0; s < 16; s++) {
215 for (i = 0; i < 64; i++) {
216 *factor1++ = (dv100_qstep[s] << (c + 9)) * iweight1[i];
217 *factor2++ = (dv100_qstep[s] << (c + 9)) * iweight2[i];
222 iweight1 = &ff_dv_iweight_88[0];
223 for (j = 0; j < 2; j++, iweight1 = &ff_dv_iweight_248[0]) {
224 for (s = 0; s < 22; s++) {
225 for (i = c = 0; c < 4; c++) {
226 for (; i < dv_quant_areas[c]; i++) {
227 *factor1 = iweight1[i] << (ff_dv_quant_shifts[s][c] + 1);
228 *factor2++ = (*factor1++) << 1;
239 av_cold int ff_dvvideo_init(AVCodecContext *avctx)
241 DVVideoContext *s = avctx->priv_data;
248 uint16_t new_dv_vlc_bits[NB_DV_VLC*2];
249 uint8_t new_dv_vlc_len[NB_DV_VLC*2];
250 uint8_t new_dv_vlc_run[NB_DV_VLC*2];
251 int16_t new_dv_vlc_level[NB_DV_VLC*2];
255 /* it's faster to include sign bit in a generic VLC parsing scheme */
256 for (i = 0, j = 0; i < NB_DV_VLC; i++, j++) {
257 new_dv_vlc_bits[j] = dv_vlc_bits[i];
258 new_dv_vlc_len[j] = dv_vlc_len[i];
259 new_dv_vlc_run[j] = dv_vlc_run[i];
260 new_dv_vlc_level[j] = dv_vlc_level[i];
262 if (dv_vlc_level[i]) {
263 new_dv_vlc_bits[j] <<= 1;
267 new_dv_vlc_bits[j] = (dv_vlc_bits[i] << 1) | 1;
268 new_dv_vlc_len[j] = dv_vlc_len[i] + 1;
269 new_dv_vlc_run[j] = dv_vlc_run[i];
270 new_dv_vlc_level[j] = -dv_vlc_level[i];
274 /* NOTE: as a trick, we use the fact the no codes are unused
275 to accelerate the parsing of partial codes */
276 init_vlc(&dv_vlc, TEX_VLC_BITS, j,
277 new_dv_vlc_len, 1, 1, new_dv_vlc_bits, 2, 2, 0);
278 assert(dv_vlc.table_size == 1184);
280 for (i = 0; i < dv_vlc.table_size; i++){
281 int code = dv_vlc.table[i][0];
282 int len = dv_vlc.table[i][1];
285 if (len < 0){ //more bits needed
289 run = new_dv_vlc_run [code] + 1;
290 level = new_dv_vlc_level[code];
292 ff_dv_rl_vlc[i].len = len;
293 ff_dv_rl_vlc[i].level = level;
294 ff_dv_rl_vlc[i].run = run;
296 ff_free_vlc(&dv_vlc);
299 /* Generic DSP setup */
300 ff_dsputil_init(&dsp, avctx);
301 ff_set_cmp(&dsp, dsp.ildct_cmp, avctx->ildct_cmp);
302 s->get_pixels = dsp.get_pixels;
303 s->ildct_cmp = dsp.ildct_cmp[5];
306 s->fdct[0] = dsp.fdct;
307 s->idct_put[0] = dsp.idct_put;
308 for (i = 0; i < 64; i++)
309 s->dv_zigzag[0][i] = dsp.idct_permutation[ff_zigzag_direct[i]];
312 s->fdct[1] = dsp.fdct248;
313 s->idct_put[1] = ff_simple_idct248_put; // FIXME: need to add it to DSP
315 for (i = 0; i < 64; i++){
316 int j = ff_zigzag248_direct[i];
317 s->dv_zigzag[1][i] = dsp.idct_permutation[(j & 7) + (j & 8) * 4 + (j & 48) / 2];
320 memcpy(s->dv_zigzag[1], ff_zigzag248_direct, 64);
322 avctx->coded_frame = &s->picture;
324 avctx->chroma_sample_location = AVCHROMA_LOC_TOPLEFT;
329 static av_cold int dvvideo_init_encoder(AVCodecContext *avctx)
331 if (!avpriv_dv_codec_profile(avctx)) {
332 av_log(avctx, AV_LOG_ERROR, "Found no DV profile for %ix%i %s video. "
333 "Valid DV profiles are:\n",
334 avctx->width, avctx->height, av_get_pix_fmt_name(avctx->pix_fmt));
335 ff_dv_print_profiles(avctx, AV_LOG_ERROR);
336 return AVERROR(EINVAL);
338 if (avctx->height > 576) {
339 av_log(avctx, AV_LOG_ERROR, "DVCPRO HD encoding is not supported.\n");
340 return AVERROR_PATCHWELCOME;
343 dv_vlc_map_tableinit();
345 return ff_dvvideo_init(avctx);
348 /* bit budget for AC only in 5 MBs */
349 static const int vs_total_ac_bits = (100 * 4 + 68*2) * 5;
350 static const int mb_area_start[5] = { 1, 6, 21, 43, 64 };
352 static inline int put_bits_left(PutBitContext* s)
354 return (s->buf_end - s->buf) * 8 - put_bits_count(s);
358 /* Converts run and level (where level != 0) pair into VLC, returning bit size */
359 static av_always_inline int dv_rl2vlc(int run, int level, int sign, uint32_t* vlc)
362 if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {
363 *vlc = dv_vlc_map[run][level].vlc | sign;
364 size = dv_vlc_map[run][level].size;
367 if (level < DV_VLC_MAP_LEV_SIZE) {
368 *vlc = dv_vlc_map[0][level].vlc | sign;
369 size = dv_vlc_map[0][level].size;
371 *vlc = 0xfe00 | (level << 1) | sign;
375 *vlc |= ((run < 16) ? dv_vlc_map[run-1][0].vlc :
376 (0x1f80 | (run - 1))) << size;
377 size += (run < 16) ? dv_vlc_map[run-1][0].size : 13;
384 static av_always_inline int dv_rl2vlc_size(int run, int level)
388 if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {
389 size = dv_vlc_map[run][level].size;
392 size = (level < DV_VLC_MAP_LEV_SIZE) ? dv_vlc_map[0][level].size : 16;
394 size += (run < 16) ? dv_vlc_map[run-1][0].size : 13;
400 static av_always_inline int dv_rl2vlc(int run, int l, int sign, uint32_t* vlc)
402 *vlc = dv_vlc_map[run][l].vlc | sign;
403 return dv_vlc_map[run][l].size;
406 static av_always_inline int dv_rl2vlc_size(int run, int l)
408 return dv_vlc_map[run][l].size;
412 typedef struct EncBlockInfo {
422 uint8_t partial_bit_count;
423 uint32_t partial_bit_buffer; /* we can't use uint16_t here */
426 static av_always_inline PutBitContext* dv_encode_ac(EncBlockInfo* bi,
427 PutBitContext* pb_pool,
428 PutBitContext* pb_end)
431 PutBitContext* pb = pb_pool;
432 int size = bi->partial_bit_count;
433 uint32_t vlc = bi->partial_bit_buffer;
435 bi->partial_bit_count = bi->partial_bit_buffer = 0;
437 /* Find suitable storage space */
438 for (; size > (bits_left = put_bits_left(pb)); pb++) {
441 put_bits(pb, bits_left, vlc >> size);
442 vlc = vlc & ((1 << size) - 1);
444 if (pb + 1 >= pb_end) {
445 bi->partial_bit_count = size;
446 bi->partial_bit_buffer = vlc;
452 put_bits(pb, size, vlc);
454 if (bi->cur_ac >= 64)
457 /* Construct the next VLC */
459 bi->cur_ac = bi->next[prev];
460 if (bi->cur_ac < 64){
461 size = dv_rl2vlc(bi->cur_ac - prev - 1, bi->mb[bi->cur_ac], bi->sign[bi->cur_ac], &vlc);
463 size = 4; vlc = 6; /* End Of Block stamp */
469 static av_always_inline int dv_guess_dct_mode(DVVideoContext *s, uint8_t *data, int linesize) {
470 if (s->avctx->flags & CODEC_FLAG_INTERLACED_DCT) {
471 int ps = s->ildct_cmp(NULL, data, NULL, linesize, 8) - 400;
473 int is = s->ildct_cmp(NULL, data , NULL, linesize<<1, 4) +
474 s->ildct_cmp(NULL, data + linesize, NULL, linesize<<1, 4);
482 static const int dv_weight_bits = 18;
483 static const int dv_weight_88[64] = {
484 131072, 257107, 257107, 242189, 252167, 242189, 235923, 237536,
485 237536, 235923, 229376, 231390, 223754, 231390, 229376, 222935,
486 224969, 217965, 217965, 224969, 222935, 200636, 218652, 211916,
487 212325, 211916, 218652, 200636, 188995, 196781, 205965, 206433,
488 206433, 205965, 196781, 188995, 185364, 185364, 200636, 200704,
489 200636, 185364, 185364, 174609, 180568, 195068, 195068, 180568,
490 174609, 170091, 175557, 189591, 175557, 170091, 165371, 170627,
491 170627, 165371, 160727, 153560, 160727, 144651, 144651, 136258,
493 static const int dv_weight_248[64] = {
494 131072, 242189, 257107, 237536, 229376, 200636, 242189, 223754,
495 224969, 196781, 262144, 242189, 229376, 200636, 257107, 237536,
496 211916, 185364, 235923, 217965, 229376, 211916, 206433, 180568,
497 242189, 223754, 224969, 196781, 211916, 185364, 235923, 217965,
498 200704, 175557, 222935, 205965, 200636, 185364, 195068, 170627,
499 229376, 211916, 206433, 180568, 200704, 175557, 222935, 205965,
500 175557, 153560, 188995, 174609, 165371, 144651, 200636, 185364,
501 195068, 170627, 175557, 153560, 188995, 174609, 165371, 144651,
504 static av_always_inline int dv_init_enc_block(EncBlockInfo* bi, uint8_t *data, int linesize, DVVideoContext *s, int bias)
507 const uint8_t* zigzag_scan;
508 LOCAL_ALIGNED_16(DCTELEM, blk, [64]);
510 /* We offer two different methods for class number assignment: the
511 method suggested in SMPTE 314M Table 22, and an improved
512 method. The SMPTE method is very conservative; it assigns class
513 3 (i.e. severe quantization) to any block where the largest AC
514 component is greater than 36. FFmpeg's DV encoder tracks AC bit
515 consumption precisely, so there is no need to bias most blocks
516 towards strongly lossy compression. Instead, we assign class 2
517 to most blocks, and use class 3 only when strictly necessary
518 (for blocks whose largest AC component exceeds 255). */
520 #if 0 /* SMPTE spec method */
521 static const int classes[] = {12, 24, 36, 0xffff};
522 #else /* improved FFmpeg method */
523 static const int classes[] = {-1, -1, 255, 0xffff};
525 int max = classes[0];
528 assert((((int)blk) & 15) == 0);
530 bi->area_q[0] = bi->area_q[1] = bi->area_q[2] = bi->area_q[3] = 0;
531 bi->partial_bit_count = 0;
532 bi->partial_bit_buffer = 0;
535 bi->dct_mode = dv_guess_dct_mode(s, data, linesize);
536 s->get_pixels(blk, data, linesize);
537 s->fdct[bi->dct_mode](blk);
539 /* We rely on the fact that encoding all zeros leads to an immediate EOB,
540 which is precisely what the spec calls for in the "dummy" blocks. */
541 memset(blk, 0, 64*sizeof(*blk));
546 zigzag_scan = bi->dct_mode ? ff_zigzag248_direct : ff_zigzag_direct;
547 weight = bi->dct_mode ? dv_weight_248 : dv_weight_88;
549 for (area = 0; area < 4; area++) {
550 bi->prev[area] = prev;
551 bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
552 for (i = mb_area_start[area]; i < mb_area_start[area+1]; i++) {
553 int level = blk[zigzag_scan[i]];
555 if (level + 15 > 30U) {
556 bi->sign[i] = (level >> 31) & 1;
557 /* weight it and and shift down into range, adding for rounding */
558 /* the extra division by a factor of 2^4 reverses the 8x expansion of the DCT
559 AND the 2x doubling of the weights */
560 level = (FFABS(level) * weight[i] + (1 << (dv_weight_bits+3))) >> (dv_weight_bits+4);
564 bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, level);
571 for (bi->cno = 0; max > classes[bi->cno]; bi->cno++);
579 for (area = 0; area < 4; area++) {
580 bi->prev[area] = prev;
581 bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
582 for (; i < mb_area_start[area+1]; i = bi->next[i]) {
586 bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, bi->mb[i]);
595 return bi->bit_size[0] + bi->bit_size[1] + bi->bit_size[2] + bi->bit_size[3];
598 static inline void dv_guess_qnos(EncBlockInfo* blks, int* qnos)
601 int i, j, k, a, prev, a2;
604 size[0] = size[1] = size[2] = size[3] = size[4] = 1 << 24;
607 for (i = 0; i < 5; i++) {
613 for (j = 0; j < 6; j++, b++) {
614 for (a = 0; a < 4; a++) {
615 if (b->area_q[a] != ff_dv_quant_shifts[qnos[i] + ff_dv_quant_offset[b->cno]][a]) {
616 b->bit_size[a] = 1; // 4 areas 4 bits for EOB :)
619 assert(b->next[prev] >= mb_area_start[a+1] || b->mb[prev]);
620 for (k = b->next[prev] ; k < mb_area_start[a+1]; k = b->next[k]) {
623 b->bit_size[a] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
626 if (b->next[k] >= mb_area_start[a+1] && b->next[k]<64){
627 for (a2 = a + 1; b->next[k] >= mb_area_start[a2+1]; a2++)
630 assert(b->mb[b->next[k]]);
631 b->bit_size[a2] += dv_rl2vlc_size(b->next[k] - prev - 1, b->mb[b->next[k]])
632 -dv_rl2vlc_size(b->next[k] - k - 1, b->mb[b->next[k]]);
633 assert(b->prev[a2] == k && (a2 + 1 >= 4 || b->prev[a2+1] != k));
636 b->next[prev] = b->next[k];
641 size[i] += b->bit_size[a];
644 if (vs_total_ac_bits >= size[0] + size[1] + size[2] + size[3] + size[4])
647 } while (qnos[0]|qnos[1]|qnos[2]|qnos[3]|qnos[4]);
650 for (a = 2; a == 2 || vs_total_ac_bits < size[0]; a += a){
652 size[0] = 5 * 6 * 4; //EOB
653 for (j = 0; j < 6 *5; j++, b++) {
655 for (k = b->next[prev]; k < 64; k = b->next[k]) {
656 if (b->mb[k] < a && b->mb[k] > -a){
657 b->next[prev] = b->next[k];
659 size[0] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
667 static int dv_encode_video_segment(AVCodecContext *avctx, void *arg)
669 DVVideoContext *s = avctx->priv_data;
670 DVwork_chunk *work_chunk = arg;
672 int mb_x, mb_y, c_offset, linesize, y_stride;
675 LOCAL_ALIGNED_8(uint8_t, scratch, [128]);
676 EncBlockInfo enc_blks[5*DV_MAX_BPM];
677 PutBitContext pbs[5*DV_MAX_BPM];
679 EncBlockInfo* enc_blk;
681 int qnos[5] = {15, 15, 15, 15, 15}; /* No quantization */
682 int* qnosp = &qnos[0];
684 dif = &s->buf[work_chunk->buf_offset*80];
685 enc_blk = &enc_blks[0];
686 for (mb_index = 0; mb_index < 5; mb_index++) {
687 dv_calculate_mb_xy(s, work_chunk, mb_index, &mb_x, &mb_y);
689 /* initializing luminance blocks */
690 if ((s->sys->pix_fmt == PIX_FMT_YUV420P) ||
691 (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8)) ||
692 (s->sys->height >= 720 && mb_y != 134)) {
693 y_stride = s->picture.linesize[0] << 3;
697 y_ptr = s->picture.data[0] + ((mb_y * s->picture.linesize[0] + mb_x) << 3);
698 linesize = s->picture.linesize[0];
700 if (s->sys->video_stype == 4) { /* SD 422 */
702 dv_init_enc_block(enc_blk+0, y_ptr , linesize, s, 0) +
703 dv_init_enc_block(enc_blk+1, NULL , linesize, s, 0) +
704 dv_init_enc_block(enc_blk+2, y_ptr + 8 , linesize, s, 0) +
705 dv_init_enc_block(enc_blk+3, NULL , linesize, s, 0);
708 dv_init_enc_block(enc_blk+0, y_ptr , linesize, s, 0) +
709 dv_init_enc_block(enc_blk+1, y_ptr + 8 , linesize, s, 0) +
710 dv_init_enc_block(enc_blk+2, y_ptr + y_stride, linesize, s, 0) +
711 dv_init_enc_block(enc_blk+3, y_ptr + 8 + y_stride, linesize, s, 0);
715 /* initializing chrominance blocks */
716 c_offset = (((mb_y >> (s->sys->pix_fmt == PIX_FMT_YUV420P)) * s->picture.linesize[1] +
717 (mb_x >> ((s->sys->pix_fmt == PIX_FMT_YUV411P) ? 2 : 1))) << 3);
718 for (j = 2; j; j--) {
719 uint8_t *c_ptr = s->picture.data[j] + c_offset;
720 linesize = s->picture.linesize[j];
721 y_stride = (mb_y == 134) ? 8 : (s->picture.linesize[j] << 3);
722 if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8)) {
724 uint8_t* b = scratch;
725 for (i = 0; i < 8; i++) {
726 d = c_ptr + (linesize << 3);
727 b[0] = c_ptr[0]; b[1] = c_ptr[1]; b[2] = c_ptr[2]; b[3] = c_ptr[3];
728 b[4] = d[0]; b[5] = d[1]; b[6] = d[2]; b[7] = d[3];
736 vs_bit_size += dv_init_enc_block( enc_blk++, c_ptr , linesize, s, 1);
737 if (s->sys->bpm == 8) {
738 vs_bit_size += dv_init_enc_block(enc_blk++, c_ptr + y_stride, linesize, s, 1);
743 if (vs_total_ac_bits < vs_bit_size)
744 dv_guess_qnos(&enc_blks[0], qnosp);
746 /* DIF encoding process */
747 for (j=0; j<5*s->sys->bpm;) {
753 /* First pass over individual cells only */
754 for (i=0; i<s->sys->bpm; i++, j++) {
755 int sz = s->sys->block_sizes[i]>>3;
757 init_put_bits(&pbs[j], dif, sz);
758 put_sbits(&pbs[j], 9, ((enc_blks[j].mb[0] >> 3) - 1024 + 2) >> 2);
759 put_bits(&pbs[j], 1, enc_blks[j].dct_mode);
760 put_bits(&pbs[j], 2, enc_blks[j].cno);
762 dv_encode_ac(&enc_blks[j], &pbs[j], &pbs[j+1]);
766 /* Second pass over each MB space */
768 for (i=0; i<s->sys->bpm; i++) {
769 if (enc_blks[start_mb+i].partial_bit_count)
770 pb = dv_encode_ac(&enc_blks[start_mb+i], pb, &pbs[start_mb+s->sys->bpm]);
774 /* Third and final pass over the whole video segment space */
776 for (j=0; j<5*s->sys->bpm; j++) {
777 if (enc_blks[j].partial_bit_count)
778 pb = dv_encode_ac(&enc_blks[j], pb, &pbs[s->sys->bpm*5]);
779 if (enc_blks[j].partial_bit_count)
780 av_log(avctx, AV_LOG_ERROR, "ac bitstream overflow\n");
783 for (j=0; j<5*s->sys->bpm; j++) {
785 int size = pbs[j].size_in_bits >> 3;
786 flush_put_bits(&pbs[j]);
787 pos = put_bits_count(&pbs[j]) >> 3;
789 av_log(avctx, AV_LOG_ERROR, "bitstream written beyond buffer size\n");
792 memset(pbs[j].buf + pos, 0xff, size - pos);
798 static inline int dv_write_pack(enum dv_pack_type pack_id, DVVideoContext *c,
802 * Here's what SMPTE314M says about these two:
803 * (page 6) APTn, AP1n, AP2n, AP3n: These data shall be identical
804 * as track application IDs (APTn = 001, AP1n =
805 * 001, AP2n = 001, AP3n = 001), if the source signal
806 * comes from a digital VCR. If the signal source is
807 * unknown, all bits for these data shall be set to 1.
808 * (page 12) STYPE: STYPE defines a signal type of video signal
809 * 00000b = 4:1:1 compression
810 * 00100b = 4:2:2 compression
812 * Now, I've got two problems with these statements:
813 * 1. it looks like APT == 111b should be a safe bet, but it isn't.
814 * It seems that for PAL as defined in IEC 61834 we have to set
815 * APT to 000 and for SMPTE314M to 001.
816 * 2. It is not at all clear what STYPE is used for 4:2:0 PAL
817 * compression scheme (if any).
819 int apt = (c->sys->pix_fmt == PIX_FMT_YUV420P ? 0 : 1);
822 if ((int)(av_q2d(c->avctx->sample_aspect_ratio) * c->avctx->width / c->avctx->height * 10) >= 17) /* 16:9 */
825 buf[0] = (uint8_t)pack_id;
827 case dv_header525: /* I can't imagine why these two weren't defined as real */
828 case dv_header625: /* packs in SMPTE314M -- they definitely look like ones */
829 buf[1] = 0xf8 | /* reserved -- always 1 */
830 (apt & 0x07); /* APT: Track application ID */
831 buf[2] = (0 << 7) | /* TF1: audio data is 0 - valid; 1 - invalid */
832 (0x0f << 3) | /* reserved -- always 1 */
833 (apt & 0x07); /* AP1: Audio application ID */
834 buf[3] = (0 << 7) | /* TF2: video data is 0 - valid; 1 - invalid */
835 (0x0f << 3) | /* reserved -- always 1 */
836 (apt & 0x07); /* AP2: Video application ID */
837 buf[4] = (0 << 7) | /* TF3: subcode(SSYB) is 0 - valid; 1 - invalid */
838 (0x0f << 3) | /* reserved -- always 1 */
839 (apt & 0x07); /* AP3: Subcode application ID */
841 case dv_video_source:
842 buf[1] = 0xff; /* reserved -- always 1 */
843 buf[2] = (1 << 7) | /* B/W: 0 - b/w, 1 - color */
844 (1 << 6) | /* following CLF is valid - 0, invalid - 1 */
845 (3 << 4) | /* CLF: color frames ID (see ITU-R BT.470-4) */
846 0xf; /* reserved -- always 1 */
847 buf[3] = (3 << 6) | /* reserved -- always 1 */
848 (c->sys->dsf << 5) | /* system: 60fields/50fields */
849 c->sys->video_stype; /* signal type video compression */
850 buf[4] = 0xff; /* VISC: 0xff -- no information */
852 case dv_video_control:
853 buf[1] = (0 << 6) | /* Copy generation management (CGMS) 0 -- free */
854 0x3f; /* reserved -- always 1 */
855 buf[2] = 0xc8 | /* reserved -- always b11001xxx */
857 buf[3] = (1 << 7) | /* frame/field flag 1 -- frame, 0 -- field */
858 (1 << 6) | /* first/second field flag 0 -- field 2, 1 -- field 1 */
859 (1 << 5) | /* frame change flag 0 -- same picture as before, 1 -- different */
860 (1 << 4) | /* 1 - interlaced, 0 - noninterlaced */
861 0xc; /* reserved -- always b1100 */
862 buf[4] = 0xff; /* reserved -- always 1 */
865 buf[1] = buf[2] = buf[3] = buf[4] = 0xff;
870 #if CONFIG_DVVIDEO_ENCODER
871 static inline int dv_write_dif_id(enum dv_section_type t, uint8_t chan_num,
872 uint8_t seq_num, uint8_t dif_num,
875 buf[0] = (uint8_t)t; /* Section type */
876 buf[1] = (seq_num << 4) | /* DIF seq number 0-9 for 525/60; 0-11 for 625/50 */
877 (chan_num << 3) | /* FSC: for 50Mb/s 0 - first channel; 1 - second */
878 7; /* reserved -- always 1 */
879 buf[2] = dif_num; /* DIF block number Video: 0-134, Audio: 0-8 */
884 static inline int dv_write_ssyb_id(uint8_t syb_num, uint8_t fr, uint8_t* buf)
886 if (syb_num == 0 || syb_num == 6) {
887 buf[0] = (fr << 7) | /* FR ID 1 - first half of each channel; 0 - second */
888 (0 << 4) | /* AP3 (Subcode application ID) */
889 0x0f; /* reserved -- always 1 */
891 else if (syb_num == 11) {
892 buf[0] = (fr << 7) | /* FR ID 1 - first half of each channel; 0 - second */
893 0x7f; /* reserved -- always 1 */
896 buf[0] = (fr << 7) | /* FR ID 1 - first half of each channel; 0 - second */
897 (0 << 4) | /* APT (Track application ID) */
898 0x0f; /* reserved -- always 1 */
900 buf[1] = 0xf0 | /* reserved -- always 1 */
901 (syb_num & 0x0f); /* SSYB number 0 - 11 */
902 buf[2] = 0xff; /* reserved -- always 1 */
906 static void dv_format_frame(DVVideoContext* c, uint8_t* buf)
910 for (chan = 0; chan < c->sys->n_difchan; chan++) {
911 for (i = 0; i < c->sys->difseg_size; i++) {
912 memset(buf, 0xff, 80 * 6); /* first 6 DIF blocks are for control data */
914 /* DV header: 1DIF */
915 buf += dv_write_dif_id(dv_sect_header, chan, i, 0, buf);
916 buf += dv_write_pack((c->sys->dsf ? dv_header625 : dv_header525), c, buf);
917 buf += 72; /* unused bytes */
919 /* DV subcode: 2DIFs */
920 for (j = 0; j < 2; j++) {
921 buf += dv_write_dif_id(dv_sect_subcode, chan, i, j, buf);
922 for (k = 0; k < 6; k++)
923 buf += dv_write_ssyb_id(k, (i < c->sys->difseg_size/2), buf) + 5;
924 buf += 29; /* unused bytes */
928 for (j = 0; j < 3; j++) {
929 buf += dv_write_dif_id(dv_sect_vaux, chan, i, j, buf);
930 buf += dv_write_pack(dv_video_source, c, buf);
931 buf += dv_write_pack(dv_video_control, c, buf);
933 buf += dv_write_pack(dv_video_source, c, buf);
934 buf += dv_write_pack(dv_video_control, c, buf);
935 buf += 4*5 + 2; /* unused bytes */
938 /* DV Audio/Video: 135 Video DIFs + 9 Audio DIFs */
939 for (j = 0; j < 135; j++) {
941 memset(buf, 0xff, 80);
942 buf += dv_write_dif_id(dv_sect_audio, chan, i, j/15, buf);
943 buf += 77; /* audio control & shuffled PCM audio */
945 buf += dv_write_dif_id(dv_sect_video, chan, i, j, buf);
946 buf += 77; /* 1 video macroblock: 1 bytes control
947 4 * 14 bytes Y 8x8 data
949 10 bytes Cb 8x8 data */
956 static int dvvideo_encode_frame(AVCodecContext *c, AVPacket *pkt,
957 const AVFrame *frame, int *got_packet)
959 DVVideoContext *s = c->priv_data;
962 s->sys = avpriv_dv_codec_profile(c);
963 if (!s->sys || ff_dv_init_dynamic_tables(s->sys))
965 if ((ret = ff_alloc_packet2(c, pkt, s->sys->frame_size)) < 0)
968 c->pix_fmt = s->sys->pix_fmt;
970 s->picture.key_frame = 1;
971 s->picture.pict_type = AV_PICTURE_TYPE_I;
974 c->execute(c, dv_encode_video_segment, s->sys->work_chunks, NULL,
975 dv_work_pool_size(s->sys), sizeof(DVwork_chunk));
979 dv_format_frame(s, pkt->data);
981 pkt->flags |= AV_PKT_FLAG_KEY;
987 AVCodec ff_dvvideo_encoder = {
989 .type = AVMEDIA_TYPE_VIDEO,
990 .id = AV_CODEC_ID_DVVIDEO,
991 .priv_data_size = sizeof(DVVideoContext),
992 .init = dvvideo_init_encoder,
993 .encode2 = dvvideo_encode_frame,
994 .capabilities = CODEC_CAP_SLICE_THREADS,
995 .pix_fmts = (const enum PixelFormat[]) {
996 PIX_FMT_YUV411P, PIX_FMT_YUV422P, PIX_FMT_YUV420P, PIX_FMT_NONE
998 .long_name = NULL_IF_CONFIG_SMALL("DV (Digital Video)"),
1000 #endif // CONFIG_DVVIDEO_ENCODER