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/internal.h"
42 #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 AV_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 AV_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 AV_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 av_assert1(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 memset(&dsp,0, sizeof(dsp));
301 ff_dsputil_init(&dsp, avctx);
302 ff_set_cmp(&dsp, dsp.ildct_cmp, avctx->ildct_cmp);
303 s->get_pixels = dsp.get_pixels;
304 s->ildct_cmp = dsp.ildct_cmp[5];
307 s->fdct[0] = dsp.fdct;
308 s->idct_put[0] = dsp.idct_put;
309 for (i = 0; i < 64; i++)
310 s->dv_zigzag[0][i] = dsp.idct_permutation[ff_zigzag_direct[i]];
313 s->fdct[1] = dsp.fdct248;
314 s->idct_put[1] = ff_simple_idct248_put; // FIXME: need to add it to DSP
316 for (i = 0; i < 64; i++){
317 int j = ff_zigzag248_direct[i];
318 s->dv_zigzag[1][i] = dsp.idct_permutation[(j & 7) + (j & 8) * 4 + (j & 48) / 2];
321 memcpy(s->dv_zigzag[1], ff_zigzag248_direct, 64);
323 avcodec_get_frame_defaults(&s->picture);
324 avctx->coded_frame = &s->picture;
326 avctx->chroma_sample_location = AVCHROMA_LOC_TOPLEFT;
331 static av_cold int dvvideo_init_encoder(AVCodecContext *avctx)
333 if (!avpriv_dv_codec_profile(avctx)) {
334 av_log(avctx, AV_LOG_ERROR, "Found no DV profile for %ix%i %s video. "
335 "Valid DV profiles are:\n",
336 avctx->width, avctx->height, av_get_pix_fmt_name(avctx->pix_fmt));
337 ff_dv_print_profiles(avctx, AV_LOG_ERROR);
338 return AVERROR(EINVAL);
340 if (avctx->height > 576) {
341 av_log(avctx, AV_LOG_ERROR, "DVCPRO HD encoding is not supported.\n");
342 return AVERROR_PATCHWELCOME;
345 dv_vlc_map_tableinit();
347 return ff_dvvideo_init(avctx);
350 /* bit budget for AC only in 5 MBs */
351 static const int vs_total_ac_bits = (100 * 4 + 68*2) * 5;
352 static const int mb_area_start[5] = { 1, 6, 21, 43, 64 };
355 /* Converts run and level (where level != 0) pair into VLC, returning bit size */
356 static av_always_inline int dv_rl2vlc(int run, int level, int sign, uint32_t* vlc)
359 if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {
360 *vlc = dv_vlc_map[run][level].vlc | sign;
361 size = dv_vlc_map[run][level].size;
364 if (level < DV_VLC_MAP_LEV_SIZE) {
365 *vlc = dv_vlc_map[0][level].vlc | sign;
366 size = dv_vlc_map[0][level].size;
368 *vlc = 0xfe00 | (level << 1) | sign;
372 *vlc |= ((run < 16) ? dv_vlc_map[run-1][0].vlc :
373 (0x1f80 | (run - 1))) << size;
374 size += (run < 16) ? dv_vlc_map[run-1][0].size : 13;
381 static av_always_inline int dv_rl2vlc_size(int run, int level)
385 if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {
386 size = dv_vlc_map[run][level].size;
389 size = (level < DV_VLC_MAP_LEV_SIZE) ? dv_vlc_map[0][level].size : 16;
391 size += (run < 16) ? dv_vlc_map[run-1][0].size : 13;
397 static av_always_inline int dv_rl2vlc(int run, int l, int sign, uint32_t* vlc)
399 *vlc = dv_vlc_map[run][l].vlc | sign;
400 return dv_vlc_map[run][l].size;
403 static av_always_inline int dv_rl2vlc_size(int run, int l)
405 return dv_vlc_map[run][l].size;
409 typedef struct EncBlockInfo {
419 uint8_t partial_bit_count;
420 uint32_t partial_bit_buffer; /* we can't use uint16_t here */
423 static av_always_inline PutBitContext* dv_encode_ac(EncBlockInfo* bi,
424 PutBitContext* pb_pool,
425 PutBitContext* pb_end)
428 PutBitContext* pb = pb_pool;
429 int size = bi->partial_bit_count;
430 uint32_t vlc = bi->partial_bit_buffer;
432 bi->partial_bit_count = bi->partial_bit_buffer = 0;
434 /* Find suitable storage space */
435 for (; size > (bits_left = put_bits_left(pb)); pb++) {
438 put_bits(pb, bits_left, vlc >> size);
439 vlc = vlc & ((1 << size) - 1);
441 if (pb + 1 >= pb_end) {
442 bi->partial_bit_count = size;
443 bi->partial_bit_buffer = vlc;
449 put_bits(pb, size, vlc);
451 if (bi->cur_ac >= 64)
454 /* Construct the next VLC */
456 bi->cur_ac = bi->next[prev];
457 if (bi->cur_ac < 64){
458 size = dv_rl2vlc(bi->cur_ac - prev - 1, bi->mb[bi->cur_ac], bi->sign[bi->cur_ac], &vlc);
460 size = 4; vlc = 6; /* End Of Block stamp */
466 static av_always_inline int dv_guess_dct_mode(DVVideoContext *s, uint8_t *data, int linesize) {
467 if (s->avctx->flags & CODEC_FLAG_INTERLACED_DCT) {
468 int ps = s->ildct_cmp(NULL, data, NULL, linesize, 8) - 400;
470 int is = s->ildct_cmp(NULL, data , NULL, linesize<<1, 4) +
471 s->ildct_cmp(NULL, data + linesize, NULL, linesize<<1, 4);
479 static const int dv_weight_bits = 18;
480 static const int dv_weight_88[64] = {
481 131072, 257107, 257107, 242189, 252167, 242189, 235923, 237536,
482 237536, 235923, 229376, 231390, 223754, 231390, 229376, 222935,
483 224969, 217965, 217965, 224969, 222935, 200636, 218652, 211916,
484 212325, 211916, 218652, 200636, 188995, 196781, 205965, 206433,
485 206433, 205965, 196781, 188995, 185364, 185364, 200636, 200704,
486 200636, 185364, 185364, 174609, 180568, 195068, 195068, 180568,
487 174609, 170091, 175557, 189591, 175557, 170091, 165371, 170627,
488 170627, 165371, 160727, 153560, 160727, 144651, 144651, 136258,
490 static const int dv_weight_248[64] = {
491 131072, 242189, 257107, 237536, 229376, 200636, 242189, 223754,
492 224969, 196781, 262144, 242189, 229376, 200636, 257107, 237536,
493 211916, 185364, 235923, 217965, 229376, 211916, 206433, 180568,
494 242189, 223754, 224969, 196781, 211916, 185364, 235923, 217965,
495 200704, 175557, 222935, 205965, 200636, 185364, 195068, 170627,
496 229376, 211916, 206433, 180568, 200704, 175557, 222935, 205965,
497 175557, 153560, 188995, 174609, 165371, 144651, 200636, 185364,
498 195068, 170627, 175557, 153560, 188995, 174609, 165371, 144651,
501 static av_always_inline int dv_init_enc_block(EncBlockInfo* bi, uint8_t *data, int linesize, DVVideoContext *s, int bias)
504 const uint8_t* zigzag_scan;
505 LOCAL_ALIGNED_16(int16_t, blk, [64]);
507 /* We offer two different methods for class number assignment: the
508 method suggested in SMPTE 314M Table 22, and an improved
509 method. The SMPTE method is very conservative; it assigns class
510 3 (i.e. severe quantization) to any block where the largest AC
511 component is greater than 36. FFmpeg's DV encoder tracks AC bit
512 consumption precisely, so there is no need to bias most blocks
513 towards strongly lossy compression. Instead, we assign class 2
514 to most blocks, and use class 3 only when strictly necessary
515 (for blocks whose largest AC component exceeds 255). */
517 #if 0 /* SMPTE spec method */
518 static const int classes[] = {12, 24, 36, 0xffff};
519 #else /* improved FFmpeg method */
520 static const int classes[] = {-1, -1, 255, 0xffff};
522 int max = classes[0];
525 av_assert2((((int)blk) & 15) == 0);
527 bi->area_q[0] = bi->area_q[1] = bi->area_q[2] = bi->area_q[3] = 0;
528 bi->partial_bit_count = 0;
529 bi->partial_bit_buffer = 0;
532 bi->dct_mode = dv_guess_dct_mode(s, data, linesize);
533 s->get_pixels(blk, data, linesize);
534 s->fdct[bi->dct_mode](blk);
536 /* We rely on the fact that encoding all zeros leads to an immediate EOB,
537 which is precisely what the spec calls for in the "dummy" blocks. */
538 memset(blk, 0, 64*sizeof(*blk));
543 zigzag_scan = bi->dct_mode ? ff_zigzag248_direct : ff_zigzag_direct;
544 weight = bi->dct_mode ? dv_weight_248 : dv_weight_88;
546 for (area = 0; area < 4; area++) {
547 bi->prev[area] = prev;
548 bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
549 for (i = mb_area_start[area]; i < mb_area_start[area+1]; i++) {
550 int level = blk[zigzag_scan[i]];
552 if (level + 15 > 30U) {
553 bi->sign[i] = (level >> 31) & 1;
554 /* weight it and shift down into range, adding for rounding */
555 /* the extra division by a factor of 2^4 reverses the 8x expansion of the DCT
556 AND the 2x doubling of the weights */
557 level = (FFABS(level) * weight[i] + (1 << (dv_weight_bits+3))) >> (dv_weight_bits+4);
561 bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, level);
568 for (bi->cno = 0; max > classes[bi->cno]; bi->cno++);
576 for (area = 0; area < 4; area++) {
577 bi->prev[area] = prev;
578 bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
579 for (; i < mb_area_start[area+1]; i = bi->next[i]) {
583 bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, bi->mb[i]);
592 return bi->bit_size[0] + bi->bit_size[1] + bi->bit_size[2] + bi->bit_size[3];
595 static inline void dv_guess_qnos(EncBlockInfo* blks, int* qnos)
598 int i, j, k, a, prev, a2;
601 size[0] = size[1] = size[2] = size[3] = size[4] = 1 << 24;
604 for (i = 0; i < 5; i++) {
610 for (j = 0; j < 6; j++, b++) {
611 for (a = 0; a < 4; a++) {
612 if (b->area_q[a] != ff_dv_quant_shifts[qnos[i] + ff_dv_quant_offset[b->cno]][a]) {
613 b->bit_size[a] = 1; // 4 areas 4 bits for EOB :)
616 av_assert2(b->next[prev] >= mb_area_start[a+1] || b->mb[prev]);
617 for (k = b->next[prev] ; k < mb_area_start[a+1]; k = b->next[k]) {
620 b->bit_size[a] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
623 if (b->next[k] >= mb_area_start[a+1] && b->next[k]<64){
624 for (a2 = a + 1; b->next[k] >= mb_area_start[a2+1]; a2++)
627 av_assert2(b->mb[b->next[k]]);
628 b->bit_size[a2] += dv_rl2vlc_size(b->next[k] - prev - 1, b->mb[b->next[k]])
629 -dv_rl2vlc_size(b->next[k] - k - 1, b->mb[b->next[k]]);
630 av_assert2(b->prev[a2] == k && (a2 + 1 >= 4 || b->prev[a2+1] != k));
633 b->next[prev] = b->next[k];
638 size[i] += b->bit_size[a];
641 if (vs_total_ac_bits >= size[0] + size[1] + size[2] + size[3] + size[4])
644 } while (qnos[0]|qnos[1]|qnos[2]|qnos[3]|qnos[4]);
647 for (a = 2; a == 2 || vs_total_ac_bits < size[0]; a += a){
649 size[0] = 5 * 6 * 4; //EOB
650 for (j = 0; j < 6 *5; j++, b++) {
652 for (k = b->next[prev]; k < 64; k = b->next[k]) {
653 if (b->mb[k] < a && b->mb[k] > -a){
654 b->next[prev] = b->next[k];
656 size[0] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
664 static int dv_encode_video_segment(AVCodecContext *avctx, void *arg)
666 DVVideoContext *s = avctx->priv_data;
667 DVwork_chunk *work_chunk = arg;
669 int mb_x, mb_y, c_offset, linesize, y_stride;
672 LOCAL_ALIGNED_8(uint8_t, scratch, [128]);
673 EncBlockInfo enc_blks[5*DV_MAX_BPM];
674 PutBitContext pbs[5*DV_MAX_BPM];
676 EncBlockInfo* enc_blk;
678 int qnos[5] = {15, 15, 15, 15, 15}; /* No quantization */
679 int* qnosp = &qnos[0];
681 dif = &s->buf[work_chunk->buf_offset*80];
682 enc_blk = &enc_blks[0];
683 for (mb_index = 0; mb_index < 5; mb_index++) {
684 dv_calculate_mb_xy(s, work_chunk, mb_index, &mb_x, &mb_y);
686 /* initializing luminance blocks */
687 if ((s->sys->pix_fmt == AV_PIX_FMT_YUV420P) ||
688 (s->sys->pix_fmt == AV_PIX_FMT_YUV411P && mb_x >= (704 / 8)) ||
689 (s->sys->height >= 720 && mb_y != 134)) {
690 y_stride = s->picture.linesize[0] << 3;
694 y_ptr = s->picture.data[0] + ((mb_y * s->picture.linesize[0] + mb_x) << 3);
695 linesize = s->picture.linesize[0];
697 if (s->sys->video_stype == 4) { /* SD 422 */
699 dv_init_enc_block(enc_blk+0, y_ptr , linesize, s, 0) +
700 dv_init_enc_block(enc_blk+1, NULL , linesize, s, 0) +
701 dv_init_enc_block(enc_blk+2, y_ptr + 8 , linesize, s, 0) +
702 dv_init_enc_block(enc_blk+3, NULL , linesize, s, 0);
705 dv_init_enc_block(enc_blk+0, y_ptr , linesize, s, 0) +
706 dv_init_enc_block(enc_blk+1, y_ptr + 8 , linesize, s, 0) +
707 dv_init_enc_block(enc_blk+2, y_ptr + y_stride, linesize, s, 0) +
708 dv_init_enc_block(enc_blk+3, y_ptr + 8 + y_stride, linesize, s, 0);
712 /* initializing chrominance blocks */
713 c_offset = (((mb_y >> (s->sys->pix_fmt == AV_PIX_FMT_YUV420P)) * s->picture.linesize[1] +
714 (mb_x >> ((s->sys->pix_fmt == AV_PIX_FMT_YUV411P) ? 2 : 1))) << 3);
715 for (j = 2; j; j--) {
716 uint8_t *c_ptr = s->picture.data[j] + c_offset;
717 linesize = s->picture.linesize[j];
718 y_stride = (mb_y == 134) ? 8 : (s->picture.linesize[j] << 3);
719 if (s->sys->pix_fmt == AV_PIX_FMT_YUV411P && mb_x >= (704 / 8)) {
721 uint8_t* b = scratch;
722 for (i = 0; i < 8; i++) {
723 d = c_ptr + (linesize << 3);
724 b[0] = c_ptr[0]; b[1] = c_ptr[1]; b[2] = c_ptr[2]; b[3] = c_ptr[3];
725 b[4] = d[0]; b[5] = d[1]; b[6] = d[2]; b[7] = d[3];
733 vs_bit_size += dv_init_enc_block( enc_blk++, c_ptr , linesize, s, 1);
734 if (s->sys->bpm == 8) {
735 vs_bit_size += dv_init_enc_block(enc_blk++, c_ptr + y_stride, linesize, s, 1);
740 if (vs_total_ac_bits < vs_bit_size)
741 dv_guess_qnos(&enc_blks[0], qnosp);
743 /* DIF encoding process */
744 for (j=0; j<5*s->sys->bpm;) {
750 /* First pass over individual cells only */
751 for (i=0; i<s->sys->bpm; i++, j++) {
752 int sz = s->sys->block_sizes[i]>>3;
754 init_put_bits(&pbs[j], dif, sz);
755 put_sbits(&pbs[j], 9, ((enc_blks[j].mb[0] >> 3) - 1024 + 2) >> 2);
756 put_bits(&pbs[j], 1, enc_blks[j].dct_mode);
757 put_bits(&pbs[j], 2, enc_blks[j].cno);
759 dv_encode_ac(&enc_blks[j], &pbs[j], &pbs[j+1]);
763 /* Second pass over each MB space */
765 for (i=0; i<s->sys->bpm; i++) {
766 if (enc_blks[start_mb+i].partial_bit_count)
767 pb = dv_encode_ac(&enc_blks[start_mb+i], pb, &pbs[start_mb+s->sys->bpm]);
771 /* Third and final pass over the whole video segment space */
773 for (j=0; j<5*s->sys->bpm; j++) {
774 if (enc_blks[j].partial_bit_count)
775 pb = dv_encode_ac(&enc_blks[j], pb, &pbs[s->sys->bpm*5]);
776 if (enc_blks[j].partial_bit_count)
777 av_log(avctx, AV_LOG_ERROR, "ac bitstream overflow\n");
780 for (j=0; j<5*s->sys->bpm; j++) {
782 int size = pbs[j].size_in_bits >> 3;
783 flush_put_bits(&pbs[j]);
784 pos = put_bits_count(&pbs[j]) >> 3;
786 av_log(avctx, AV_LOG_ERROR, "bitstream written beyond buffer size\n");
789 memset(pbs[j].buf + pos, 0xff, size - pos);
795 static inline int dv_write_pack(enum dv_pack_type pack_id, DVVideoContext *c,
799 * Here's what SMPTE314M says about these two:
800 * (page 6) APTn, AP1n, AP2n, AP3n: These data shall be identical
801 * as track application IDs (APTn = 001, AP1n =
802 * 001, AP2n = 001, AP3n = 001), if the source signal
803 * comes from a digital VCR. If the signal source is
804 * unknown, all bits for these data shall be set to 1.
805 * (page 12) STYPE: STYPE defines a signal type of video signal
806 * 00000b = 4:1:1 compression
807 * 00100b = 4:2:2 compression
809 * Now, I've got two problems with these statements:
810 * 1. it looks like APT == 111b should be a safe bet, but it isn't.
811 * It seems that for PAL as defined in IEC 61834 we have to set
812 * APT to 000 and for SMPTE314M to 001.
813 * 2. It is not at all clear what STYPE is used for 4:2:0 PAL
814 * compression scheme (if any).
816 int apt = (c->sys->pix_fmt == AV_PIX_FMT_YUV420P ? 0 : 1);
817 int fs = c->picture.top_field_first ? 0x00 : 0x40;
820 if ((int)(av_q2d(c->avctx->sample_aspect_ratio) * c->avctx->width / c->avctx->height * 10) >= 17) /* 16:9 */
823 buf[0] = (uint8_t)pack_id;
825 case dv_header525: /* I can't imagine why these two weren't defined as real */
826 case dv_header625: /* packs in SMPTE314M -- they definitely look like ones */
827 buf[1] = 0xf8 | /* reserved -- always 1 */
828 (apt & 0x07); /* APT: Track application ID */
829 buf[2] = (0 << 7) | /* TF1: audio data is 0 - valid; 1 - invalid */
830 (0x0f << 3) | /* reserved -- always 1 */
831 (apt & 0x07); /* AP1: Audio application ID */
832 buf[3] = (0 << 7) | /* TF2: video data is 0 - valid; 1 - invalid */
833 (0x0f << 3) | /* reserved -- always 1 */
834 (apt & 0x07); /* AP2: Video application ID */
835 buf[4] = (0 << 7) | /* TF3: subcode(SSYB) is 0 - valid; 1 - invalid */
836 (0x0f << 3) | /* reserved -- always 1 */
837 (apt & 0x07); /* AP3: Subcode application ID */
839 case dv_video_source:
840 buf[1] = 0xff; /* reserved -- always 1 */
841 buf[2] = (1 << 7) | /* B/W: 0 - b/w, 1 - color */
842 (1 << 6) | /* following CLF is valid - 0, invalid - 1 */
843 (3 << 4) | /* CLF: color frames ID (see ITU-R BT.470-4) */
844 0xf; /* reserved -- always 1 */
845 buf[3] = (3 << 6) | /* reserved -- always 1 */
846 (c->sys->dsf << 5) | /* system: 60fields/50fields */
847 c->sys->video_stype; /* signal type video compression */
848 buf[4] = 0xff; /* VISC: 0xff -- no information */
850 case dv_video_control:
851 buf[1] = (0 << 6) | /* Copy generation management (CGMS) 0 -- free */
852 0x3f; /* reserved -- always 1 */
853 buf[2] = 0xc8 | /* reserved -- always b11001xxx */
855 buf[3] = (1 << 7) | /* frame/field flag 1 -- frame, 0 -- field */
856 fs | /* first/second field flag 0 -- field 2, 1 -- field 1 */
857 (1 << 5) | /* frame change flag 0 -- same picture as before, 1 -- different */
858 (1 << 4) | /* 1 - interlaced, 0 - noninterlaced */
859 0xc; /* reserved -- always b1100 */
860 buf[4] = 0xff; /* reserved -- always 1 */
863 buf[1] = buf[2] = buf[3] = buf[4] = 0xff;
868 #if CONFIG_DVVIDEO_ENCODER
869 static inline int dv_write_dif_id(enum dv_section_type t, uint8_t chan_num,
870 uint8_t seq_num, uint8_t dif_num,
873 buf[0] = (uint8_t)t; /* Section type */
874 buf[1] = (seq_num << 4) | /* DIF seq number 0-9 for 525/60; 0-11 for 625/50 */
875 (chan_num << 3) | /* FSC: for 50Mb/s 0 - first channel; 1 - second */
876 7; /* reserved -- always 1 */
877 buf[2] = dif_num; /* DIF block number Video: 0-134, Audio: 0-8 */
882 static inline int dv_write_ssyb_id(uint8_t syb_num, uint8_t fr, uint8_t* buf)
884 if (syb_num == 0 || syb_num == 6) {
885 buf[0] = (fr << 7) | /* FR ID 1 - first half of each channel; 0 - second */
886 (0 << 4) | /* AP3 (Subcode application ID) */
887 0x0f; /* reserved -- always 1 */
889 else if (syb_num == 11) {
890 buf[0] = (fr << 7) | /* FR ID 1 - first half of each channel; 0 - second */
891 0x7f; /* reserved -- always 1 */
894 buf[0] = (fr << 7) | /* FR ID 1 - first half of each channel; 0 - second */
895 (0 << 4) | /* APT (Track application ID) */
896 0x0f; /* reserved -- always 1 */
898 buf[1] = 0xf0 | /* reserved -- always 1 */
899 (syb_num & 0x0f); /* SSYB number 0 - 11 */
900 buf[2] = 0xff; /* reserved -- always 1 */
904 static void dv_format_frame(DVVideoContext* c, uint8_t* buf)
908 for (chan = 0; chan < c->sys->n_difchan; chan++) {
909 for (i = 0; i < c->sys->difseg_size; i++) {
910 memset(buf, 0xff, 80 * 6); /* first 6 DIF blocks are for control data */
912 /* DV header: 1DIF */
913 buf += dv_write_dif_id(dv_sect_header, chan, i, 0, buf);
914 buf += dv_write_pack((c->sys->dsf ? dv_header625 : dv_header525), c, buf);
915 buf += 72; /* unused bytes */
917 /* DV subcode: 2DIFs */
918 for (j = 0; j < 2; j++) {
919 buf += dv_write_dif_id(dv_sect_subcode, chan, i, j, buf);
920 for (k = 0; k < 6; k++)
921 buf += dv_write_ssyb_id(k, (i < c->sys->difseg_size/2), buf) + 5;
922 buf += 29; /* unused bytes */
926 for (j = 0; j < 3; j++) {
927 buf += dv_write_dif_id(dv_sect_vaux, chan, i, j, buf);
928 buf += dv_write_pack(dv_video_source, c, buf);
929 buf += dv_write_pack(dv_video_control, c, buf);
931 buf += dv_write_pack(dv_video_source, c, buf);
932 buf += dv_write_pack(dv_video_control, c, buf);
933 buf += 4*5 + 2; /* unused bytes */
936 /* DV Audio/Video: 135 Video DIFs + 9 Audio DIFs */
937 for (j = 0; j < 135; j++) {
939 memset(buf, 0xff, 80);
940 buf += dv_write_dif_id(dv_sect_audio, chan, i, j/15, buf);
941 buf += 77; /* audio control & shuffled PCM audio */
943 buf += dv_write_dif_id(dv_sect_video, chan, i, j, buf);
944 buf += 77; /* 1 video macroblock: 1 bytes control
945 4 * 14 bytes Y 8x8 data
947 10 bytes Cb 8x8 data */
954 static int dvvideo_encode_frame(AVCodecContext *c, AVPacket *pkt,
955 const AVFrame *frame, int *got_packet)
957 DVVideoContext *s = c->priv_data;
960 s->sys = avpriv_dv_codec_profile(c);
961 if (!s->sys || ff_dv_init_dynamic_tables(s->sys))
963 if ((ret = ff_alloc_packet2(c, pkt, s->sys->frame_size)) < 0)
966 c->pix_fmt = s->sys->pix_fmt;
968 s->picture.key_frame = 1;
969 s->picture.pict_type = AV_PICTURE_TYPE_I;
972 c->execute(c, dv_encode_video_segment, s->sys->work_chunks, NULL,
973 dv_work_pool_size(s->sys), sizeof(DVwork_chunk));
977 dv_format_frame(s, pkt->data);
979 pkt->flags |= AV_PKT_FLAG_KEY;
985 AVCodec ff_dvvideo_encoder = {
987 .type = AVMEDIA_TYPE_VIDEO,
988 .id = AV_CODEC_ID_DVVIDEO,
989 .priv_data_size = sizeof(DVVideoContext),
990 .init = dvvideo_init_encoder,
991 .encode2 = dvvideo_encode_frame,
992 .capabilities = CODEC_CAP_SLICE_THREADS,
993 .pix_fmts = (const enum AVPixelFormat[]) {
994 AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE
996 .long_name = NULL_IF_CONFIG_SMALL("DV (Digital Video)"),
998 #endif // CONFIG_DVVIDEO_ENCODER