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);
339 dv_vlc_map_tableinit();
341 return ff_dvvideo_init(avctx);
344 /* bit budget for AC only in 5 MBs */
345 static const int vs_total_ac_bits = (100 * 4 + 68*2) * 5;
346 static const int mb_area_start[5] = { 1, 6, 21, 43, 64 };
348 static inline int put_bits_left(PutBitContext* s)
350 return (s->buf_end - s->buf) * 8 - put_bits_count(s);
354 /* Converts run and level (where level != 0) pair into VLC, returning bit size */
355 static av_always_inline int dv_rl2vlc(int run, int level, int sign, uint32_t* vlc)
358 if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {
359 *vlc = dv_vlc_map[run][level].vlc | sign;
360 size = dv_vlc_map[run][level].size;
363 if (level < DV_VLC_MAP_LEV_SIZE) {
364 *vlc = dv_vlc_map[0][level].vlc | sign;
365 size = dv_vlc_map[0][level].size;
367 *vlc = 0xfe00 | (level << 1) | sign;
371 *vlc |= ((run < 16) ? dv_vlc_map[run-1][0].vlc :
372 (0x1f80 | (run - 1))) << size;
373 size += (run < 16) ? dv_vlc_map[run-1][0].size : 13;
380 static av_always_inline int dv_rl2vlc_size(int run, int level)
384 if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {
385 size = dv_vlc_map[run][level].size;
388 size = (level < DV_VLC_MAP_LEV_SIZE) ? dv_vlc_map[0][level].size : 16;
390 size += (run < 16) ? dv_vlc_map[run-1][0].size : 13;
396 static av_always_inline int dv_rl2vlc(int run, int l, int sign, uint32_t* vlc)
398 *vlc = dv_vlc_map[run][l].vlc | sign;
399 return dv_vlc_map[run][l].size;
402 static av_always_inline int dv_rl2vlc_size(int run, int l)
404 return dv_vlc_map[run][l].size;
408 typedef struct EncBlockInfo {
418 uint8_t partial_bit_count;
419 uint32_t partial_bit_buffer; /* we can't use uint16_t here */
422 static av_always_inline PutBitContext* dv_encode_ac(EncBlockInfo* bi,
423 PutBitContext* pb_pool,
424 PutBitContext* pb_end)
427 PutBitContext* pb = pb_pool;
428 int size = bi->partial_bit_count;
429 uint32_t vlc = bi->partial_bit_buffer;
431 bi->partial_bit_count = bi->partial_bit_buffer = 0;
433 /* Find suitable storage space */
434 for (; size > (bits_left = put_bits_left(pb)); pb++) {
437 put_bits(pb, bits_left, vlc >> size);
438 vlc = vlc & ((1 << size) - 1);
440 if (pb + 1 >= pb_end) {
441 bi->partial_bit_count = size;
442 bi->partial_bit_buffer = vlc;
448 put_bits(pb, size, vlc);
450 if (bi->cur_ac >= 64)
453 /* Construct the next VLC */
455 bi->cur_ac = bi->next[prev];
456 if (bi->cur_ac < 64){
457 size = dv_rl2vlc(bi->cur_ac - prev - 1, bi->mb[bi->cur_ac], bi->sign[bi->cur_ac], &vlc);
459 size = 4; vlc = 6; /* End Of Block stamp */
465 static av_always_inline int dv_guess_dct_mode(DVVideoContext *s, uint8_t *data, int linesize) {
466 if (s->avctx->flags & CODEC_FLAG_INTERLACED_DCT) {
467 int ps = s->ildct_cmp(NULL, data, NULL, linesize, 8) - 400;
469 int is = s->ildct_cmp(NULL, data , NULL, linesize<<1, 4) +
470 s->ildct_cmp(NULL, data + linesize, NULL, linesize<<1, 4);
478 static const int dv_weight_bits = 18;
479 static const int dv_weight_88[64] = {
480 131072, 257107, 257107, 242189, 252167, 242189, 235923, 237536,
481 237536, 235923, 229376, 231390, 223754, 231390, 229376, 222935,
482 224969, 217965, 217965, 224969, 222935, 200636, 218652, 211916,
483 212325, 211916, 218652, 200636, 188995, 196781, 205965, 206433,
484 206433, 205965, 196781, 188995, 185364, 185364, 200636, 200704,
485 200636, 185364, 185364, 174609, 180568, 195068, 195068, 180568,
486 174609, 170091, 175557, 189591, 175557, 170091, 165371, 170627,
487 170627, 165371, 160727, 153560, 160727, 144651, 144651, 136258,
489 static const int dv_weight_248[64] = {
490 131072, 242189, 257107, 237536, 229376, 200636, 242189, 223754,
491 224969, 196781, 262144, 242189, 229376, 200636, 257107, 237536,
492 211916, 185364, 235923, 217965, 229376, 211916, 206433, 180568,
493 242189, 223754, 224969, 196781, 211916, 185364, 235923, 217965,
494 200704, 175557, 222935, 205965, 200636, 185364, 195068, 170627,
495 229376, 211916, 206433, 180568, 200704, 175557, 222935, 205965,
496 175557, 153560, 188995, 174609, 165371, 144651, 200636, 185364,
497 195068, 170627, 175557, 153560, 188995, 174609, 165371, 144651,
500 static av_always_inline int dv_init_enc_block(EncBlockInfo* bi, uint8_t *data, int linesize, DVVideoContext *s, int bias)
503 const uint8_t* zigzag_scan;
504 LOCAL_ALIGNED_16(DCTELEM, blk, [64]);
506 /* We offer two different methods for class number assignment: the
507 method suggested in SMPTE 314M Table 22, and an improved
508 method. The SMPTE method is very conservative; it assigns class
509 3 (i.e. severe quantization) to any block where the largest AC
510 component is greater than 36. FFmpeg's DV encoder tracks AC bit
511 consumption precisely, so there is no need to bias most blocks
512 towards strongly lossy compression. Instead, we assign class 2
513 to most blocks, and use class 3 only when strictly necessary
514 (for blocks whose largest AC component exceeds 255). */
516 #if 0 /* SMPTE spec method */
517 static const int classes[] = {12, 24, 36, 0xffff};
518 #else /* improved FFmpeg method */
519 static const int classes[] = {-1, -1, 255, 0xffff};
521 int max = classes[0];
524 assert((((int)blk) & 15) == 0);
526 bi->area_q[0] = bi->area_q[1] = bi->area_q[2] = bi->area_q[3] = 0;
527 bi->partial_bit_count = 0;
528 bi->partial_bit_buffer = 0;
531 bi->dct_mode = dv_guess_dct_mode(s, data, linesize);
532 s->get_pixels(blk, data, linesize);
533 s->fdct[bi->dct_mode](blk);
535 /* We rely on the fact that encoding all zeros leads to an immediate EOB,
536 which is precisely what the spec calls for in the "dummy" blocks. */
537 memset(blk, 0, 64*sizeof(*blk));
542 zigzag_scan = bi->dct_mode ? ff_zigzag248_direct : ff_zigzag_direct;
543 weight = bi->dct_mode ? dv_weight_248 : dv_weight_88;
545 for (area = 0; area < 4; area++) {
546 bi->prev[area] = prev;
547 bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
548 for (i = mb_area_start[area]; i < mb_area_start[area+1]; i++) {
549 int level = blk[zigzag_scan[i]];
551 if (level + 15 > 30U) {
552 bi->sign[i] = (level >> 31) & 1;
553 /* weight it and and shift down into range, adding for rounding */
554 /* the extra division by a factor of 2^4 reverses the 8x expansion of the DCT
555 AND the 2x doubling of the weights */
556 level = (FFABS(level) * weight[i] + (1 << (dv_weight_bits+3))) >> (dv_weight_bits+4);
560 bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, level);
567 for (bi->cno = 0; max > classes[bi->cno]; bi->cno++);
575 for (area = 0; area < 4; area++) {
576 bi->prev[area] = prev;
577 bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
578 for (; i < mb_area_start[area+1]; i = bi->next[i]) {
582 bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, bi->mb[i]);
591 return bi->bit_size[0] + bi->bit_size[1] + bi->bit_size[2] + bi->bit_size[3];
594 static inline void dv_guess_qnos(EncBlockInfo* blks, int* qnos)
597 int i, j, k, a, prev, a2;
600 size[0] = size[1] = size[2] = size[3] = size[4] = 1 << 24;
603 for (i = 0; i < 5; i++) {
609 for (j = 0; j < 6; j++, b++) {
610 for (a = 0; a < 4; a++) {
611 if (b->area_q[a] != ff_dv_quant_shifts[qnos[i] + ff_dv_quant_offset[b->cno]][a]) {
612 b->bit_size[a] = 1; // 4 areas 4 bits for EOB :)
615 assert(b->next[prev] >= mb_area_start[a+1] || b->mb[prev]);
616 for (k = b->next[prev] ; k < mb_area_start[a+1]; k = b->next[k]) {
619 b->bit_size[a] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
622 if (b->next[k] >= mb_area_start[a+1] && b->next[k]<64){
623 for (a2 = a + 1; b->next[k] >= mb_area_start[a2+1]; a2++)
626 assert(b->mb[b->next[k]]);
627 b->bit_size[a2] += dv_rl2vlc_size(b->next[k] - prev - 1, b->mb[b->next[k]])
628 -dv_rl2vlc_size(b->next[k] - k - 1, b->mb[b->next[k]]);
629 assert(b->prev[a2] == k && (a2 + 1 >= 4 || b->prev[a2+1] != k));
632 b->next[prev] = b->next[k];
637 size[i] += b->bit_size[a];
640 if (vs_total_ac_bits >= size[0] + size[1] + size[2] + size[3] + size[4])
643 } while (qnos[0]|qnos[1]|qnos[2]|qnos[3]|qnos[4]);
646 for (a = 2; a == 2 || vs_total_ac_bits < size[0]; a += a){
648 size[0] = 5 * 6 * 4; //EOB
649 for (j = 0; j < 6 *5; j++, b++) {
651 for (k = b->next[prev]; k < 64; k = b->next[k]) {
652 if (b->mb[k] < a && b->mb[k] > -a){
653 b->next[prev] = b->next[k];
655 size[0] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
663 static int dv_encode_video_segment(AVCodecContext *avctx, void *arg)
665 DVVideoContext *s = avctx->priv_data;
666 DVwork_chunk *work_chunk = arg;
668 int mb_x, mb_y, c_offset, linesize, y_stride;
671 LOCAL_ALIGNED_8(uint8_t, scratch, [128]);
672 EncBlockInfo enc_blks[5*DV_MAX_BPM];
673 PutBitContext pbs[5*DV_MAX_BPM];
675 EncBlockInfo* enc_blk;
677 int qnos[5] = {15, 15, 15, 15, 15}; /* No quantization */
678 int* qnosp = &qnos[0];
680 dif = &s->buf[work_chunk->buf_offset*80];
681 enc_blk = &enc_blks[0];
682 for (mb_index = 0; mb_index < 5; mb_index++) {
683 dv_calculate_mb_xy(s, work_chunk, mb_index, &mb_x, &mb_y);
685 /* initializing luminance blocks */
686 if ((s->sys->pix_fmt == PIX_FMT_YUV420P) ||
687 (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8)) ||
688 (s->sys->height >= 720 && mb_y != 134)) {
689 y_stride = s->picture.linesize[0] << 3;
693 y_ptr = s->picture.data[0] + ((mb_y * s->picture.linesize[0] + mb_x) << 3);
694 linesize = s->picture.linesize[0];
696 if (s->sys->video_stype == 4) { /* SD 422 */
698 dv_init_enc_block(enc_blk+0, y_ptr , linesize, s, 0) +
699 dv_init_enc_block(enc_blk+1, NULL , linesize, s, 0) +
700 dv_init_enc_block(enc_blk+2, y_ptr + 8 , linesize, s, 0) +
701 dv_init_enc_block(enc_blk+3, NULL , linesize, s, 0);
704 dv_init_enc_block(enc_blk+0, y_ptr , linesize, s, 0) +
705 dv_init_enc_block(enc_blk+1, y_ptr + 8 , linesize, s, 0) +
706 dv_init_enc_block(enc_blk+2, y_ptr + y_stride, linesize, s, 0) +
707 dv_init_enc_block(enc_blk+3, y_ptr + 8 + y_stride, linesize, s, 0);
711 /* initializing chrominance blocks */
712 c_offset = (((mb_y >> (s->sys->pix_fmt == PIX_FMT_YUV420P)) * s->picture.linesize[1] +
713 (mb_x >> ((s->sys->pix_fmt == PIX_FMT_YUV411P) ? 2 : 1))) << 3);
714 for (j = 2; j; j--) {
715 uint8_t *c_ptr = s->picture.data[j] + c_offset;
716 linesize = s->picture.linesize[j];
717 y_stride = (mb_y == 134) ? 8 : (s->picture.linesize[j] << 3);
718 if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8)) {
720 uint8_t* b = scratch;
721 for (i = 0; i < 8; i++) {
722 d = c_ptr + (linesize << 3);
723 b[0] = c_ptr[0]; b[1] = c_ptr[1]; b[2] = c_ptr[2]; b[3] = c_ptr[3];
724 b[4] = d[0]; b[5] = d[1]; b[6] = d[2]; b[7] = d[3];
732 vs_bit_size += dv_init_enc_block( enc_blk++, c_ptr , linesize, s, 1);
733 if (s->sys->bpm == 8) {
734 vs_bit_size += dv_init_enc_block(enc_blk++, c_ptr + y_stride, linesize, s, 1);
739 if (vs_total_ac_bits < vs_bit_size)
740 dv_guess_qnos(&enc_blks[0], qnosp);
742 /* DIF encoding process */
743 for (j=0; j<5*s->sys->bpm;) {
749 /* First pass over individual cells only */
750 for (i=0; i<s->sys->bpm; i++, j++) {
751 int sz = s->sys->block_sizes[i]>>3;
753 init_put_bits(&pbs[j], dif, sz);
754 put_sbits(&pbs[j], 9, ((enc_blks[j].mb[0] >> 3) - 1024 + 2) >> 2);
755 put_bits(&pbs[j], 1, enc_blks[j].dct_mode);
756 put_bits(&pbs[j], 2, enc_blks[j].cno);
758 dv_encode_ac(&enc_blks[j], &pbs[j], &pbs[j+1]);
762 /* Second pass over each MB space */
764 for (i=0; i<s->sys->bpm; i++) {
765 if (enc_blks[start_mb+i].partial_bit_count)
766 pb = dv_encode_ac(&enc_blks[start_mb+i], pb, &pbs[start_mb+s->sys->bpm]);
770 /* Third and final pass over the whole video segment space */
772 for (j=0; j<5*s->sys->bpm; j++) {
773 if (enc_blks[j].partial_bit_count)
774 pb = dv_encode_ac(&enc_blks[j], pb, &pbs[s->sys->bpm*5]);
775 if (enc_blks[j].partial_bit_count)
776 av_log(avctx, AV_LOG_ERROR, "ac bitstream overflow\n");
779 for (j=0; j<5*s->sys->bpm; j++) {
781 int size = pbs[j].size_in_bits >> 3;
782 flush_put_bits(&pbs[j]);
783 pos = put_bits_count(&pbs[j]) >> 3;
785 av_log(avctx, AV_LOG_ERROR, "bitstream written beyond buffer size\n");
788 memset(pbs[j].buf + pos, 0xff, size - pos);
794 static inline int dv_write_pack(enum dv_pack_type pack_id, DVVideoContext *c,
798 * Here's what SMPTE314M says about these two:
799 * (page 6) APTn, AP1n, AP2n, AP3n: These data shall be identical
800 * as track application IDs (APTn = 001, AP1n =
801 * 001, AP2n = 001, AP3n = 001), if the source signal
802 * comes from a digital VCR. If the signal source is
803 * unknown, all bits for these data shall be set to 1.
804 * (page 12) STYPE: STYPE defines a signal type of video signal
805 * 00000b = 4:1:1 compression
806 * 00100b = 4:2:2 compression
808 * Now, I've got two problems with these statements:
809 * 1. it looks like APT == 111b should be a safe bet, but it isn't.
810 * It seems that for PAL as defined in IEC 61834 we have to set
811 * APT to 000 and for SMPTE314M to 001.
812 * 2. It is not at all clear what STYPE is used for 4:2:0 PAL
813 * compression scheme (if any).
815 int apt = (c->sys->pix_fmt == PIX_FMT_YUV420P ? 0 : 1);
818 if ((int)(av_q2d(c->avctx->sample_aspect_ratio) * c->avctx->width / c->avctx->height * 10) >= 17) /* 16:9 */
821 buf[0] = (uint8_t)pack_id;
823 case dv_header525: /* I can't imagine why these two weren't defined as real */
824 case dv_header625: /* packs in SMPTE314M -- they definitely look like ones */
825 buf[1] = 0xf8 | /* reserved -- always 1 */
826 (apt & 0x07); /* APT: Track application ID */
827 buf[2] = (0 << 7) | /* TF1: audio data is 0 - valid; 1 - invalid */
828 (0x0f << 3) | /* reserved -- always 1 */
829 (apt & 0x07); /* AP1: Audio application ID */
830 buf[3] = (0 << 7) | /* TF2: video data is 0 - valid; 1 - invalid */
831 (0x0f << 3) | /* reserved -- always 1 */
832 (apt & 0x07); /* AP2: Video application ID */
833 buf[4] = (0 << 7) | /* TF3: subcode(SSYB) is 0 - valid; 1 - invalid */
834 (0x0f << 3) | /* reserved -- always 1 */
835 (apt & 0x07); /* AP3: Subcode application ID */
837 case dv_video_source:
838 buf[1] = 0xff; /* reserved -- always 1 */
839 buf[2] = (1 << 7) | /* B/W: 0 - b/w, 1 - color */
840 (1 << 6) | /* following CLF is valid - 0, invalid - 1 */
841 (3 << 4) | /* CLF: color frames ID (see ITU-R BT.470-4) */
842 0xf; /* reserved -- always 1 */
843 buf[3] = (3 << 6) | /* reserved -- always 1 */
844 (c->sys->dsf << 5) | /* system: 60fields/50fields */
845 c->sys->video_stype; /* signal type video compression */
846 buf[4] = 0xff; /* VISC: 0xff -- no information */
848 case dv_video_control:
849 buf[1] = (0 << 6) | /* Copy generation management (CGMS) 0 -- free */
850 0x3f; /* reserved -- always 1 */
851 buf[2] = 0xc8 | /* reserved -- always b11001xxx */
853 buf[3] = (1 << 7) | /* frame/field flag 1 -- frame, 0 -- field */
854 (1 << 6) | /* first/second field flag 0 -- field 2, 1 -- field 1 */
855 (1 << 5) | /* frame change flag 0 -- same picture as before, 1 -- different */
856 (1 << 4) | /* 1 - interlaced, 0 - noninterlaced */
857 0xc; /* reserved -- always b1100 */
858 buf[4] = 0xff; /* reserved -- always 1 */
861 buf[1] = buf[2] = buf[3] = buf[4] = 0xff;
866 #if CONFIG_DVVIDEO_ENCODER
867 static inline int dv_write_dif_id(enum dv_section_type t, uint8_t chan_num,
868 uint8_t seq_num, uint8_t dif_num,
871 buf[0] = (uint8_t)t; /* Section type */
872 buf[1] = (seq_num << 4) | /* DIF seq number 0-9 for 525/60; 0-11 for 625/50 */
873 (chan_num << 3) | /* FSC: for 50Mb/s 0 - first channel; 1 - second */
874 7; /* reserved -- always 1 */
875 buf[2] = dif_num; /* DIF block number Video: 0-134, Audio: 0-8 */
880 static inline int dv_write_ssyb_id(uint8_t syb_num, uint8_t fr, uint8_t* buf)
882 if (syb_num == 0 || syb_num == 6) {
883 buf[0] = (fr << 7) | /* FR ID 1 - first half of each channel; 0 - second */
884 (0 << 4) | /* AP3 (Subcode application ID) */
885 0x0f; /* reserved -- always 1 */
887 else if (syb_num == 11) {
888 buf[0] = (fr << 7) | /* FR ID 1 - first half of each channel; 0 - second */
889 0x7f; /* reserved -- always 1 */
892 buf[0] = (fr << 7) | /* FR ID 1 - first half of each channel; 0 - second */
893 (0 << 4) | /* APT (Track application ID) */
894 0x0f; /* reserved -- always 1 */
896 buf[1] = 0xf0 | /* reserved -- always 1 */
897 (syb_num & 0x0f); /* SSYB number 0 - 11 */
898 buf[2] = 0xff; /* reserved -- always 1 */
902 static void dv_format_frame(DVVideoContext* c, uint8_t* buf)
906 for (chan = 0; chan < c->sys->n_difchan; chan++) {
907 for (i = 0; i < c->sys->difseg_size; i++) {
908 memset(buf, 0xff, 80 * 6); /* first 6 DIF blocks are for control data */
910 /* DV header: 1DIF */
911 buf += dv_write_dif_id(dv_sect_header, chan, i, 0, buf);
912 buf += dv_write_pack((c->sys->dsf ? dv_header625 : dv_header525), c, buf);
913 buf += 72; /* unused bytes */
915 /* DV subcode: 2DIFs */
916 for (j = 0; j < 2; j++) {
917 buf += dv_write_dif_id(dv_sect_subcode, chan, i, j, buf);
918 for (k = 0; k < 6; k++)
919 buf += dv_write_ssyb_id(k, (i < c->sys->difseg_size/2), buf) + 5;
920 buf += 29; /* unused bytes */
924 for (j = 0; j < 3; j++) {
925 buf += dv_write_dif_id(dv_sect_vaux, chan, i, j, buf);
926 buf += dv_write_pack(dv_video_source, c, buf);
927 buf += dv_write_pack(dv_video_control, c, buf);
929 buf += dv_write_pack(dv_video_source, c, buf);
930 buf += dv_write_pack(dv_video_control, c, buf);
931 buf += 4*5 + 2; /* unused bytes */
934 /* DV Audio/Video: 135 Video DIFs + 9 Audio DIFs */
935 for (j = 0; j < 135; j++) {
937 memset(buf, 0xff, 80);
938 buf += dv_write_dif_id(dv_sect_audio, chan, i, j/15, buf);
939 buf += 77; /* audio control & shuffled PCM audio */
941 buf += dv_write_dif_id(dv_sect_video, chan, i, j, buf);
942 buf += 77; /* 1 video macroblock: 1 bytes control
943 4 * 14 bytes Y 8x8 data
945 10 bytes Cb 8x8 data */
952 static int dvvideo_encode_frame(AVCodecContext *c, AVPacket *pkt,
953 const AVFrame *frame, int *got_packet)
955 DVVideoContext *s = c->priv_data;
958 s->sys = avpriv_dv_codec_profile(c);
959 if (!s->sys || ff_dv_init_dynamic_tables(s->sys))
961 if ((ret = ff_alloc_packet2(c, pkt, s->sys->frame_size)) < 0)
964 c->pix_fmt = s->sys->pix_fmt;
966 s->picture.key_frame = 1;
967 s->picture.pict_type = AV_PICTURE_TYPE_I;
970 c->execute(c, dv_encode_video_segment, s->sys->work_chunks, NULL,
971 dv_work_pool_size(s->sys), sizeof(DVwork_chunk));
975 dv_format_frame(s, pkt->data);
977 pkt->flags |= AV_PKT_FLAG_KEY;
983 AVCodec ff_dvvideo_encoder = {
985 .type = AVMEDIA_TYPE_VIDEO,
986 .id = CODEC_ID_DVVIDEO,
987 .priv_data_size = sizeof(DVVideoContext),
988 .init = dvvideo_init_encoder,
989 .encode2 = dvvideo_encode_frame,
990 .capabilities = CODEC_CAP_SLICE_THREADS,
991 .pix_fmts = (const enum PixelFormat[]) {
992 PIX_FMT_YUV411P, PIX_FMT_YUV422P, PIX_FMT_YUV420P, PIX_FMT_NONE
994 .long_name = NULL_IF_CONFIG_SMALL("DV (Digital Video)"),
996 #endif // CONFIG_DVVIDEO_ENCODER