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/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 assert(dv_vlc.table_size == 1184);
280 for (i = 0; i < dv_vlc.table_size; i++){
281 int code = dv_vlc.table[i][0];
282 int len = dv_vlc.table[i][1];
285 if (len < 0){ //more bits needed
289 run = new_dv_vlc_run [code] + 1;
290 level = new_dv_vlc_level[code];
292 ff_dv_rl_vlc[i].len = len;
293 ff_dv_rl_vlc[i].level = level;
294 ff_dv_rl_vlc[i].run = run;
296 ff_free_vlc(&dv_vlc);
299 /* Generic DSP setup */
300 ff_dsputil_init(&dsp, avctx);
301 ff_set_cmp(&dsp, dsp.ildct_cmp, avctx->ildct_cmp);
302 s->get_pixels = dsp.get_pixels;
303 s->ildct_cmp = dsp.ildct_cmp[5];
306 s->fdct[0] = dsp.fdct;
307 s->idct_put[0] = dsp.idct_put;
308 for (i = 0; i < 64; i++)
309 s->dv_zigzag[0][i] = dsp.idct_permutation[ff_zigzag_direct[i]];
312 s->fdct[1] = dsp.fdct248;
313 s->idct_put[1] = ff_simple_idct248_put; // FIXME: need to add it to DSP
314 memcpy(s->dv_zigzag[1], ff_zigzag248_direct, 64);
316 avcodec_get_frame_defaults(&s->picture);
317 avctx->coded_frame = &s->picture;
319 avctx->chroma_sample_location = AVCHROMA_LOC_TOPLEFT;
324 static av_cold int dvvideo_init_encoder(AVCodecContext *avctx)
326 if (!avpriv_dv_codec_profile(avctx)) {
327 av_log(avctx, AV_LOG_ERROR, "Found no DV profile for %ix%i %s video. "
328 "Valid DV profiles are:\n",
329 avctx->width, avctx->height, av_get_pix_fmt_name(avctx->pix_fmt));
330 ff_dv_print_profiles(avctx, AV_LOG_ERROR);
331 return AVERROR(EINVAL);
334 dv_vlc_map_tableinit();
336 return ff_dvvideo_init(avctx);
339 /* bit budget for AC only in 5 MBs */
340 static const int vs_total_ac_bits = (100 * 4 + 68*2) * 5;
341 static const int mb_area_start[5] = { 1, 6, 21, 43, 64 };
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 const int dv_weight_bits = 18;
469 static const int dv_weight_88[64] = {
470 131072, 257107, 257107, 242189, 252167, 242189, 235923, 237536,
471 237536, 235923, 229376, 231390, 223754, 231390, 229376, 222935,
472 224969, 217965, 217965, 224969, 222935, 200636, 218652, 211916,
473 212325, 211916, 218652, 200636, 188995, 196781, 205965, 206433,
474 206433, 205965, 196781, 188995, 185364, 185364, 200636, 200704,
475 200636, 185364, 185364, 174609, 180568, 195068, 195068, 180568,
476 174609, 170091, 175557, 189591, 175557, 170091, 165371, 170627,
477 170627, 165371, 160727, 153560, 160727, 144651, 144651, 136258,
479 static const int dv_weight_248[64] = {
480 131072, 242189, 257107, 237536, 229376, 200636, 242189, 223754,
481 224969, 196781, 262144, 242189, 229376, 200636, 257107, 237536,
482 211916, 185364, 235923, 217965, 229376, 211916, 206433, 180568,
483 242189, 223754, 224969, 196781, 211916, 185364, 235923, 217965,
484 200704, 175557, 222935, 205965, 200636, 185364, 195068, 170627,
485 229376, 211916, 206433, 180568, 200704, 175557, 222935, 205965,
486 175557, 153560, 188995, 174609, 165371, 144651, 200636, 185364,
487 195068, 170627, 175557, 153560, 188995, 174609, 165371, 144651,
490 static av_always_inline int dv_init_enc_block(EncBlockInfo* bi, uint8_t *data, int linesize, DVVideoContext *s, int bias)
493 const uint8_t* zigzag_scan;
494 LOCAL_ALIGNED_16(int16_t, blk, [64]);
496 /* We offer two different methods for class number assignment: the
497 method suggested in SMPTE 314M Table 22, and an improved
498 method. The SMPTE method is very conservative; it assigns class
499 3 (i.e. severe quantization) to any block where the largest AC
500 component is greater than 36. Libav's DV encoder tracks AC bit
501 consumption precisely, so there is no need to bias most blocks
502 towards strongly lossy compression. Instead, we assign class 2
503 to most blocks, and use class 3 only when strictly necessary
504 (for blocks whose largest AC component exceeds 255). */
506 #if 0 /* SMPTE spec method */
507 static const int classes[] = {12, 24, 36, 0xffff};
508 #else /* improved Libav method */
509 static const int classes[] = {-1, -1, 255, 0xffff};
511 int max = classes[0];
514 assert((((int)blk) & 15) == 0);
516 bi->area_q[0] = bi->area_q[1] = bi->area_q[2] = bi->area_q[3] = 0;
517 bi->partial_bit_count = 0;
518 bi->partial_bit_buffer = 0;
521 bi->dct_mode = dv_guess_dct_mode(s, data, linesize);
522 s->get_pixels(blk, data, linesize);
523 s->fdct[bi->dct_mode](blk);
525 /* We rely on the fact that encoding all zeros leads to an immediate EOB,
526 which is precisely what the spec calls for in the "dummy" blocks. */
527 memset(blk, 0, 64*sizeof(*blk));
532 zigzag_scan = bi->dct_mode ? ff_zigzag248_direct : ff_zigzag_direct;
533 weight = bi->dct_mode ? dv_weight_248 : dv_weight_88;
535 for (area = 0; area < 4; area++) {
536 bi->prev[area] = prev;
537 bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
538 for (i = mb_area_start[area]; i < mb_area_start[area+1]; i++) {
539 int level = blk[zigzag_scan[i]];
541 if (level + 15 > 30U) {
542 bi->sign[i] = (level >> 31) & 1;
543 /* weight it and and shift down into range, adding for rounding */
544 /* the extra division by a factor of 2^4 reverses the 8x expansion of the DCT
545 AND the 2x doubling of the weights */
546 level = (FFABS(level) * weight[i] + (1 << (dv_weight_bits+3))) >> (dv_weight_bits+4);
550 bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, level);
557 for (bi->cno = 0; max > classes[bi->cno]; bi->cno++);
565 for (area = 0; area < 4; area++) {
566 bi->prev[area] = prev;
567 bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
568 for (; i < mb_area_start[area+1]; i = bi->next[i]) {
572 bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, bi->mb[i]);
581 return bi->bit_size[0] + bi->bit_size[1] + bi->bit_size[2] + bi->bit_size[3];
584 static inline void dv_guess_qnos(EncBlockInfo* blks, int* qnos)
587 int i, j, k, a, prev, a2;
590 size[0] = size[1] = size[2] = size[3] = size[4] = 1 << 24;
593 for (i = 0; i < 5; i++) {
599 for (j = 0; j < 6; j++, b++) {
600 for (a = 0; a < 4; a++) {
601 if (b->area_q[a] != ff_dv_quant_shifts[qnos[i] + ff_dv_quant_offset[b->cno]][a]) {
602 b->bit_size[a] = 1; // 4 areas 4 bits for EOB :)
605 assert(b->next[prev] >= mb_area_start[a+1] || b->mb[prev]);
606 for (k = b->next[prev] ; k < mb_area_start[a+1]; k = b->next[k]) {
609 b->bit_size[a] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
612 if (b->next[k] >= mb_area_start[a+1] && b->next[k]<64){
613 for (a2 = a + 1; b->next[k] >= mb_area_start[a2+1]; a2++)
616 assert(b->mb[b->next[k]]);
617 b->bit_size[a2] += dv_rl2vlc_size(b->next[k] - prev - 1, b->mb[b->next[k]])
618 -dv_rl2vlc_size(b->next[k] - k - 1, b->mb[b->next[k]]);
619 assert(b->prev[a2] == k && (a2 + 1 >= 4 || b->prev[a2+1] != k));
622 b->next[prev] = b->next[k];
627 size[i] += b->bit_size[a];
630 if (vs_total_ac_bits >= size[0] + size[1] + size[2] + size[3] + size[4])
633 } while (qnos[0]|qnos[1]|qnos[2]|qnos[3]|qnos[4]);
636 for (a = 2; a == 2 || vs_total_ac_bits < size[0]; a += a){
638 size[0] = 5 * 6 * 4; //EOB
639 for (j = 0; j < 6 *5; j++, b++) {
641 for (k = b->next[prev]; k < 64; k = b->next[k]) {
642 if (b->mb[k] < a && b->mb[k] > -a){
643 b->next[prev] = b->next[k];
645 size[0] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
653 static int dv_encode_video_segment(AVCodecContext *avctx, void *arg)
655 DVVideoContext *s = avctx->priv_data;
656 DVwork_chunk *work_chunk = arg;
658 int mb_x, mb_y, c_offset, linesize, y_stride;
661 LOCAL_ALIGNED_8(uint8_t, scratch, [128]);
662 EncBlockInfo enc_blks[5*DV_MAX_BPM];
663 PutBitContext pbs[5*DV_MAX_BPM];
665 EncBlockInfo* enc_blk;
667 int qnos[5] = {15, 15, 15, 15, 15}; /* No quantization */
668 int* qnosp = &qnos[0];
670 dif = &s->buf[work_chunk->buf_offset*80];
671 enc_blk = &enc_blks[0];
672 for (mb_index = 0; mb_index < 5; mb_index++) {
673 dv_calculate_mb_xy(s, work_chunk, mb_index, &mb_x, &mb_y);
675 /* initializing luminance blocks */
676 if ((s->sys->pix_fmt == AV_PIX_FMT_YUV420P) ||
677 (s->sys->pix_fmt == AV_PIX_FMT_YUV411P && mb_x >= (704 / 8)) ||
678 (s->sys->height >= 720 && mb_y != 134)) {
679 y_stride = s->picture.linesize[0] << 3;
683 y_ptr = s->picture.data[0] + ((mb_y * s->picture.linesize[0] + mb_x) << 3);
684 linesize = s->picture.linesize[0];
686 if (s->sys->video_stype == 4) { /* SD 422 */
688 dv_init_enc_block(enc_blk+0, y_ptr , linesize, s, 0) +
689 dv_init_enc_block(enc_blk+1, NULL , linesize, s, 0) +
690 dv_init_enc_block(enc_blk+2, y_ptr + 8 , linesize, s, 0) +
691 dv_init_enc_block(enc_blk+3, NULL , linesize, s, 0);
694 dv_init_enc_block(enc_blk+0, y_ptr , linesize, s, 0) +
695 dv_init_enc_block(enc_blk+1, y_ptr + 8 , linesize, s, 0) +
696 dv_init_enc_block(enc_blk+2, y_ptr + y_stride, linesize, s, 0) +
697 dv_init_enc_block(enc_blk+3, y_ptr + 8 + y_stride, linesize, s, 0);
701 /* initializing chrominance blocks */
702 c_offset = (((mb_y >> (s->sys->pix_fmt == AV_PIX_FMT_YUV420P)) * s->picture.linesize[1] +
703 (mb_x >> ((s->sys->pix_fmt == AV_PIX_FMT_YUV411P) ? 2 : 1))) << 3);
704 for (j = 2; j; j--) {
705 uint8_t *c_ptr = s->picture.data[j] + c_offset;
706 linesize = s->picture.linesize[j];
707 y_stride = (mb_y == 134) ? 8 : (s->picture.linesize[j] << 3);
708 if (s->sys->pix_fmt == AV_PIX_FMT_YUV411P && mb_x >= (704 / 8)) {
710 uint8_t* b = scratch;
711 for (i = 0; i < 8; i++) {
712 d = c_ptr + (linesize << 3);
713 b[0] = c_ptr[0]; b[1] = c_ptr[1]; b[2] = c_ptr[2]; b[3] = c_ptr[3];
714 b[4] = d[0]; b[5] = d[1]; b[6] = d[2]; b[7] = d[3];
722 vs_bit_size += dv_init_enc_block( enc_blk++, c_ptr , linesize, s, 1);
723 if (s->sys->bpm == 8) {
724 vs_bit_size += dv_init_enc_block(enc_blk++, c_ptr + y_stride, linesize, s, 1);
729 if (vs_total_ac_bits < vs_bit_size)
730 dv_guess_qnos(&enc_blks[0], qnosp);
732 /* DIF encoding process */
733 for (j=0; j<5*s->sys->bpm;) {
739 /* First pass over individual cells only */
740 for (i=0; i<s->sys->bpm; i++, j++) {
741 int sz = s->sys->block_sizes[i]>>3;
743 init_put_bits(&pbs[j], dif, sz);
744 put_sbits(&pbs[j], 9, ((enc_blks[j].mb[0] >> 3) - 1024 + 2) >> 2);
745 put_bits(&pbs[j], 1, enc_blks[j].dct_mode);
746 put_bits(&pbs[j], 2, enc_blks[j].cno);
748 dv_encode_ac(&enc_blks[j], &pbs[j], &pbs[j+1]);
752 /* Second pass over each MB space */
754 for (i=0; i<s->sys->bpm; i++) {
755 if (enc_blks[start_mb+i].partial_bit_count)
756 pb = dv_encode_ac(&enc_blks[start_mb+i], pb, &pbs[start_mb+s->sys->bpm]);
760 /* Third and final pass over the whole video segment space */
762 for (j=0; j<5*s->sys->bpm; j++) {
763 if (enc_blks[j].partial_bit_count)
764 pb = dv_encode_ac(&enc_blks[j], pb, &pbs[s->sys->bpm*5]);
765 if (enc_blks[j].partial_bit_count)
766 av_log(avctx, AV_LOG_ERROR, "ac bitstream overflow\n");
769 for (j=0; j<5*s->sys->bpm; j++) {
771 int size = pbs[j].size_in_bits >> 3;
772 flush_put_bits(&pbs[j]);
773 pos = put_bits_count(&pbs[j]) >> 3;
775 av_log(avctx, AV_LOG_ERROR, "bitstream written beyond buffer size\n");
778 memset(pbs[j].buf + pos, 0xff, size - pos);
784 static inline int dv_write_pack(enum dv_pack_type pack_id, DVVideoContext *c,
788 * Here's what SMPTE314M says about these two:
789 * (page 6) APTn, AP1n, AP2n, AP3n: These data shall be identical
790 * as track application IDs (APTn = 001, AP1n =
791 * 001, AP2n = 001, AP3n = 001), if the source signal
792 * comes from a digital VCR. If the signal source is
793 * unknown, all bits for these data shall be set to 1.
794 * (page 12) STYPE: STYPE defines a signal type of video signal
795 * 00000b = 4:1:1 compression
796 * 00100b = 4:2:2 compression
798 * Now, I've got two problems with these statements:
799 * 1. it looks like APT == 111b should be a safe bet, but it isn't.
800 * It seems that for PAL as defined in IEC 61834 we have to set
801 * APT to 000 and for SMPTE314M to 001.
802 * 2. It is not at all clear what STYPE is used for 4:2:0 PAL
803 * compression scheme (if any).
805 int apt = (c->sys->pix_fmt == AV_PIX_FMT_YUV420P ? 0 : 1);
808 if ((int)(av_q2d(c->avctx->sample_aspect_ratio) * c->avctx->width / c->avctx->height * 10) >= 17) /* 16:9 */
811 buf[0] = (uint8_t)pack_id;
813 case dv_header525: /* I can't imagine why these two weren't defined as real */
814 case dv_header625: /* packs in SMPTE314M -- they definitely look like ones */
815 buf[1] = 0xf8 | /* reserved -- always 1 */
816 (apt & 0x07); /* APT: Track application ID */
817 buf[2] = (0 << 7) | /* TF1: audio data is 0 - valid; 1 - invalid */
818 (0x0f << 3) | /* reserved -- always 1 */
819 (apt & 0x07); /* AP1: Audio application ID */
820 buf[3] = (0 << 7) | /* TF2: video data is 0 - valid; 1 - invalid */
821 (0x0f << 3) | /* reserved -- always 1 */
822 (apt & 0x07); /* AP2: Video application ID */
823 buf[4] = (0 << 7) | /* TF3: subcode(SSYB) is 0 - valid; 1 - invalid */
824 (0x0f << 3) | /* reserved -- always 1 */
825 (apt & 0x07); /* AP3: Subcode application ID */
827 case dv_video_source:
828 buf[1] = 0xff; /* reserved -- always 1 */
829 buf[2] = (1 << 7) | /* B/W: 0 - b/w, 1 - color */
830 (1 << 6) | /* following CLF is valid - 0, invalid - 1 */
831 (3 << 4) | /* CLF: color frames ID (see ITU-R BT.470-4) */
832 0xf; /* reserved -- always 1 */
833 buf[3] = (3 << 6) | /* reserved -- always 1 */
834 (c->sys->dsf << 5) | /* system: 60fields/50fields */
835 c->sys->video_stype; /* signal type video compression */
836 buf[4] = 0xff; /* VISC: 0xff -- no information */
838 case dv_video_control:
839 buf[1] = (0 << 6) | /* Copy generation management (CGMS) 0 -- free */
840 0x3f; /* reserved -- always 1 */
841 buf[2] = 0xc8 | /* reserved -- always b11001xxx */
843 buf[3] = (1 << 7) | /* frame/field flag 1 -- frame, 0 -- field */
844 (1 << 6) | /* first/second field flag 0 -- field 2, 1 -- field 1 */
845 (1 << 5) | /* frame change flag 0 -- same picture as before, 1 -- different */
846 (1 << 4) | /* 1 - interlaced, 0 - noninterlaced */
847 0xc; /* reserved -- always b1100 */
848 buf[4] = 0xff; /* reserved -- always 1 */
851 buf[1] = buf[2] = buf[3] = buf[4] = 0xff;
856 #if CONFIG_DVVIDEO_ENCODER
857 static inline int dv_write_dif_id(enum dv_section_type t, uint8_t chan_num,
858 uint8_t seq_num, uint8_t dif_num,
861 buf[0] = (uint8_t)t; /* Section type */
862 buf[1] = (seq_num << 4) | /* DIF seq number 0-9 for 525/60; 0-11 for 625/50 */
863 (chan_num << 3) | /* FSC: for 50Mb/s 0 - first channel; 1 - second */
864 7; /* reserved -- always 1 */
865 buf[2] = dif_num; /* DIF block number Video: 0-134, Audio: 0-8 */
870 static inline int dv_write_ssyb_id(uint8_t syb_num, uint8_t fr, uint8_t* buf)
872 if (syb_num == 0 || syb_num == 6) {
873 buf[0] = (fr << 7) | /* FR ID 1 - first half of each channel; 0 - second */
874 (0 << 4) | /* AP3 (Subcode application ID) */
875 0x0f; /* reserved -- always 1 */
877 else if (syb_num == 11) {
878 buf[0] = (fr << 7) | /* FR ID 1 - first half of each channel; 0 - second */
879 0x7f; /* reserved -- always 1 */
882 buf[0] = (fr << 7) | /* FR ID 1 - first half of each channel; 0 - second */
883 (0 << 4) | /* APT (Track application ID) */
884 0x0f; /* reserved -- always 1 */
886 buf[1] = 0xf0 | /* reserved -- always 1 */
887 (syb_num & 0x0f); /* SSYB number 0 - 11 */
888 buf[2] = 0xff; /* reserved -- always 1 */
892 static void dv_format_frame(DVVideoContext* c, uint8_t* buf)
896 for (chan = 0; chan < c->sys->n_difchan; chan++) {
897 for (i = 0; i < c->sys->difseg_size; i++) {
898 memset(buf, 0xff, 80 * 6); /* first 6 DIF blocks are for control data */
900 /* DV header: 1DIF */
901 buf += dv_write_dif_id(dv_sect_header, chan, i, 0, buf);
902 buf += dv_write_pack((c->sys->dsf ? dv_header625 : dv_header525), c, buf);
903 buf += 72; /* unused bytes */
905 /* DV subcode: 2DIFs */
906 for (j = 0; j < 2; j++) {
907 buf += dv_write_dif_id(dv_sect_subcode, chan, i, j, buf);
908 for (k = 0; k < 6; k++)
909 buf += dv_write_ssyb_id(k, (i < c->sys->difseg_size/2), buf) + 5;
910 buf += 29; /* unused bytes */
914 for (j = 0; j < 3; j++) {
915 buf += dv_write_dif_id(dv_sect_vaux, chan, i, j, buf);
916 buf += dv_write_pack(dv_video_source, c, buf);
917 buf += dv_write_pack(dv_video_control, c, buf);
919 buf += dv_write_pack(dv_video_source, c, buf);
920 buf += dv_write_pack(dv_video_control, c, buf);
921 buf += 4*5 + 2; /* unused bytes */
924 /* DV Audio/Video: 135 Video DIFs + 9 Audio DIFs */
925 for (j = 0; j < 135; j++) {
927 memset(buf, 0xff, 80);
928 buf += dv_write_dif_id(dv_sect_audio, chan, i, j/15, buf);
929 buf += 77; /* audio control & shuffled PCM audio */
931 buf += dv_write_dif_id(dv_sect_video, chan, i, j, buf);
932 buf += 77; /* 1 video macroblock: 1 bytes control
933 4 * 14 bytes Y 8x8 data
935 10 bytes Cb 8x8 data */
942 static int dvvideo_encode_frame(AVCodecContext *c, AVPacket *pkt,
943 const AVFrame *frame, int *got_packet)
945 DVVideoContext *s = c->priv_data;
948 s->sys = avpriv_dv_codec_profile(c);
949 if (!s->sys || ff_dv_init_dynamic_tables(s->sys))
951 if ((ret = ff_alloc_packet(pkt, s->sys->frame_size)) < 0) {
952 av_log(c, AV_LOG_ERROR, "Error getting output packet.\n");
956 c->pix_fmt = s->sys->pix_fmt;
958 s->picture.key_frame = 1;
959 s->picture.pict_type = AV_PICTURE_TYPE_I;
962 c->execute(c, dv_encode_video_segment, s->sys->work_chunks, NULL,
963 dv_work_pool_size(s->sys), sizeof(DVwork_chunk));
967 dv_format_frame(s, pkt->data);
969 pkt->flags |= AV_PKT_FLAG_KEY;
975 AVCodec ff_dvvideo_encoder = {
977 .type = AVMEDIA_TYPE_VIDEO,
978 .id = AV_CODEC_ID_DVVIDEO,
979 .priv_data_size = sizeof(DVVideoContext),
980 .init = dvvideo_init_encoder,
981 .encode2 = dvvideo_encode_frame,
982 .capabilities = CODEC_CAP_SLICE_THREADS,
983 .pix_fmts = (const enum AVPixelFormat[]) {
984 AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE
986 .long_name = NULL_IF_CONFIG_SMALL("DV (Digital Video)"),
988 #endif // CONFIG_DVVIDEO_ENCODER