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 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 avctx->coded_frame = &s->picture;
325 avctx->chroma_sample_location = AVCHROMA_LOC_TOPLEFT;
330 static av_cold int dvvideo_init_encoder(AVCodecContext *avctx)
332 if (!avpriv_dv_codec_profile(avctx)) {
333 av_log(avctx, AV_LOG_ERROR, "Found no DV profile for %ix%i %s video. "
334 "Valid DV profiles are:\n",
335 avctx->width, avctx->height, av_get_pix_fmt_name(avctx->pix_fmt));
336 ff_dv_print_profiles(avctx, AV_LOG_ERROR);
337 return AVERROR(EINVAL);
339 if (avctx->height > 576) {
340 av_log(avctx, AV_LOG_ERROR, "DVCPRO HD encoding is not supported.\n");
341 return AVERROR_PATCHWELCOME;
344 dv_vlc_map_tableinit();
346 return ff_dvvideo_init(avctx);
349 /* bit budget for AC only in 5 MBs */
350 static const int vs_total_ac_bits = (100 * 4 + 68*2) * 5;
351 static const int mb_area_start[5] = { 1, 6, 21, 43, 64 };
353 static inline int put_bits_left(PutBitContext* s)
355 return (s->buf_end - s->buf) * 8 - put_bits_count(s);
359 /* Converts run and level (where level != 0) pair into VLC, returning bit size */
360 static av_always_inline int dv_rl2vlc(int run, int level, int sign, uint32_t* vlc)
363 if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {
364 *vlc = dv_vlc_map[run][level].vlc | sign;
365 size = dv_vlc_map[run][level].size;
368 if (level < DV_VLC_MAP_LEV_SIZE) {
369 *vlc = dv_vlc_map[0][level].vlc | sign;
370 size = dv_vlc_map[0][level].size;
372 *vlc = 0xfe00 | (level << 1) | sign;
376 *vlc |= ((run < 16) ? dv_vlc_map[run-1][0].vlc :
377 (0x1f80 | (run - 1))) << size;
378 size += (run < 16) ? dv_vlc_map[run-1][0].size : 13;
385 static av_always_inline int dv_rl2vlc_size(int run, int level)
389 if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {
390 size = dv_vlc_map[run][level].size;
393 size = (level < DV_VLC_MAP_LEV_SIZE) ? dv_vlc_map[0][level].size : 16;
395 size += (run < 16) ? dv_vlc_map[run-1][0].size : 13;
401 static av_always_inline int dv_rl2vlc(int run, int l, int sign, uint32_t* vlc)
403 *vlc = dv_vlc_map[run][l].vlc | sign;
404 return dv_vlc_map[run][l].size;
407 static av_always_inline int dv_rl2vlc_size(int run, int l)
409 return dv_vlc_map[run][l].size;
413 typedef struct EncBlockInfo {
423 uint8_t partial_bit_count;
424 uint32_t partial_bit_buffer; /* we can't use uint16_t here */
427 static av_always_inline PutBitContext* dv_encode_ac(EncBlockInfo* bi,
428 PutBitContext* pb_pool,
429 PutBitContext* pb_end)
432 PutBitContext* pb = pb_pool;
433 int size = bi->partial_bit_count;
434 uint32_t vlc = bi->partial_bit_buffer;
436 bi->partial_bit_count = bi->partial_bit_buffer = 0;
438 /* Find suitable storage space */
439 for (; size > (bits_left = put_bits_left(pb)); pb++) {
442 put_bits(pb, bits_left, vlc >> size);
443 vlc = vlc & ((1 << size) - 1);
445 if (pb + 1 >= pb_end) {
446 bi->partial_bit_count = size;
447 bi->partial_bit_buffer = vlc;
453 put_bits(pb, size, vlc);
455 if (bi->cur_ac >= 64)
458 /* Construct the next VLC */
460 bi->cur_ac = bi->next[prev];
461 if (bi->cur_ac < 64){
462 size = dv_rl2vlc(bi->cur_ac - prev - 1, bi->mb[bi->cur_ac], bi->sign[bi->cur_ac], &vlc);
464 size = 4; vlc = 6; /* End Of Block stamp */
470 static av_always_inline int dv_guess_dct_mode(DVVideoContext *s, uint8_t *data, int linesize) {
471 if (s->avctx->flags & CODEC_FLAG_INTERLACED_DCT) {
472 int ps = s->ildct_cmp(NULL, data, NULL, linesize, 8) - 400;
474 int is = s->ildct_cmp(NULL, data , NULL, linesize<<1, 4) +
475 s->ildct_cmp(NULL, data + linesize, NULL, linesize<<1, 4);
483 static const int dv_weight_bits = 18;
484 static const int dv_weight_88[64] = {
485 131072, 257107, 257107, 242189, 252167, 242189, 235923, 237536,
486 237536, 235923, 229376, 231390, 223754, 231390, 229376, 222935,
487 224969, 217965, 217965, 224969, 222935, 200636, 218652, 211916,
488 212325, 211916, 218652, 200636, 188995, 196781, 205965, 206433,
489 206433, 205965, 196781, 188995, 185364, 185364, 200636, 200704,
490 200636, 185364, 185364, 174609, 180568, 195068, 195068, 180568,
491 174609, 170091, 175557, 189591, 175557, 170091, 165371, 170627,
492 170627, 165371, 160727, 153560, 160727, 144651, 144651, 136258,
494 static const int dv_weight_248[64] = {
495 131072, 242189, 257107, 237536, 229376, 200636, 242189, 223754,
496 224969, 196781, 262144, 242189, 229376, 200636, 257107, 237536,
497 211916, 185364, 235923, 217965, 229376, 211916, 206433, 180568,
498 242189, 223754, 224969, 196781, 211916, 185364, 235923, 217965,
499 200704, 175557, 222935, 205965, 200636, 185364, 195068, 170627,
500 229376, 211916, 206433, 180568, 200704, 175557, 222935, 205965,
501 175557, 153560, 188995, 174609, 165371, 144651, 200636, 185364,
502 195068, 170627, 175557, 153560, 188995, 174609, 165371, 144651,
505 static av_always_inline int dv_init_enc_block(EncBlockInfo* bi, uint8_t *data, int linesize, DVVideoContext *s, int bias)
508 const uint8_t* zigzag_scan;
509 LOCAL_ALIGNED_16(int16_t, blk, [64]);
511 /* We offer two different methods for class number assignment: the
512 method suggested in SMPTE 314M Table 22, and an improved
513 method. The SMPTE method is very conservative; it assigns class
514 3 (i.e. severe quantization) to any block where the largest AC
515 component is greater than 36. FFmpeg's DV encoder tracks AC bit
516 consumption precisely, so there is no need to bias most blocks
517 towards strongly lossy compression. Instead, we assign class 2
518 to most blocks, and use class 3 only when strictly necessary
519 (for blocks whose largest AC component exceeds 255). */
521 #if 0 /* SMPTE spec method */
522 static const int classes[] = {12, 24, 36, 0xffff};
523 #else /* improved FFmpeg method */
524 static const int classes[] = {-1, -1, 255, 0xffff};
526 int max = classes[0];
529 av_assert2((((int)blk) & 15) == 0);
531 bi->area_q[0] = bi->area_q[1] = bi->area_q[2] = bi->area_q[3] = 0;
532 bi->partial_bit_count = 0;
533 bi->partial_bit_buffer = 0;
536 bi->dct_mode = dv_guess_dct_mode(s, data, linesize);
537 s->get_pixels(blk, data, linesize);
538 s->fdct[bi->dct_mode](blk);
540 /* We rely on the fact that encoding all zeros leads to an immediate EOB,
541 which is precisely what the spec calls for in the "dummy" blocks. */
542 memset(blk, 0, 64*sizeof(*blk));
547 zigzag_scan = bi->dct_mode ? ff_zigzag248_direct : ff_zigzag_direct;
548 weight = bi->dct_mode ? dv_weight_248 : dv_weight_88;
550 for (area = 0; area < 4; area++) {
551 bi->prev[area] = prev;
552 bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
553 for (i = mb_area_start[area]; i < mb_area_start[area+1]; i++) {
554 int level = blk[zigzag_scan[i]];
556 if (level + 15 > 30U) {
557 bi->sign[i] = (level >> 31) & 1;
558 /* weight it and and shift down into range, adding for rounding */
559 /* the extra division by a factor of 2^4 reverses the 8x expansion of the DCT
560 AND the 2x doubling of the weights */
561 level = (FFABS(level) * weight[i] + (1 << (dv_weight_bits+3))) >> (dv_weight_bits+4);
565 bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, level);
572 for (bi->cno = 0; max > classes[bi->cno]; bi->cno++);
580 for (area = 0; area < 4; area++) {
581 bi->prev[area] = prev;
582 bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
583 for (; i < mb_area_start[area+1]; i = bi->next[i]) {
587 bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, bi->mb[i]);
596 return bi->bit_size[0] + bi->bit_size[1] + bi->bit_size[2] + bi->bit_size[3];
599 static inline void dv_guess_qnos(EncBlockInfo* blks, int* qnos)
602 int i, j, k, a, prev, a2;
605 size[0] = size[1] = size[2] = size[3] = size[4] = 1 << 24;
608 for (i = 0; i < 5; i++) {
614 for (j = 0; j < 6; j++, b++) {
615 for (a = 0; a < 4; a++) {
616 if (b->area_q[a] != ff_dv_quant_shifts[qnos[i] + ff_dv_quant_offset[b->cno]][a]) {
617 b->bit_size[a] = 1; // 4 areas 4 bits for EOB :)
620 av_assert2(b->next[prev] >= mb_area_start[a+1] || b->mb[prev]);
621 for (k = b->next[prev] ; k < mb_area_start[a+1]; k = b->next[k]) {
624 b->bit_size[a] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
627 if (b->next[k] >= mb_area_start[a+1] && b->next[k]<64){
628 for (a2 = a + 1; b->next[k] >= mb_area_start[a2+1]; a2++)
631 av_assert2(b->mb[b->next[k]]);
632 b->bit_size[a2] += dv_rl2vlc_size(b->next[k] - prev - 1, b->mb[b->next[k]])
633 -dv_rl2vlc_size(b->next[k] - k - 1, b->mb[b->next[k]]);
634 av_assert2(b->prev[a2] == k && (a2 + 1 >= 4 || b->prev[a2+1] != k));
637 b->next[prev] = b->next[k];
642 size[i] += b->bit_size[a];
645 if (vs_total_ac_bits >= size[0] + size[1] + size[2] + size[3] + size[4])
648 } while (qnos[0]|qnos[1]|qnos[2]|qnos[3]|qnos[4]);
651 for (a = 2; a == 2 || vs_total_ac_bits < size[0]; a += a){
653 size[0] = 5 * 6 * 4; //EOB
654 for (j = 0; j < 6 *5; j++, b++) {
656 for (k = b->next[prev]; k < 64; k = b->next[k]) {
657 if (b->mb[k] < a && b->mb[k] > -a){
658 b->next[prev] = b->next[k];
660 size[0] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
668 static int dv_encode_video_segment(AVCodecContext *avctx, void *arg)
670 DVVideoContext *s = avctx->priv_data;
671 DVwork_chunk *work_chunk = arg;
673 int mb_x, mb_y, c_offset, linesize, y_stride;
676 LOCAL_ALIGNED_8(uint8_t, scratch, [128]);
677 EncBlockInfo enc_blks[5*DV_MAX_BPM];
678 PutBitContext pbs[5*DV_MAX_BPM];
680 EncBlockInfo* enc_blk;
682 int qnos[5] = {15, 15, 15, 15, 15}; /* No quantization */
683 int* qnosp = &qnos[0];
685 dif = &s->buf[work_chunk->buf_offset*80];
686 enc_blk = &enc_blks[0];
687 for (mb_index = 0; mb_index < 5; mb_index++) {
688 dv_calculate_mb_xy(s, work_chunk, mb_index, &mb_x, &mb_y);
690 /* initializing luminance blocks */
691 if ((s->sys->pix_fmt == AV_PIX_FMT_YUV420P) ||
692 (s->sys->pix_fmt == AV_PIX_FMT_YUV411P && mb_x >= (704 / 8)) ||
693 (s->sys->height >= 720 && mb_y != 134)) {
694 y_stride = s->picture.linesize[0] << 3;
698 y_ptr = s->picture.data[0] + ((mb_y * s->picture.linesize[0] + mb_x) << 3);
699 linesize = s->picture.linesize[0];
701 if (s->sys->video_stype == 4) { /* SD 422 */
703 dv_init_enc_block(enc_blk+0, y_ptr , linesize, s, 0) +
704 dv_init_enc_block(enc_blk+1, NULL , linesize, s, 0) +
705 dv_init_enc_block(enc_blk+2, y_ptr + 8 , linesize, s, 0) +
706 dv_init_enc_block(enc_blk+3, NULL , linesize, s, 0);
709 dv_init_enc_block(enc_blk+0, y_ptr , linesize, s, 0) +
710 dv_init_enc_block(enc_blk+1, y_ptr + 8 , linesize, s, 0) +
711 dv_init_enc_block(enc_blk+2, y_ptr + y_stride, linesize, s, 0) +
712 dv_init_enc_block(enc_blk+3, y_ptr + 8 + y_stride, linesize, s, 0);
716 /* initializing chrominance blocks */
717 c_offset = (((mb_y >> (s->sys->pix_fmt == AV_PIX_FMT_YUV420P)) * s->picture.linesize[1] +
718 (mb_x >> ((s->sys->pix_fmt == AV_PIX_FMT_YUV411P) ? 2 : 1))) << 3);
719 for (j = 2; j; j--) {
720 uint8_t *c_ptr = s->picture.data[j] + c_offset;
721 linesize = s->picture.linesize[j];
722 y_stride = (mb_y == 134) ? 8 : (s->picture.linesize[j] << 3);
723 if (s->sys->pix_fmt == AV_PIX_FMT_YUV411P && mb_x >= (704 / 8)) {
725 uint8_t* b = scratch;
726 for (i = 0; i < 8; i++) {
727 d = c_ptr + (linesize << 3);
728 b[0] = c_ptr[0]; b[1] = c_ptr[1]; b[2] = c_ptr[2]; b[3] = c_ptr[3];
729 b[4] = d[0]; b[5] = d[1]; b[6] = d[2]; b[7] = d[3];
737 vs_bit_size += dv_init_enc_block( enc_blk++, c_ptr , linesize, s, 1);
738 if (s->sys->bpm == 8) {
739 vs_bit_size += dv_init_enc_block(enc_blk++, c_ptr + y_stride, linesize, s, 1);
744 if (vs_total_ac_bits < vs_bit_size)
745 dv_guess_qnos(&enc_blks[0], qnosp);
747 /* DIF encoding process */
748 for (j=0; j<5*s->sys->bpm;) {
754 /* First pass over individual cells only */
755 for (i=0; i<s->sys->bpm; i++, j++) {
756 int sz = s->sys->block_sizes[i]>>3;
758 init_put_bits(&pbs[j], dif, sz);
759 put_sbits(&pbs[j], 9, ((enc_blks[j].mb[0] >> 3) - 1024 + 2) >> 2);
760 put_bits(&pbs[j], 1, enc_blks[j].dct_mode);
761 put_bits(&pbs[j], 2, enc_blks[j].cno);
763 dv_encode_ac(&enc_blks[j], &pbs[j], &pbs[j+1]);
767 /* Second pass over each MB space */
769 for (i=0; i<s->sys->bpm; i++) {
770 if (enc_blks[start_mb+i].partial_bit_count)
771 pb = dv_encode_ac(&enc_blks[start_mb+i], pb, &pbs[start_mb+s->sys->bpm]);
775 /* Third and final pass over the whole video segment space */
777 for (j=0; j<5*s->sys->bpm; j++) {
778 if (enc_blks[j].partial_bit_count)
779 pb = dv_encode_ac(&enc_blks[j], pb, &pbs[s->sys->bpm*5]);
780 if (enc_blks[j].partial_bit_count)
781 av_log(avctx, AV_LOG_ERROR, "ac bitstream overflow\n");
784 for (j=0; j<5*s->sys->bpm; j++) {
786 int size = pbs[j].size_in_bits >> 3;
787 flush_put_bits(&pbs[j]);
788 pos = put_bits_count(&pbs[j]) >> 3;
790 av_log(avctx, AV_LOG_ERROR, "bitstream written beyond buffer size\n");
793 memset(pbs[j].buf + pos, 0xff, size - pos);
799 static inline int dv_write_pack(enum dv_pack_type pack_id, DVVideoContext *c,
803 * Here's what SMPTE314M says about these two:
804 * (page 6) APTn, AP1n, AP2n, AP3n: These data shall be identical
805 * as track application IDs (APTn = 001, AP1n =
806 * 001, AP2n = 001, AP3n = 001), if the source signal
807 * comes from a digital VCR. If the signal source is
808 * unknown, all bits for these data shall be set to 1.
809 * (page 12) STYPE: STYPE defines a signal type of video signal
810 * 00000b = 4:1:1 compression
811 * 00100b = 4:2:2 compression
813 * Now, I've got two problems with these statements:
814 * 1. it looks like APT == 111b should be a safe bet, but it isn't.
815 * It seems that for PAL as defined in IEC 61834 we have to set
816 * APT to 000 and for SMPTE314M to 001.
817 * 2. It is not at all clear what STYPE is used for 4:2:0 PAL
818 * compression scheme (if any).
820 int apt = (c->sys->pix_fmt == AV_PIX_FMT_YUV420P ? 0 : 1);
821 int fs = c->picture.top_field_first ? 0x00 : 0x40;
824 if ((int)(av_q2d(c->avctx->sample_aspect_ratio) * c->avctx->width / c->avctx->height * 10) >= 17) /* 16:9 */
827 buf[0] = (uint8_t)pack_id;
829 case dv_header525: /* I can't imagine why these two weren't defined as real */
830 case dv_header625: /* packs in SMPTE314M -- they definitely look like ones */
831 buf[1] = 0xf8 | /* reserved -- always 1 */
832 (apt & 0x07); /* APT: Track application ID */
833 buf[2] = (0 << 7) | /* TF1: audio data is 0 - valid; 1 - invalid */
834 (0x0f << 3) | /* reserved -- always 1 */
835 (apt & 0x07); /* AP1: Audio application ID */
836 buf[3] = (0 << 7) | /* TF2: video data is 0 - valid; 1 - invalid */
837 (0x0f << 3) | /* reserved -- always 1 */
838 (apt & 0x07); /* AP2: Video application ID */
839 buf[4] = (0 << 7) | /* TF3: subcode(SSYB) is 0 - valid; 1 - invalid */
840 (0x0f << 3) | /* reserved -- always 1 */
841 (apt & 0x07); /* AP3: Subcode application ID */
843 case dv_video_source:
844 buf[1] = 0xff; /* reserved -- always 1 */
845 buf[2] = (1 << 7) | /* B/W: 0 - b/w, 1 - color */
846 (1 << 6) | /* following CLF is valid - 0, invalid - 1 */
847 (3 << 4) | /* CLF: color frames ID (see ITU-R BT.470-4) */
848 0xf; /* reserved -- always 1 */
849 buf[3] = (3 << 6) | /* reserved -- always 1 */
850 (c->sys->dsf << 5) | /* system: 60fields/50fields */
851 c->sys->video_stype; /* signal type video compression */
852 buf[4] = 0xff; /* VISC: 0xff -- no information */
854 case dv_video_control:
855 buf[1] = (0 << 6) | /* Copy generation management (CGMS) 0 -- free */
856 0x3f; /* reserved -- always 1 */
857 buf[2] = 0xc8 | /* reserved -- always b11001xxx */
859 buf[3] = (1 << 7) | /* frame/field flag 1 -- frame, 0 -- field */
860 fs | /* first/second field flag 0 -- field 2, 1 -- field 1 */
861 (1 << 5) | /* frame change flag 0 -- same picture as before, 1 -- different */
862 (1 << 4) | /* 1 - interlaced, 0 - noninterlaced */
863 0xc; /* reserved -- always b1100 */
864 buf[4] = 0xff; /* reserved -- always 1 */
867 buf[1] = buf[2] = buf[3] = buf[4] = 0xff;
872 #if CONFIG_DVVIDEO_ENCODER
873 static inline int dv_write_dif_id(enum dv_section_type t, uint8_t chan_num,
874 uint8_t seq_num, uint8_t dif_num,
877 buf[0] = (uint8_t)t; /* Section type */
878 buf[1] = (seq_num << 4) | /* DIF seq number 0-9 for 525/60; 0-11 for 625/50 */
879 (chan_num << 3) | /* FSC: for 50Mb/s 0 - first channel; 1 - second */
880 7; /* reserved -- always 1 */
881 buf[2] = dif_num; /* DIF block number Video: 0-134, Audio: 0-8 */
886 static inline int dv_write_ssyb_id(uint8_t syb_num, uint8_t fr, uint8_t* buf)
888 if (syb_num == 0 || syb_num == 6) {
889 buf[0] = (fr << 7) | /* FR ID 1 - first half of each channel; 0 - second */
890 (0 << 4) | /* AP3 (Subcode application ID) */
891 0x0f; /* reserved -- always 1 */
893 else if (syb_num == 11) {
894 buf[0] = (fr << 7) | /* FR ID 1 - first half of each channel; 0 - second */
895 0x7f; /* reserved -- always 1 */
898 buf[0] = (fr << 7) | /* FR ID 1 - first half of each channel; 0 - second */
899 (0 << 4) | /* APT (Track application ID) */
900 0x0f; /* reserved -- always 1 */
902 buf[1] = 0xf0 | /* reserved -- always 1 */
903 (syb_num & 0x0f); /* SSYB number 0 - 11 */
904 buf[2] = 0xff; /* reserved -- always 1 */
908 static void dv_format_frame(DVVideoContext* c, uint8_t* buf)
912 for (chan = 0; chan < c->sys->n_difchan; chan++) {
913 for (i = 0; i < c->sys->difseg_size; i++) {
914 memset(buf, 0xff, 80 * 6); /* first 6 DIF blocks are for control data */
916 /* DV header: 1DIF */
917 buf += dv_write_dif_id(dv_sect_header, chan, i, 0, buf);
918 buf += dv_write_pack((c->sys->dsf ? dv_header625 : dv_header525), c, buf);
919 buf += 72; /* unused bytes */
921 /* DV subcode: 2DIFs */
922 for (j = 0; j < 2; j++) {
923 buf += dv_write_dif_id(dv_sect_subcode, chan, i, j, buf);
924 for (k = 0; k < 6; k++)
925 buf += dv_write_ssyb_id(k, (i < c->sys->difseg_size/2), buf) + 5;
926 buf += 29; /* unused bytes */
930 for (j = 0; j < 3; j++) {
931 buf += dv_write_dif_id(dv_sect_vaux, chan, i, j, buf);
932 buf += dv_write_pack(dv_video_source, c, buf);
933 buf += dv_write_pack(dv_video_control, c, buf);
935 buf += dv_write_pack(dv_video_source, c, buf);
936 buf += dv_write_pack(dv_video_control, c, buf);
937 buf += 4*5 + 2; /* unused bytes */
940 /* DV Audio/Video: 135 Video DIFs + 9 Audio DIFs */
941 for (j = 0; j < 135; j++) {
943 memset(buf, 0xff, 80);
944 buf += dv_write_dif_id(dv_sect_audio, chan, i, j/15, buf);
945 buf += 77; /* audio control & shuffled PCM audio */
947 buf += dv_write_dif_id(dv_sect_video, chan, i, j, buf);
948 buf += 77; /* 1 video macroblock: 1 bytes control
949 4 * 14 bytes Y 8x8 data
951 10 bytes Cb 8x8 data */
958 static int dvvideo_encode_frame(AVCodecContext *c, AVPacket *pkt,
959 const AVFrame *frame, int *got_packet)
961 DVVideoContext *s = c->priv_data;
964 s->sys = avpriv_dv_codec_profile(c);
965 if (!s->sys || ff_dv_init_dynamic_tables(s->sys))
967 if ((ret = ff_alloc_packet2(c, pkt, s->sys->frame_size)) < 0)
970 c->pix_fmt = s->sys->pix_fmt;
972 s->picture.key_frame = 1;
973 s->picture.pict_type = AV_PICTURE_TYPE_I;
976 c->execute(c, dv_encode_video_segment, s->sys->work_chunks, NULL,
977 dv_work_pool_size(s->sys), sizeof(DVwork_chunk));
981 dv_format_frame(s, pkt->data);
983 pkt->flags |= AV_PKT_FLAG_KEY;
989 AVCodec ff_dvvideo_encoder = {
991 .type = AVMEDIA_TYPE_VIDEO,
992 .id = AV_CODEC_ID_DVVIDEO,
993 .priv_data_size = sizeof(DVVideoContext),
994 .init = dvvideo_init_encoder,
995 .encode2 = dvvideo_encode_frame,
996 .capabilities = CODEC_CAP_SLICE_THREADS,
997 .pix_fmts = (const enum AVPixelFormat[]) {
998 AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE
1000 .long_name = NULL_IF_CONFIG_SMALL("DV (Digital Video)"),
1002 #endif // CONFIG_DVVIDEO_ENCODER