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 };
354 static inline int put_bits_left(PutBitContext* s)
356 return (s->buf_end - s->buf) * 8 - put_bits_count(s);
360 /* Converts run and level (where level != 0) pair into VLC, returning bit size */
361 static av_always_inline int dv_rl2vlc(int run, int level, int sign, uint32_t* vlc)
364 if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {
365 *vlc = dv_vlc_map[run][level].vlc | sign;
366 size = dv_vlc_map[run][level].size;
369 if (level < DV_VLC_MAP_LEV_SIZE) {
370 *vlc = dv_vlc_map[0][level].vlc | sign;
371 size = dv_vlc_map[0][level].size;
373 *vlc = 0xfe00 | (level << 1) | sign;
377 *vlc |= ((run < 16) ? dv_vlc_map[run-1][0].vlc :
378 (0x1f80 | (run - 1))) << size;
379 size += (run < 16) ? dv_vlc_map[run-1][0].size : 13;
386 static av_always_inline int dv_rl2vlc_size(int run, int level)
390 if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {
391 size = dv_vlc_map[run][level].size;
394 size = (level < DV_VLC_MAP_LEV_SIZE) ? dv_vlc_map[0][level].size : 16;
396 size += (run < 16) ? dv_vlc_map[run-1][0].size : 13;
402 static av_always_inline int dv_rl2vlc(int run, int l, int sign, uint32_t* vlc)
404 *vlc = dv_vlc_map[run][l].vlc | sign;
405 return dv_vlc_map[run][l].size;
408 static av_always_inline int dv_rl2vlc_size(int run, int l)
410 return dv_vlc_map[run][l].size;
414 typedef struct EncBlockInfo {
424 uint8_t partial_bit_count;
425 uint32_t partial_bit_buffer; /* we can't use uint16_t here */
428 static av_always_inline PutBitContext* dv_encode_ac(EncBlockInfo* bi,
429 PutBitContext* pb_pool,
430 PutBitContext* pb_end)
433 PutBitContext* pb = pb_pool;
434 int size = bi->partial_bit_count;
435 uint32_t vlc = bi->partial_bit_buffer;
437 bi->partial_bit_count = bi->partial_bit_buffer = 0;
439 /* Find suitable storage space */
440 for (; size > (bits_left = put_bits_left(pb)); pb++) {
443 put_bits(pb, bits_left, vlc >> size);
444 vlc = vlc & ((1 << size) - 1);
446 if (pb + 1 >= pb_end) {
447 bi->partial_bit_count = size;
448 bi->partial_bit_buffer = vlc;
454 put_bits(pb, size, vlc);
456 if (bi->cur_ac >= 64)
459 /* Construct the next VLC */
461 bi->cur_ac = bi->next[prev];
462 if (bi->cur_ac < 64){
463 size = dv_rl2vlc(bi->cur_ac - prev - 1, bi->mb[bi->cur_ac], bi->sign[bi->cur_ac], &vlc);
465 size = 4; vlc = 6; /* End Of Block stamp */
471 static av_always_inline int dv_guess_dct_mode(DVVideoContext *s, uint8_t *data, int linesize) {
472 if (s->avctx->flags & CODEC_FLAG_INTERLACED_DCT) {
473 int ps = s->ildct_cmp(NULL, data, NULL, linesize, 8) - 400;
475 int is = s->ildct_cmp(NULL, data , NULL, linesize<<1, 4) +
476 s->ildct_cmp(NULL, data + linesize, NULL, linesize<<1, 4);
484 static const int dv_weight_bits = 18;
485 static const int dv_weight_88[64] = {
486 131072, 257107, 257107, 242189, 252167, 242189, 235923, 237536,
487 237536, 235923, 229376, 231390, 223754, 231390, 229376, 222935,
488 224969, 217965, 217965, 224969, 222935, 200636, 218652, 211916,
489 212325, 211916, 218652, 200636, 188995, 196781, 205965, 206433,
490 206433, 205965, 196781, 188995, 185364, 185364, 200636, 200704,
491 200636, 185364, 185364, 174609, 180568, 195068, 195068, 180568,
492 174609, 170091, 175557, 189591, 175557, 170091, 165371, 170627,
493 170627, 165371, 160727, 153560, 160727, 144651, 144651, 136258,
495 static const int dv_weight_248[64] = {
496 131072, 242189, 257107, 237536, 229376, 200636, 242189, 223754,
497 224969, 196781, 262144, 242189, 229376, 200636, 257107, 237536,
498 211916, 185364, 235923, 217965, 229376, 211916, 206433, 180568,
499 242189, 223754, 224969, 196781, 211916, 185364, 235923, 217965,
500 200704, 175557, 222935, 205965, 200636, 185364, 195068, 170627,
501 229376, 211916, 206433, 180568, 200704, 175557, 222935, 205965,
502 175557, 153560, 188995, 174609, 165371, 144651, 200636, 185364,
503 195068, 170627, 175557, 153560, 188995, 174609, 165371, 144651,
506 static av_always_inline int dv_init_enc_block(EncBlockInfo* bi, uint8_t *data, int linesize, DVVideoContext *s, int bias)
509 const uint8_t* zigzag_scan;
510 LOCAL_ALIGNED_16(int16_t, blk, [64]);
512 /* We offer two different methods for class number assignment: the
513 method suggested in SMPTE 314M Table 22, and an improved
514 method. The SMPTE method is very conservative; it assigns class
515 3 (i.e. severe quantization) to any block where the largest AC
516 component is greater than 36. FFmpeg's DV encoder tracks AC bit
517 consumption precisely, so there is no need to bias most blocks
518 towards strongly lossy compression. Instead, we assign class 2
519 to most blocks, and use class 3 only when strictly necessary
520 (for blocks whose largest AC component exceeds 255). */
522 #if 0 /* SMPTE spec method */
523 static const int classes[] = {12, 24, 36, 0xffff};
524 #else /* improved FFmpeg method */
525 static const int classes[] = {-1, -1, 255, 0xffff};
527 int max = classes[0];
530 av_assert2((((int)blk) & 15) == 0);
532 bi->area_q[0] = bi->area_q[1] = bi->area_q[2] = bi->area_q[3] = 0;
533 bi->partial_bit_count = 0;
534 bi->partial_bit_buffer = 0;
537 bi->dct_mode = dv_guess_dct_mode(s, data, linesize);
538 s->get_pixels(blk, data, linesize);
539 s->fdct[bi->dct_mode](blk);
541 /* We rely on the fact that encoding all zeros leads to an immediate EOB,
542 which is precisely what the spec calls for in the "dummy" blocks. */
543 memset(blk, 0, 64*sizeof(*blk));
548 zigzag_scan = bi->dct_mode ? ff_zigzag248_direct : ff_zigzag_direct;
549 weight = bi->dct_mode ? dv_weight_248 : dv_weight_88;
551 for (area = 0; area < 4; area++) {
552 bi->prev[area] = prev;
553 bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
554 for (i = mb_area_start[area]; i < mb_area_start[area+1]; i++) {
555 int level = blk[zigzag_scan[i]];
557 if (level + 15 > 30U) {
558 bi->sign[i] = (level >> 31) & 1;
559 /* weight it and and shift down into range, adding for rounding */
560 /* the extra division by a factor of 2^4 reverses the 8x expansion of the DCT
561 AND the 2x doubling of the weights */
562 level = (FFABS(level) * weight[i] + (1 << (dv_weight_bits+3))) >> (dv_weight_bits+4);
566 bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, level);
573 for (bi->cno = 0; max > classes[bi->cno]; bi->cno++);
581 for (area = 0; area < 4; area++) {
582 bi->prev[area] = prev;
583 bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
584 for (; i < mb_area_start[area+1]; i = bi->next[i]) {
588 bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, bi->mb[i]);
597 return bi->bit_size[0] + bi->bit_size[1] + bi->bit_size[2] + bi->bit_size[3];
600 static inline void dv_guess_qnos(EncBlockInfo* blks, int* qnos)
603 int i, j, k, a, prev, a2;
606 size[0] = size[1] = size[2] = size[3] = size[4] = 1 << 24;
609 for (i = 0; i < 5; i++) {
615 for (j = 0; j < 6; j++, b++) {
616 for (a = 0; a < 4; a++) {
617 if (b->area_q[a] != ff_dv_quant_shifts[qnos[i] + ff_dv_quant_offset[b->cno]][a]) {
618 b->bit_size[a] = 1; // 4 areas 4 bits for EOB :)
621 av_assert2(b->next[prev] >= mb_area_start[a+1] || b->mb[prev]);
622 for (k = b->next[prev] ; k < mb_area_start[a+1]; k = b->next[k]) {
625 b->bit_size[a] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
628 if (b->next[k] >= mb_area_start[a+1] && b->next[k]<64){
629 for (a2 = a + 1; b->next[k] >= mb_area_start[a2+1]; a2++)
632 av_assert2(b->mb[b->next[k]]);
633 b->bit_size[a2] += dv_rl2vlc_size(b->next[k] - prev - 1, b->mb[b->next[k]])
634 -dv_rl2vlc_size(b->next[k] - k - 1, b->mb[b->next[k]]);
635 av_assert2(b->prev[a2] == k && (a2 + 1 >= 4 || b->prev[a2+1] != k));
638 b->next[prev] = b->next[k];
643 size[i] += b->bit_size[a];
646 if (vs_total_ac_bits >= size[0] + size[1] + size[2] + size[3] + size[4])
649 } while (qnos[0]|qnos[1]|qnos[2]|qnos[3]|qnos[4]);
652 for (a = 2; a == 2 || vs_total_ac_bits < size[0]; a += a){
654 size[0] = 5 * 6 * 4; //EOB
655 for (j = 0; j < 6 *5; j++, b++) {
657 for (k = b->next[prev]; k < 64; k = b->next[k]) {
658 if (b->mb[k] < a && b->mb[k] > -a){
659 b->next[prev] = b->next[k];
661 size[0] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
669 static int dv_encode_video_segment(AVCodecContext *avctx, void *arg)
671 DVVideoContext *s = avctx->priv_data;
672 DVwork_chunk *work_chunk = arg;
674 int mb_x, mb_y, c_offset, linesize, y_stride;
677 LOCAL_ALIGNED_8(uint8_t, scratch, [128]);
678 EncBlockInfo enc_blks[5*DV_MAX_BPM];
679 PutBitContext pbs[5*DV_MAX_BPM];
681 EncBlockInfo* enc_blk;
683 int qnos[5] = {15, 15, 15, 15, 15}; /* No quantization */
684 int* qnosp = &qnos[0];
686 dif = &s->buf[work_chunk->buf_offset*80];
687 enc_blk = &enc_blks[0];
688 for (mb_index = 0; mb_index < 5; mb_index++) {
689 dv_calculate_mb_xy(s, work_chunk, mb_index, &mb_x, &mb_y);
691 /* initializing luminance blocks */
692 if ((s->sys->pix_fmt == AV_PIX_FMT_YUV420P) ||
693 (s->sys->pix_fmt == AV_PIX_FMT_YUV411P && mb_x >= (704 / 8)) ||
694 (s->sys->height >= 720 && mb_y != 134)) {
695 y_stride = s->picture.linesize[0] << 3;
699 y_ptr = s->picture.data[0] + ((mb_y * s->picture.linesize[0] + mb_x) << 3);
700 linesize = s->picture.linesize[0];
702 if (s->sys->video_stype == 4) { /* SD 422 */
704 dv_init_enc_block(enc_blk+0, y_ptr , linesize, s, 0) +
705 dv_init_enc_block(enc_blk+1, NULL , linesize, s, 0) +
706 dv_init_enc_block(enc_blk+2, y_ptr + 8 , linesize, s, 0) +
707 dv_init_enc_block(enc_blk+3, NULL , linesize, s, 0);
710 dv_init_enc_block(enc_blk+0, y_ptr , linesize, s, 0) +
711 dv_init_enc_block(enc_blk+1, y_ptr + 8 , linesize, s, 0) +
712 dv_init_enc_block(enc_blk+2, y_ptr + y_stride, linesize, s, 0) +
713 dv_init_enc_block(enc_blk+3, y_ptr + 8 + y_stride, linesize, s, 0);
717 /* initializing chrominance blocks */
718 c_offset = (((mb_y >> (s->sys->pix_fmt == AV_PIX_FMT_YUV420P)) * s->picture.linesize[1] +
719 (mb_x >> ((s->sys->pix_fmt == AV_PIX_FMT_YUV411P) ? 2 : 1))) << 3);
720 for (j = 2; j; j--) {
721 uint8_t *c_ptr = s->picture.data[j] + c_offset;
722 linesize = s->picture.linesize[j];
723 y_stride = (mb_y == 134) ? 8 : (s->picture.linesize[j] << 3);
724 if (s->sys->pix_fmt == AV_PIX_FMT_YUV411P && mb_x >= (704 / 8)) {
726 uint8_t* b = scratch;
727 for (i = 0; i < 8; i++) {
728 d = c_ptr + (linesize << 3);
729 b[0] = c_ptr[0]; b[1] = c_ptr[1]; b[2] = c_ptr[2]; b[3] = c_ptr[3];
730 b[4] = d[0]; b[5] = d[1]; b[6] = d[2]; b[7] = d[3];
738 vs_bit_size += dv_init_enc_block( enc_blk++, c_ptr , linesize, s, 1);
739 if (s->sys->bpm == 8) {
740 vs_bit_size += dv_init_enc_block(enc_blk++, c_ptr + y_stride, linesize, s, 1);
745 if (vs_total_ac_bits < vs_bit_size)
746 dv_guess_qnos(&enc_blks[0], qnosp);
748 /* DIF encoding process */
749 for (j=0; j<5*s->sys->bpm;) {
755 /* First pass over individual cells only */
756 for (i=0; i<s->sys->bpm; i++, j++) {
757 int sz = s->sys->block_sizes[i]>>3;
759 init_put_bits(&pbs[j], dif, sz);
760 put_sbits(&pbs[j], 9, ((enc_blks[j].mb[0] >> 3) - 1024 + 2) >> 2);
761 put_bits(&pbs[j], 1, enc_blks[j].dct_mode);
762 put_bits(&pbs[j], 2, enc_blks[j].cno);
764 dv_encode_ac(&enc_blks[j], &pbs[j], &pbs[j+1]);
768 /* Second pass over each MB space */
770 for (i=0; i<s->sys->bpm; i++) {
771 if (enc_blks[start_mb+i].partial_bit_count)
772 pb = dv_encode_ac(&enc_blks[start_mb+i], pb, &pbs[start_mb+s->sys->bpm]);
776 /* Third and final pass over the whole video segment space */
778 for (j=0; j<5*s->sys->bpm; j++) {
779 if (enc_blks[j].partial_bit_count)
780 pb = dv_encode_ac(&enc_blks[j], pb, &pbs[s->sys->bpm*5]);
781 if (enc_blks[j].partial_bit_count)
782 av_log(avctx, AV_LOG_ERROR, "ac bitstream overflow\n");
785 for (j=0; j<5*s->sys->bpm; j++) {
787 int size = pbs[j].size_in_bits >> 3;
788 flush_put_bits(&pbs[j]);
789 pos = put_bits_count(&pbs[j]) >> 3;
791 av_log(avctx, AV_LOG_ERROR, "bitstream written beyond buffer size\n");
794 memset(pbs[j].buf + pos, 0xff, size - pos);
800 static inline int dv_write_pack(enum dv_pack_type pack_id, DVVideoContext *c,
804 * Here's what SMPTE314M says about these two:
805 * (page 6) APTn, AP1n, AP2n, AP3n: These data shall be identical
806 * as track application IDs (APTn = 001, AP1n =
807 * 001, AP2n = 001, AP3n = 001), if the source signal
808 * comes from a digital VCR. If the signal source is
809 * unknown, all bits for these data shall be set to 1.
810 * (page 12) STYPE: STYPE defines a signal type of video signal
811 * 00000b = 4:1:1 compression
812 * 00100b = 4:2:2 compression
814 * Now, I've got two problems with these statements:
815 * 1. it looks like APT == 111b should be a safe bet, but it isn't.
816 * It seems that for PAL as defined in IEC 61834 we have to set
817 * APT to 000 and for SMPTE314M to 001.
818 * 2. It is not at all clear what STYPE is used for 4:2:0 PAL
819 * compression scheme (if any).
821 int apt = (c->sys->pix_fmt == AV_PIX_FMT_YUV420P ? 0 : 1);
822 int fs = c->picture.top_field_first ? 0x00 : 0x40;
825 if ((int)(av_q2d(c->avctx->sample_aspect_ratio) * c->avctx->width / c->avctx->height * 10) >= 17) /* 16:9 */
828 buf[0] = (uint8_t)pack_id;
830 case dv_header525: /* I can't imagine why these two weren't defined as real */
831 case dv_header625: /* packs in SMPTE314M -- they definitely look like ones */
832 buf[1] = 0xf8 | /* reserved -- always 1 */
833 (apt & 0x07); /* APT: Track application ID */
834 buf[2] = (0 << 7) | /* TF1: audio data is 0 - valid; 1 - invalid */
835 (0x0f << 3) | /* reserved -- always 1 */
836 (apt & 0x07); /* AP1: Audio application ID */
837 buf[3] = (0 << 7) | /* TF2: video data is 0 - valid; 1 - invalid */
838 (0x0f << 3) | /* reserved -- always 1 */
839 (apt & 0x07); /* AP2: Video application ID */
840 buf[4] = (0 << 7) | /* TF3: subcode(SSYB) is 0 - valid; 1 - invalid */
841 (0x0f << 3) | /* reserved -- always 1 */
842 (apt & 0x07); /* AP3: Subcode application ID */
844 case dv_video_source:
845 buf[1] = 0xff; /* reserved -- always 1 */
846 buf[2] = (1 << 7) | /* B/W: 0 - b/w, 1 - color */
847 (1 << 6) | /* following CLF is valid - 0, invalid - 1 */
848 (3 << 4) | /* CLF: color frames ID (see ITU-R BT.470-4) */
849 0xf; /* reserved -- always 1 */
850 buf[3] = (3 << 6) | /* reserved -- always 1 */
851 (c->sys->dsf << 5) | /* system: 60fields/50fields */
852 c->sys->video_stype; /* signal type video compression */
853 buf[4] = 0xff; /* VISC: 0xff -- no information */
855 case dv_video_control:
856 buf[1] = (0 << 6) | /* Copy generation management (CGMS) 0 -- free */
857 0x3f; /* reserved -- always 1 */
858 buf[2] = 0xc8 | /* reserved -- always b11001xxx */
860 buf[3] = (1 << 7) | /* frame/field flag 1 -- frame, 0 -- field */
861 fs | /* first/second field flag 0 -- field 2, 1 -- field 1 */
862 (1 << 5) | /* frame change flag 0 -- same picture as before, 1 -- different */
863 (1 << 4) | /* 1 - interlaced, 0 - noninterlaced */
864 0xc; /* reserved -- always b1100 */
865 buf[4] = 0xff; /* reserved -- always 1 */
868 buf[1] = buf[2] = buf[3] = buf[4] = 0xff;
873 #if CONFIG_DVVIDEO_ENCODER
874 static inline int dv_write_dif_id(enum dv_section_type t, uint8_t chan_num,
875 uint8_t seq_num, uint8_t dif_num,
878 buf[0] = (uint8_t)t; /* Section type */
879 buf[1] = (seq_num << 4) | /* DIF seq number 0-9 for 525/60; 0-11 for 625/50 */
880 (chan_num << 3) | /* FSC: for 50Mb/s 0 - first channel; 1 - second */
881 7; /* reserved -- always 1 */
882 buf[2] = dif_num; /* DIF block number Video: 0-134, Audio: 0-8 */
887 static inline int dv_write_ssyb_id(uint8_t syb_num, uint8_t fr, uint8_t* buf)
889 if (syb_num == 0 || syb_num == 6) {
890 buf[0] = (fr << 7) | /* FR ID 1 - first half of each channel; 0 - second */
891 (0 << 4) | /* AP3 (Subcode application ID) */
892 0x0f; /* reserved -- always 1 */
894 else if (syb_num == 11) {
895 buf[0] = (fr << 7) | /* FR ID 1 - first half of each channel; 0 - second */
896 0x7f; /* reserved -- always 1 */
899 buf[0] = (fr << 7) | /* FR ID 1 - first half of each channel; 0 - second */
900 (0 << 4) | /* APT (Track application ID) */
901 0x0f; /* reserved -- always 1 */
903 buf[1] = 0xf0 | /* reserved -- always 1 */
904 (syb_num & 0x0f); /* SSYB number 0 - 11 */
905 buf[2] = 0xff; /* reserved -- always 1 */
909 static void dv_format_frame(DVVideoContext* c, uint8_t* buf)
913 for (chan = 0; chan < c->sys->n_difchan; chan++) {
914 for (i = 0; i < c->sys->difseg_size; i++) {
915 memset(buf, 0xff, 80 * 6); /* first 6 DIF blocks are for control data */
917 /* DV header: 1DIF */
918 buf += dv_write_dif_id(dv_sect_header, chan, i, 0, buf);
919 buf += dv_write_pack((c->sys->dsf ? dv_header625 : dv_header525), c, buf);
920 buf += 72; /* unused bytes */
922 /* DV subcode: 2DIFs */
923 for (j = 0; j < 2; j++) {
924 buf += dv_write_dif_id(dv_sect_subcode, chan, i, j, buf);
925 for (k = 0; k < 6; k++)
926 buf += dv_write_ssyb_id(k, (i < c->sys->difseg_size/2), buf) + 5;
927 buf += 29; /* unused bytes */
931 for (j = 0; j < 3; j++) {
932 buf += dv_write_dif_id(dv_sect_vaux, chan, i, j, buf);
933 buf += dv_write_pack(dv_video_source, c, buf);
934 buf += dv_write_pack(dv_video_control, c, buf);
936 buf += dv_write_pack(dv_video_source, c, buf);
937 buf += dv_write_pack(dv_video_control, c, buf);
938 buf += 4*5 + 2; /* unused bytes */
941 /* DV Audio/Video: 135 Video DIFs + 9 Audio DIFs */
942 for (j = 0; j < 135; j++) {
944 memset(buf, 0xff, 80);
945 buf += dv_write_dif_id(dv_sect_audio, chan, i, j/15, buf);
946 buf += 77; /* audio control & shuffled PCM audio */
948 buf += dv_write_dif_id(dv_sect_video, chan, i, j, buf);
949 buf += 77; /* 1 video macroblock: 1 bytes control
950 4 * 14 bytes Y 8x8 data
952 10 bytes Cb 8x8 data */
959 static int dvvideo_encode_frame(AVCodecContext *c, AVPacket *pkt,
960 const AVFrame *frame, int *got_packet)
962 DVVideoContext *s = c->priv_data;
965 s->sys = avpriv_dv_codec_profile(c);
966 if (!s->sys || ff_dv_init_dynamic_tables(s->sys))
968 if ((ret = ff_alloc_packet2(c, pkt, s->sys->frame_size)) < 0)
971 c->pix_fmt = s->sys->pix_fmt;
973 s->picture.key_frame = 1;
974 s->picture.pict_type = AV_PICTURE_TYPE_I;
977 c->execute(c, dv_encode_video_segment, s->sys->work_chunks, NULL,
978 dv_work_pool_size(s->sys), sizeof(DVwork_chunk));
982 dv_format_frame(s, pkt->data);
984 pkt->flags |= AV_PKT_FLAG_KEY;
990 AVCodec ff_dvvideo_encoder = {
992 .type = AVMEDIA_TYPE_VIDEO,
993 .id = AV_CODEC_ID_DVVIDEO,
994 .priv_data_size = sizeof(DVVideoContext),
995 .init = dvvideo_init_encoder,
996 .encode2 = dvvideo_encode_frame,
997 .capabilities = CODEC_CAP_SLICE_THREADS,
998 .pix_fmts = (const enum AVPixelFormat[]) {
999 AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE
1001 .long_name = NULL_IF_CONFIG_SMALL("DV (Digital Video)"),
1003 #endif // CONFIG_DVVIDEO_ENCODER