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 Libav.
21 * Libav 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 * Libav 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 Libav; 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"
50 #include "dv_tablegen.h"
52 /* XXX: also include quantization */
53 RL_VLC_ELEM ff_dv_rl_vlc[1184];
55 static inline void dv_calc_mb_coordinates(const DVprofile *d, int chan, int seq, int slot,
58 static const uint8_t off[] = { 2, 6, 8, 0, 4 };
59 static const uint8_t shuf1[] = { 36, 18, 54, 0, 72 };
60 static const uint8_t shuf2[] = { 24, 12, 36, 0, 48 };
61 static const uint8_t shuf3[] = { 18, 9, 27, 0, 36 };
63 static const uint8_t l_start[] = {0, 4, 9, 13, 18, 22, 27, 31, 36, 40};
64 static const uint8_t l_start_shuffled[] = { 9, 4, 13, 0, 18 };
66 static const uint8_t serpent1[] = {0, 1, 2, 2, 1, 0,
71 static const uint8_t serpent2[] = {0, 1, 2, 3, 4, 5, 5, 4, 3, 2, 1, 0,
72 0, 1, 2, 3, 4, 5, 5, 4, 3, 2, 1, 0,
75 static const uint8_t remap[][2] = {{ 0, 0}, { 0, 0}, { 0, 0}, { 0, 0}, /* dummy */
76 { 0, 0}, { 0, 1}, { 0, 2}, { 0, 3}, {10, 0},
77 {10, 1}, {10, 2}, {10, 3}, {20, 0}, {20, 1},
78 {20, 2}, {20, 3}, {30, 0}, {30, 1}, {30, 2},
79 {30, 3}, {40, 0}, {40, 1}, {40, 2}, {40, 3},
80 {50, 0}, {50, 1}, {50, 2}, {50, 3}, {60, 0},
81 {60, 1}, {60, 2}, {60, 3}, {70, 0}, {70, 1},
82 {70, 2}, {70, 3}, { 0,64}, { 0,65}, { 0,66},
83 {10,64}, {10,65}, {10,66}, {20,64}, {20,65},
84 {20,66}, {30,64}, {30,65}, {30,66}, {40,64},
85 {40,65}, {40,66}, {50,64}, {50,65}, {50,66},
86 {60,64}, {60,65}, {60,66}, {70,64}, {70,65},
87 {70,66}, { 0,67}, {20,67}, {40,67}, {60,67}};
95 blk = (chan*11+seq)*27+slot;
97 if (chan == 0 && seq == 11) {
106 i = (4*chan + blk + off[m])%11;
109 x = shuf1[m] + (chan&1)*9 + k%9;
110 y = (i*3+k/9)*2 + (chan>>1) + 1;
112 tbl[m] = (x<<1)|(y<<9);
115 blk = (chan*10+seq)*27+slot;
117 i = (4*chan + (seq/5) + 2*blk + off[m])%10;
120 x = shuf1[m]+(chan&1)*9 + k%9;
121 y = (i*3+k/9)*2 + (chan>>1) + 4;
124 x = remap[y][0]+((x-80)<<(y>59));
127 tbl[m] = (x<<1)|(y<<9);
130 blk = (chan*10+seq)*27+slot;
132 i = (4*chan + (seq/5) + 2*blk + off[m])%10;
133 k = (blk/5)%27 + (i&1)*3;
135 x = shuf2[m] + k%6 + 6*(chan&1);
136 y = l_start[i] + k/6 + 45*(chan>>1);
137 tbl[m] = (x<<1)|(y<<9);
140 switch (d->pix_fmt) {
141 case PIX_FMT_YUV422P:
142 x = shuf3[m] + slot/3;
144 ((((seq + off[m]) % d->difseg_size)<<1) + chan)*3;
145 tbl[m] = (x<<1)|(y<<8);
147 case PIX_FMT_YUV420P:
148 x = shuf3[m] + slot/3;
150 ((seq + off[m]) % d->difseg_size)*3;
151 tbl[m] = (x<<1)|(y<<9);
153 case PIX_FMT_YUV411P:
154 i = (seq + off[m]) % d->difseg_size;
155 k = slot + ((m==1||m==2)?3:0);
157 x = l_start_shuffled[m] + k/6;
158 y = serpent2[k] + i*6;
161 tbl[m] = (x<<2)|(y<<8);
170 int ff_dv_init_dynamic_tables(const DVprofile *d)
173 uint32_t *factor1, *factor2;
174 const int *iweight1, *iweight2;
176 if (!d->work_chunks[dv_work_pool_size(d)-1].buf_offset) {
178 for (c=0; c<d->n_difchan; c++) {
179 for (s=0; s<d->difseg_size; s++) {
181 for (j=0; j<27; j++) {
183 if (!(DV_PROFILE_IS_1080i50(d) && c != 0 && s == 11) &&
184 !(DV_PROFILE_IS_720p50(d) && s > 9)) {
185 dv_calc_mb_coordinates(d, c, s, j, &d->work_chunks[i].mb_coordinates[0]);
186 d->work_chunks[i++].buf_offset = p;
194 if (!d->idct_factor[DV_PROFILE_IS_HD(d)?8191:5631]) {
195 factor1 = &d->idct_factor[0];
196 factor2 = &d->idct_factor[DV_PROFILE_IS_HD(d)?4096:2816];
197 if (d->height == 720) {
198 iweight1 = &dv_iweight_720_y[0];
199 iweight2 = &dv_iweight_720_c[0];
201 iweight1 = &dv_iweight_1080_y[0];
202 iweight2 = &dv_iweight_1080_c[0];
204 if (DV_PROFILE_IS_HD(d)) {
205 for (c = 0; c < 4; c++) {
206 for (s = 0; s < 16; s++) {
207 for (i = 0; i < 64; i++) {
208 *factor1++ = (dv100_qstep[s] << (c + 9)) * iweight1[i];
209 *factor2++ = (dv100_qstep[s] << (c + 9)) * iweight2[i];
214 iweight1 = &dv_iweight_88[0];
215 for (j = 0; j < 2; j++, iweight1 = &dv_iweight_248[0]) {
216 for (s = 0; s < 22; s++) {
217 for (i = c = 0; c < 4; c++) {
218 for (; i < dv_quant_areas[c]; i++) {
219 *factor1 = iweight1[i] << (dv_quant_shifts[s][c] + 1);
220 *factor2++ = (*factor1++) << 1;
231 av_cold int ff_dvvideo_init(AVCodecContext *avctx)
233 DVVideoContext *s = avctx->priv_data;
240 uint16_t new_dv_vlc_bits[NB_DV_VLC*2];
241 uint8_t new_dv_vlc_len[NB_DV_VLC*2];
242 uint8_t new_dv_vlc_run[NB_DV_VLC*2];
243 int16_t new_dv_vlc_level[NB_DV_VLC*2];
247 /* it's faster to include sign bit in a generic VLC parsing scheme */
248 for (i = 0, j = 0; i < NB_DV_VLC; i++, j++) {
249 new_dv_vlc_bits[j] = dv_vlc_bits[i];
250 new_dv_vlc_len[j] = dv_vlc_len[i];
251 new_dv_vlc_run[j] = dv_vlc_run[i];
252 new_dv_vlc_level[j] = dv_vlc_level[i];
254 if (dv_vlc_level[i]) {
255 new_dv_vlc_bits[j] <<= 1;
259 new_dv_vlc_bits[j] = (dv_vlc_bits[i] << 1) | 1;
260 new_dv_vlc_len[j] = dv_vlc_len[i] + 1;
261 new_dv_vlc_run[j] = dv_vlc_run[i];
262 new_dv_vlc_level[j] = -dv_vlc_level[i];
266 /* NOTE: as a trick, we use the fact the no codes are unused
267 to accelerate the parsing of partial codes */
268 init_vlc(&dv_vlc, TEX_VLC_BITS, j,
269 new_dv_vlc_len, 1, 1, new_dv_vlc_bits, 2, 2, 0);
270 assert(dv_vlc.table_size == 1184);
272 for (i = 0; i < dv_vlc.table_size; i++){
273 int code = dv_vlc.table[i][0];
274 int len = dv_vlc.table[i][1];
277 if (len < 0){ //more bits needed
281 run = new_dv_vlc_run [code] + 1;
282 level = new_dv_vlc_level[code];
284 ff_dv_rl_vlc[i].len = len;
285 ff_dv_rl_vlc[i].level = level;
286 ff_dv_rl_vlc[i].run = run;
288 ff_free_vlc(&dv_vlc);
290 dv_vlc_map_tableinit();
293 /* Generic DSP setup */
294 ff_dsputil_init(&dsp, avctx);
295 ff_set_cmp(&dsp, dsp.ildct_cmp, avctx->ildct_cmp);
296 s->get_pixels = dsp.get_pixels;
297 s->ildct_cmp = dsp.ildct_cmp[5];
300 s->fdct[0] = dsp.fdct;
301 s->idct_put[0] = dsp.idct_put;
302 for (i = 0; i < 64; i++)
303 s->dv_zigzag[0][i] = dsp.idct_permutation[ff_zigzag_direct[i]];
306 s->fdct[1] = dsp.fdct248;
307 s->idct_put[1] = ff_simple_idct248_put; // FIXME: need to add it to DSP
309 for (i = 0; i < 64; i++){
310 int j = ff_zigzag248_direct[i];
311 s->dv_zigzag[1][i] = dsp.idct_permutation[(j & 7) + (j & 8) * 4 + (j & 48) / 2];
314 memcpy(s->dv_zigzag[1], ff_zigzag248_direct, 64);
316 avctx->coded_frame = &s->picture;
318 avctx->chroma_sample_location = AVCHROMA_LOC_TOPLEFT;
323 static av_cold int dvvideo_init_encoder(AVCodecContext *avctx)
325 if (!avpriv_dv_codec_profile(avctx)) {
326 av_log(avctx, AV_LOG_ERROR, "Found no DV profile for %ix%i %s video\n",
327 avctx->width, avctx->height, av_get_pix_fmt_name(avctx->pix_fmt));
331 return ff_dvvideo_init(avctx);
334 /* bit budget for AC only in 5 MBs */
335 static const int vs_total_ac_bits = (100 * 4 + 68*2) * 5;
336 static const int mb_area_start[5] = { 1, 6, 21, 43, 64 };
338 static inline int put_bits_left(PutBitContext* s)
340 return (s->buf_end - s->buf) * 8 - put_bits_count(s);
344 /* Converts run and level (where level != 0) pair into VLC, returning bit size */
345 static av_always_inline int dv_rl2vlc(int run, int level, int sign, uint32_t* vlc)
348 if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {
349 *vlc = dv_vlc_map[run][level].vlc | sign;
350 size = dv_vlc_map[run][level].size;
353 if (level < DV_VLC_MAP_LEV_SIZE) {
354 *vlc = dv_vlc_map[0][level].vlc | sign;
355 size = dv_vlc_map[0][level].size;
357 *vlc = 0xfe00 | (level << 1) | sign;
361 *vlc |= ((run < 16) ? dv_vlc_map[run-1][0].vlc :
362 (0x1f80 | (run - 1))) << size;
363 size += (run < 16) ? dv_vlc_map[run-1][0].size : 13;
370 static av_always_inline int dv_rl2vlc_size(int run, int level)
374 if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {
375 size = dv_vlc_map[run][level].size;
378 size = (level < DV_VLC_MAP_LEV_SIZE) ? dv_vlc_map[0][level].size : 16;
380 size += (run < 16) ? dv_vlc_map[run-1][0].size : 13;
386 static av_always_inline int dv_rl2vlc(int run, int l, int sign, uint32_t* vlc)
388 *vlc = dv_vlc_map[run][l].vlc | sign;
389 return dv_vlc_map[run][l].size;
392 static av_always_inline int dv_rl2vlc_size(int run, int l)
394 return dv_vlc_map[run][l].size;
398 typedef struct EncBlockInfo {
408 uint8_t partial_bit_count;
409 uint32_t partial_bit_buffer; /* we can't use uint16_t here */
412 static av_always_inline PutBitContext* dv_encode_ac(EncBlockInfo* bi,
413 PutBitContext* pb_pool,
414 PutBitContext* pb_end)
417 PutBitContext* pb = pb_pool;
418 int size = bi->partial_bit_count;
419 uint32_t vlc = bi->partial_bit_buffer;
421 bi->partial_bit_count = bi->partial_bit_buffer = 0;
423 /* Find suitable storage space */
424 for (; size > (bits_left = put_bits_left(pb)); pb++) {
427 put_bits(pb, bits_left, vlc >> size);
428 vlc = vlc & ((1 << size) - 1);
430 if (pb + 1 >= pb_end) {
431 bi->partial_bit_count = size;
432 bi->partial_bit_buffer = vlc;
438 put_bits(pb, size, vlc);
440 if (bi->cur_ac >= 64)
443 /* Construct the next VLC */
445 bi->cur_ac = bi->next[prev];
446 if (bi->cur_ac < 64){
447 size = dv_rl2vlc(bi->cur_ac - prev - 1, bi->mb[bi->cur_ac], bi->sign[bi->cur_ac], &vlc);
449 size = 4; vlc = 6; /* End Of Block stamp */
455 static av_always_inline int dv_guess_dct_mode(DVVideoContext *s, uint8_t *data, int linesize) {
456 if (s->avctx->flags & CODEC_FLAG_INTERLACED_DCT) {
457 int ps = s->ildct_cmp(NULL, data, NULL, linesize, 8) - 400;
459 int is = s->ildct_cmp(NULL, data , NULL, linesize<<1, 4) +
460 s->ildct_cmp(NULL, data + linesize, NULL, linesize<<1, 4);
468 static av_always_inline int dv_init_enc_block(EncBlockInfo* bi, uint8_t *data, int linesize, DVVideoContext *s, int bias)
471 const uint8_t* zigzag_scan;
472 LOCAL_ALIGNED_16(DCTELEM, blk, [64]);
474 /* We offer two different methods for class number assignment: the
475 method suggested in SMPTE 314M Table 22, and an improved
476 method. The SMPTE method is very conservative; it assigns class
477 3 (i.e. severe quantization) to any block where the largest AC
478 component is greater than 36. Libav's DV encoder tracks AC bit
479 consumption precisely, so there is no need to bias most blocks
480 towards strongly lossy compression. Instead, we assign class 2
481 to most blocks, and use class 3 only when strictly necessary
482 (for blocks whose largest AC component exceeds 255). */
484 #if 0 /* SMPTE spec method */
485 static const int classes[] = {12, 24, 36, 0xffff};
486 #else /* improved Libav method */
487 static const int classes[] = {-1, -1, 255, 0xffff};
489 int max = classes[0];
492 assert((((int)blk) & 15) == 0);
494 bi->area_q[0] = bi->area_q[1] = bi->area_q[2] = bi->area_q[3] = 0;
495 bi->partial_bit_count = 0;
496 bi->partial_bit_buffer = 0;
499 bi->dct_mode = dv_guess_dct_mode(s, data, linesize);
500 s->get_pixels(blk, data, linesize);
501 s->fdct[bi->dct_mode](blk);
503 /* We rely on the fact that encoding all zeros leads to an immediate EOB,
504 which is precisely what the spec calls for in the "dummy" blocks. */
505 memset(blk, 0, 64*sizeof(*blk));
510 zigzag_scan = bi->dct_mode ? ff_zigzag248_direct : ff_zigzag_direct;
511 weight = bi->dct_mode ? dv_weight_248 : dv_weight_88;
513 for (area = 0; area < 4; area++) {
514 bi->prev[area] = prev;
515 bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
516 for (i = mb_area_start[area]; i < mb_area_start[area+1]; i++) {
517 int level = blk[zigzag_scan[i]];
519 if (level + 15 > 30U) {
520 bi->sign[i] = (level >> 31) & 1;
521 /* weight it and and shift down into range, adding for rounding */
522 /* the extra division by a factor of 2^4 reverses the 8x expansion of the DCT
523 AND the 2x doubling of the weights */
524 level = (FFABS(level) * weight[i] + (1 << (dv_weight_bits+3))) >> (dv_weight_bits+4);
528 bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, level);
535 for (bi->cno = 0; max > classes[bi->cno]; bi->cno++);
543 for (area = 0; area < 4; area++) {
544 bi->prev[area] = prev;
545 bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
546 for (; i < mb_area_start[area+1]; i = bi->next[i]) {
550 bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, bi->mb[i]);
559 return bi->bit_size[0] + bi->bit_size[1] + bi->bit_size[2] + bi->bit_size[3];
562 static inline void dv_guess_qnos(EncBlockInfo* blks, int* qnos)
565 int i, j, k, a, prev, a2;
568 size[0] = size[1] = size[2] = size[3] = size[4] = 1 << 24;
571 for (i = 0; i < 5; i++) {
577 for (j = 0; j < 6; j++, b++) {
578 for (a = 0; a < 4; a++) {
579 if (b->area_q[a] != dv_quant_shifts[qnos[i] + dv_quant_offset[b->cno]][a]) {
580 b->bit_size[a] = 1; // 4 areas 4 bits for EOB :)
583 assert(b->next[prev] >= mb_area_start[a+1] || b->mb[prev]);
584 for (k = b->next[prev] ; k < mb_area_start[a+1]; k = b->next[k]) {
587 b->bit_size[a] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
590 if (b->next[k] >= mb_area_start[a+1] && b->next[k]<64){
591 for (a2 = a + 1; b->next[k] >= mb_area_start[a2+1]; a2++)
594 assert(b->mb[b->next[k]]);
595 b->bit_size[a2] += dv_rl2vlc_size(b->next[k] - prev - 1, b->mb[b->next[k]])
596 -dv_rl2vlc_size(b->next[k] - k - 1, b->mb[b->next[k]]);
597 assert(b->prev[a2] == k && (a2 + 1 >= 4 || b->prev[a2+1] != k));
600 b->next[prev] = b->next[k];
605 size[i] += b->bit_size[a];
608 if (vs_total_ac_bits >= size[0] + size[1] + size[2] + size[3] + size[4])
611 } while (qnos[0]|qnos[1]|qnos[2]|qnos[3]|qnos[4]);
614 for (a = 2; a == 2 || vs_total_ac_bits < size[0]; a += a){
616 size[0] = 5 * 6 * 4; //EOB
617 for (j = 0; j < 6 *5; j++, b++) {
619 for (k = b->next[prev]; k < 64; k = b->next[k]) {
620 if (b->mb[k] < a && b->mb[k] > -a){
621 b->next[prev] = b->next[k];
623 size[0] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
631 static int dv_encode_video_segment(AVCodecContext *avctx, void *arg)
633 DVVideoContext *s = avctx->priv_data;
634 DVwork_chunk *work_chunk = arg;
636 int mb_x, mb_y, c_offset, linesize, y_stride;
639 LOCAL_ALIGNED_8(uint8_t, scratch, [64]);
640 EncBlockInfo enc_blks[5*DV_MAX_BPM];
641 PutBitContext pbs[5*DV_MAX_BPM];
643 EncBlockInfo* enc_blk;
645 int qnos[5] = {15, 15, 15, 15, 15}; /* No quantization */
646 int* qnosp = &qnos[0];
648 dif = &s->buf[work_chunk->buf_offset*80];
649 enc_blk = &enc_blks[0];
650 for (mb_index = 0; mb_index < 5; mb_index++) {
651 dv_calculate_mb_xy(s, work_chunk, mb_index, &mb_x, &mb_y);
653 /* initializing luminance blocks */
654 if ((s->sys->pix_fmt == PIX_FMT_YUV420P) ||
655 (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8)) ||
656 (s->sys->height >= 720 && mb_y != 134)) {
657 y_stride = s->picture.linesize[0] << 3;
661 y_ptr = s->picture.data[0] + ((mb_y * s->picture.linesize[0] + mb_x) << 3);
662 linesize = s->picture.linesize[0];
664 if (s->sys->video_stype == 4) { /* SD 422 */
666 dv_init_enc_block(enc_blk+0, y_ptr , linesize, s, 0) +
667 dv_init_enc_block(enc_blk+1, NULL , linesize, s, 0) +
668 dv_init_enc_block(enc_blk+2, y_ptr + 8 , linesize, s, 0) +
669 dv_init_enc_block(enc_blk+3, NULL , linesize, s, 0);
672 dv_init_enc_block(enc_blk+0, y_ptr , linesize, s, 0) +
673 dv_init_enc_block(enc_blk+1, y_ptr + 8 , linesize, s, 0) +
674 dv_init_enc_block(enc_blk+2, y_ptr + y_stride, linesize, s, 0) +
675 dv_init_enc_block(enc_blk+3, y_ptr + 8 + y_stride, linesize, s, 0);
679 /* initializing chrominance blocks */
680 c_offset = (((mb_y >> (s->sys->pix_fmt == PIX_FMT_YUV420P)) * s->picture.linesize[1] +
681 (mb_x >> ((s->sys->pix_fmt == PIX_FMT_YUV411P) ? 2 : 1))) << 3);
682 for (j = 2; j; j--) {
683 uint8_t *c_ptr = s->picture.data[j] + c_offset;
684 linesize = s->picture.linesize[j];
685 y_stride = (mb_y == 134) ? 8 : (s->picture.linesize[j] << 3);
686 if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8)) {
688 uint8_t* b = scratch;
689 for (i = 0; i < 8; i++) {
690 d = c_ptr + (linesize << 3);
691 b[0] = c_ptr[0]; b[1] = c_ptr[1]; b[2] = c_ptr[2]; b[3] = c_ptr[3];
692 b[4] = d[0]; b[5] = d[1]; b[6] = d[2]; b[7] = d[3];
700 vs_bit_size += dv_init_enc_block( enc_blk++, c_ptr , linesize, s, 1);
701 if (s->sys->bpm == 8) {
702 vs_bit_size += dv_init_enc_block(enc_blk++, c_ptr + y_stride, linesize, s, 1);
707 if (vs_total_ac_bits < vs_bit_size)
708 dv_guess_qnos(&enc_blks[0], qnosp);
710 /* DIF encoding process */
711 for (j=0; j<5*s->sys->bpm;) {
717 /* First pass over individual cells only */
718 for (i=0; i<s->sys->bpm; i++, j++) {
719 int sz = s->sys->block_sizes[i]>>3;
721 init_put_bits(&pbs[j], dif, sz);
722 put_sbits(&pbs[j], 9, ((enc_blks[j].mb[0] >> 3) - 1024 + 2) >> 2);
723 put_bits(&pbs[j], 1, enc_blks[j].dct_mode);
724 put_bits(&pbs[j], 2, enc_blks[j].cno);
726 dv_encode_ac(&enc_blks[j], &pbs[j], &pbs[j+1]);
730 /* Second pass over each MB space */
732 for (i=0; i<s->sys->bpm; i++) {
733 if (enc_blks[start_mb+i].partial_bit_count)
734 pb = dv_encode_ac(&enc_blks[start_mb+i], pb, &pbs[start_mb+s->sys->bpm]);
738 /* Third and final pass over the whole video segment space */
740 for (j=0; j<5*s->sys->bpm; j++) {
741 if (enc_blks[j].partial_bit_count)
742 pb = dv_encode_ac(&enc_blks[j], pb, &pbs[s->sys->bpm*5]);
743 if (enc_blks[j].partial_bit_count)
744 av_log(avctx, AV_LOG_ERROR, "ac bitstream overflow\n");
747 for (j=0; j<5*s->sys->bpm; j++) {
749 int size = pbs[j].size_in_bits >> 3;
750 flush_put_bits(&pbs[j]);
751 pos = put_bits_count(&pbs[j]) >> 3;
753 av_log(avctx, AV_LOG_ERROR, "bitstream written beyond buffer size\n");
756 memset(pbs[j].buf + pos, 0xff, size - pos);
762 static inline int dv_write_pack(enum dv_pack_type pack_id, DVVideoContext *c,
766 * Here's what SMPTE314M says about these two:
767 * (page 6) APTn, AP1n, AP2n, AP3n: These data shall be identical
768 * as track application IDs (APTn = 001, AP1n =
769 * 001, AP2n = 001, AP3n = 001), if the source signal
770 * comes from a digital VCR. If the signal source is
771 * unknown, all bits for these data shall be set to 1.
772 * (page 12) STYPE: STYPE defines a signal type of video signal
773 * 00000b = 4:1:1 compression
774 * 00100b = 4:2:2 compression
776 * Now, I've got two problems with these statements:
777 * 1. it looks like APT == 111b should be a safe bet, but it isn't.
778 * It seems that for PAL as defined in IEC 61834 we have to set
779 * APT to 000 and for SMPTE314M to 001.
780 * 2. It is not at all clear what STYPE is used for 4:2:0 PAL
781 * compression scheme (if any).
783 int apt = (c->sys->pix_fmt == PIX_FMT_YUV420P ? 0 : 1);
786 if ((int)(av_q2d(c->avctx->sample_aspect_ratio) * c->avctx->width / c->avctx->height * 10) >= 17) /* 16:9 */
789 buf[0] = (uint8_t)pack_id;
791 case dv_header525: /* I can't imagine why these two weren't defined as real */
792 case dv_header625: /* packs in SMPTE314M -- they definitely look like ones */
793 buf[1] = 0xf8 | /* reserved -- always 1 */
794 (apt & 0x07); /* APT: Track application ID */
795 buf[2] = (0 << 7) | /* TF1: audio data is 0 - valid; 1 - invalid */
796 (0x0f << 3) | /* reserved -- always 1 */
797 (apt & 0x07); /* AP1: Audio application ID */
798 buf[3] = (0 << 7) | /* TF2: video data is 0 - valid; 1 - invalid */
799 (0x0f << 3) | /* reserved -- always 1 */
800 (apt & 0x07); /* AP2: Video application ID */
801 buf[4] = (0 << 7) | /* TF3: subcode(SSYB) is 0 - valid; 1 - invalid */
802 (0x0f << 3) | /* reserved -- always 1 */
803 (apt & 0x07); /* AP3: Subcode application ID */
805 case dv_video_source:
806 buf[1] = 0xff; /* reserved -- always 1 */
807 buf[2] = (1 << 7) | /* B/W: 0 - b/w, 1 - color */
808 (1 << 6) | /* following CLF is valid - 0, invalid - 1 */
809 (3 << 4) | /* CLF: color frames ID (see ITU-R BT.470-4) */
810 0xf; /* reserved -- always 1 */
811 buf[3] = (3 << 6) | /* reserved -- always 1 */
812 (c->sys->dsf << 5) | /* system: 60fields/50fields */
813 c->sys->video_stype; /* signal type video compression */
814 buf[4] = 0xff; /* VISC: 0xff -- no information */
816 case dv_video_control:
817 buf[1] = (0 << 6) | /* Copy generation management (CGMS) 0 -- free */
818 0x3f; /* reserved -- always 1 */
819 buf[2] = 0xc8 | /* reserved -- always b11001xxx */
821 buf[3] = (1 << 7) | /* frame/field flag 1 -- frame, 0 -- field */
822 (1 << 6) | /* first/second field flag 0 -- field 2, 1 -- field 1 */
823 (1 << 5) | /* frame change flag 0 -- same picture as before, 1 -- different */
824 (1 << 4) | /* 1 - interlaced, 0 - noninterlaced */
825 0xc; /* reserved -- always b1100 */
826 buf[4] = 0xff; /* reserved -- always 1 */
829 buf[1] = buf[2] = buf[3] = buf[4] = 0xff;
834 #if CONFIG_DVVIDEO_ENCODER
835 static inline int dv_write_dif_id(enum dv_section_type t, uint8_t chan_num,
836 uint8_t seq_num, uint8_t dif_num,
839 buf[0] = (uint8_t)t; /* Section type */
840 buf[1] = (seq_num << 4) | /* DIF seq number 0-9 for 525/60; 0-11 for 625/50 */
841 (chan_num << 3) | /* FSC: for 50Mb/s 0 - first channel; 1 - second */
842 7; /* reserved -- always 1 */
843 buf[2] = dif_num; /* DIF block number Video: 0-134, Audio: 0-8 */
848 static inline int dv_write_ssyb_id(uint8_t syb_num, uint8_t fr, uint8_t* buf)
850 if (syb_num == 0 || syb_num == 6) {
851 buf[0] = (fr << 7) | /* FR ID 1 - first half of each channel; 0 - second */
852 (0 << 4) | /* AP3 (Subcode application ID) */
853 0x0f; /* reserved -- always 1 */
855 else if (syb_num == 11) {
856 buf[0] = (fr << 7) | /* FR ID 1 - first half of each channel; 0 - second */
857 0x7f; /* reserved -- always 1 */
860 buf[0] = (fr << 7) | /* FR ID 1 - first half of each channel; 0 - second */
861 (0 << 4) | /* APT (Track application ID) */
862 0x0f; /* reserved -- always 1 */
864 buf[1] = 0xf0 | /* reserved -- always 1 */
865 (syb_num & 0x0f); /* SSYB number 0 - 11 */
866 buf[2] = 0xff; /* reserved -- always 1 */
870 static void dv_format_frame(DVVideoContext* c, uint8_t* buf)
874 for (chan = 0; chan < c->sys->n_difchan; chan++) {
875 for (i = 0; i < c->sys->difseg_size; i++) {
876 memset(buf, 0xff, 80 * 6); /* first 6 DIF blocks are for control data */
878 /* DV header: 1DIF */
879 buf += dv_write_dif_id(dv_sect_header, chan, i, 0, buf);
880 buf += dv_write_pack((c->sys->dsf ? dv_header625 : dv_header525), c, buf);
881 buf += 72; /* unused bytes */
883 /* DV subcode: 2DIFs */
884 for (j = 0; j < 2; j++) {
885 buf += dv_write_dif_id(dv_sect_subcode, chan, i, j, buf);
886 for (k = 0; k < 6; k++)
887 buf += dv_write_ssyb_id(k, (i < c->sys->difseg_size/2), buf) + 5;
888 buf += 29; /* unused bytes */
892 for (j = 0; j < 3; j++) {
893 buf += dv_write_dif_id(dv_sect_vaux, chan, i, j, buf);
894 buf += dv_write_pack(dv_video_source, c, buf);
895 buf += dv_write_pack(dv_video_control, c, buf);
897 buf += dv_write_pack(dv_video_source, c, buf);
898 buf += dv_write_pack(dv_video_control, c, buf);
899 buf += 4*5 + 2; /* unused bytes */
902 /* DV Audio/Video: 135 Video DIFs + 9 Audio DIFs */
903 for (j = 0; j < 135; j++) {
905 memset(buf, 0xff, 80);
906 buf += dv_write_dif_id(dv_sect_audio, chan, i, j/15, buf);
907 buf += 77; /* audio control & shuffled PCM audio */
909 buf += dv_write_dif_id(dv_sect_video, chan, i, j, buf);
910 buf += 77; /* 1 video macroblock: 1 bytes control
911 4 * 14 bytes Y 8x8 data
913 10 bytes Cb 8x8 data */
920 static int dvvideo_encode_frame(AVCodecContext *c, AVPacket *pkt,
921 const AVFrame *frame, int *got_packet)
923 DVVideoContext *s = c->priv_data;
926 s->sys = avpriv_dv_codec_profile(c);
927 if (!s->sys || ff_dv_init_dynamic_tables(s->sys))
929 if ((ret = ff_alloc_packet(pkt, s->sys->frame_size)) < 0) {
930 av_log(c, AV_LOG_ERROR, "Error getting output packet.\n");
934 c->pix_fmt = s->sys->pix_fmt;
936 s->picture.key_frame = 1;
937 s->picture.pict_type = AV_PICTURE_TYPE_I;
940 c->execute(c, dv_encode_video_segment, s->sys->work_chunks, NULL,
941 dv_work_pool_size(s->sys), sizeof(DVwork_chunk));
945 dv_format_frame(s, pkt->data);
947 pkt->flags |= AV_PKT_FLAG_KEY;
953 AVCodec ff_dvvideo_encoder = {
955 .type = AVMEDIA_TYPE_VIDEO,
956 .id = CODEC_ID_DVVIDEO,
957 .priv_data_size = sizeof(DVVideoContext),
958 .init = dvvideo_init_encoder,
959 .encode2 = dvvideo_encode_frame,
960 .capabilities = CODEC_CAP_SLICE_THREADS,
961 .pix_fmts = (const enum PixelFormat[]) {PIX_FMT_YUV411P, PIX_FMT_YUV422P, PIX_FMT_YUV420P, PIX_FMT_NONE},
962 .long_name = NULL_IF_CONFIG_SMALL("DV (Digital Video)"),
964 #endif // CONFIG_DVVIDEO_ENCODER