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"
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 AV_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 AV_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 AV_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 /* quantization quanta by QNO for DV100 */
171 static const uint8_t dv100_qstep[16] = {
172 1, /* QNO = 0 and 1 both have no quantization */
174 2, 3, 4, 5, 6, 7, 8, 16, 18, 20, 22, 24, 28, 52
177 static const uint8_t dv_quant_areas[4] = { 6, 21, 43, 64 };
179 int ff_dv_init_dynamic_tables(const DVprofile *d)
182 uint32_t *factor1, *factor2;
183 const int *iweight1, *iweight2;
185 if (!d->work_chunks[dv_work_pool_size(d)-1].buf_offset) {
187 for (c=0; c<d->n_difchan; c++) {
188 for (s=0; s<d->difseg_size; s++) {
190 for (j=0; j<27; j++) {
192 if (!(DV_PROFILE_IS_1080i50(d) && c != 0 && s == 11) &&
193 !(DV_PROFILE_IS_720p50(d) && s > 9)) {
194 dv_calc_mb_coordinates(d, c, s, j, &d->work_chunks[i].mb_coordinates[0]);
195 d->work_chunks[i++].buf_offset = p;
203 if (!d->idct_factor[DV_PROFILE_IS_HD(d)?8191:5631]) {
204 factor1 = &d->idct_factor[0];
205 factor2 = &d->idct_factor[DV_PROFILE_IS_HD(d)?4096:2816];
206 if (d->height == 720) {
207 iweight1 = &ff_dv_iweight_720_y[0];
208 iweight2 = &ff_dv_iweight_720_c[0];
210 iweight1 = &ff_dv_iweight_1080_y[0];
211 iweight2 = &ff_dv_iweight_1080_c[0];
213 if (DV_PROFILE_IS_HD(d)) {
214 for (c = 0; c < 4; c++) {
215 for (s = 0; s < 16; s++) {
216 for (i = 0; i < 64; i++) {
217 *factor1++ = (dv100_qstep[s] << (c + 9)) * iweight1[i];
218 *factor2++ = (dv100_qstep[s] << (c + 9)) * iweight2[i];
223 iweight1 = &ff_dv_iweight_88[0];
224 for (j = 0; j < 2; j++, iweight1 = &ff_dv_iweight_248[0]) {
225 for (s = 0; s < 22; s++) {
226 for (i = c = 0; c < 4; c++) {
227 for (; i < dv_quant_areas[c]; i++) {
228 *factor1 = iweight1[i] << (ff_dv_quant_shifts[s][c] + 1);
229 *factor2++ = (*factor1++) << 1;
240 av_cold int ff_dvvideo_init(AVCodecContext *avctx)
242 DVVideoContext *s = avctx->priv_data;
249 uint16_t new_dv_vlc_bits[NB_DV_VLC*2];
250 uint8_t new_dv_vlc_len[NB_DV_VLC*2];
251 uint8_t new_dv_vlc_run[NB_DV_VLC*2];
252 int16_t new_dv_vlc_level[NB_DV_VLC*2];
256 /* it's faster to include sign bit in a generic VLC parsing scheme */
257 for (i = 0, j = 0; i < NB_DV_VLC; i++, j++) {
258 new_dv_vlc_bits[j] = dv_vlc_bits[i];
259 new_dv_vlc_len[j] = dv_vlc_len[i];
260 new_dv_vlc_run[j] = dv_vlc_run[i];
261 new_dv_vlc_level[j] = dv_vlc_level[i];
263 if (dv_vlc_level[i]) {
264 new_dv_vlc_bits[j] <<= 1;
268 new_dv_vlc_bits[j] = (dv_vlc_bits[i] << 1) | 1;
269 new_dv_vlc_len[j] = dv_vlc_len[i] + 1;
270 new_dv_vlc_run[j] = dv_vlc_run[i];
271 new_dv_vlc_level[j] = -dv_vlc_level[i];
275 /* NOTE: as a trick, we use the fact the no codes are unused
276 to accelerate the parsing of partial codes */
277 init_vlc(&dv_vlc, TEX_VLC_BITS, j,
278 new_dv_vlc_len, 1, 1, new_dv_vlc_bits, 2, 2, 0);
279 assert(dv_vlc.table_size == 1184);
281 for (i = 0; i < dv_vlc.table_size; i++){
282 int code = dv_vlc.table[i][0];
283 int len = dv_vlc.table[i][1];
286 if (len < 0){ //more bits needed
290 run = new_dv_vlc_run [code] + 1;
291 level = new_dv_vlc_level[code];
293 ff_dv_rl_vlc[i].len = len;
294 ff_dv_rl_vlc[i].level = level;
295 ff_dv_rl_vlc[i].run = run;
297 ff_free_vlc(&dv_vlc);
300 /* Generic DSP setup */
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
315 memcpy(s->dv_zigzag[1], ff_zigzag248_direct, 64);
317 avcodec_get_frame_defaults(&s->picture);
318 avctx->coded_frame = &s->picture;
320 avctx->chroma_sample_location = AVCHROMA_LOC_TOPLEFT;
325 static av_cold int dvvideo_init_encoder(AVCodecContext *avctx)
327 if (!avpriv_dv_codec_profile(avctx)) {
328 av_log(avctx, AV_LOG_ERROR, "Found no DV profile for %ix%i %s video. "
329 "Valid DV profiles are:\n",
330 avctx->width, avctx->height, av_get_pix_fmt_name(avctx->pix_fmt));
331 ff_dv_print_profiles(avctx, AV_LOG_ERROR);
332 return AVERROR(EINVAL);
335 dv_vlc_map_tableinit();
337 return ff_dvvideo_init(avctx);
340 /* bit budget for AC only in 5 MBs */
341 static const int vs_total_ac_bits = (100 * 4 + 68*2) * 5;
342 static const int mb_area_start[5] = { 1, 6, 21, 43, 64 };
345 /* Converts run and level (where level != 0) pair into VLC, returning bit size */
346 static av_always_inline int dv_rl2vlc(int run, int level, int sign, uint32_t* vlc)
349 if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {
350 *vlc = dv_vlc_map[run][level].vlc | sign;
351 size = dv_vlc_map[run][level].size;
354 if (level < DV_VLC_MAP_LEV_SIZE) {
355 *vlc = dv_vlc_map[0][level].vlc | sign;
356 size = dv_vlc_map[0][level].size;
358 *vlc = 0xfe00 | (level << 1) | sign;
362 *vlc |= ((run < 16) ? dv_vlc_map[run-1][0].vlc :
363 (0x1f80 | (run - 1))) << size;
364 size += (run < 16) ? dv_vlc_map[run-1][0].size : 13;
371 static av_always_inline int dv_rl2vlc_size(int run, int level)
375 if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {
376 size = dv_vlc_map[run][level].size;
379 size = (level < DV_VLC_MAP_LEV_SIZE) ? dv_vlc_map[0][level].size : 16;
381 size += (run < 16) ? dv_vlc_map[run-1][0].size : 13;
387 static av_always_inline int dv_rl2vlc(int run, int l, int sign, uint32_t* vlc)
389 *vlc = dv_vlc_map[run][l].vlc | sign;
390 return dv_vlc_map[run][l].size;
393 static av_always_inline int dv_rl2vlc_size(int run, int l)
395 return dv_vlc_map[run][l].size;
399 typedef struct EncBlockInfo {
409 uint8_t partial_bit_count;
410 uint32_t partial_bit_buffer; /* we can't use uint16_t here */
413 static av_always_inline PutBitContext* dv_encode_ac(EncBlockInfo* bi,
414 PutBitContext* pb_pool,
415 PutBitContext* pb_end)
418 PutBitContext* pb = pb_pool;
419 int size = bi->partial_bit_count;
420 uint32_t vlc = bi->partial_bit_buffer;
422 bi->partial_bit_count = bi->partial_bit_buffer = 0;
424 /* Find suitable storage space */
425 for (; size > (bits_left = put_bits_left(pb)); pb++) {
428 put_bits(pb, bits_left, vlc >> size);
429 vlc = vlc & ((1 << size) - 1);
431 if (pb + 1 >= pb_end) {
432 bi->partial_bit_count = size;
433 bi->partial_bit_buffer = vlc;
439 put_bits(pb, size, vlc);
441 if (bi->cur_ac >= 64)
444 /* Construct the next VLC */
446 bi->cur_ac = bi->next[prev];
447 if (bi->cur_ac < 64){
448 size = dv_rl2vlc(bi->cur_ac - prev - 1, bi->mb[bi->cur_ac], bi->sign[bi->cur_ac], &vlc);
450 size = 4; vlc = 6; /* End Of Block stamp */
456 static av_always_inline int dv_guess_dct_mode(DVVideoContext *s, uint8_t *data, int linesize) {
457 if (s->avctx->flags & CODEC_FLAG_INTERLACED_DCT) {
458 int ps = s->ildct_cmp(NULL, data, NULL, linesize, 8) - 400;
460 int is = s->ildct_cmp(NULL, data , NULL, linesize<<1, 4) +
461 s->ildct_cmp(NULL, data + linesize, NULL, linesize<<1, 4);
469 static const int dv_weight_bits = 18;
470 static const int dv_weight_88[64] = {
471 131072, 257107, 257107, 242189, 252167, 242189, 235923, 237536,
472 237536, 235923, 229376, 231390, 223754, 231390, 229376, 222935,
473 224969, 217965, 217965, 224969, 222935, 200636, 218652, 211916,
474 212325, 211916, 218652, 200636, 188995, 196781, 205965, 206433,
475 206433, 205965, 196781, 188995, 185364, 185364, 200636, 200704,
476 200636, 185364, 185364, 174609, 180568, 195068, 195068, 180568,
477 174609, 170091, 175557, 189591, 175557, 170091, 165371, 170627,
478 170627, 165371, 160727, 153560, 160727, 144651, 144651, 136258,
480 static const int dv_weight_248[64] = {
481 131072, 242189, 257107, 237536, 229376, 200636, 242189, 223754,
482 224969, 196781, 262144, 242189, 229376, 200636, 257107, 237536,
483 211916, 185364, 235923, 217965, 229376, 211916, 206433, 180568,
484 242189, 223754, 224969, 196781, 211916, 185364, 235923, 217965,
485 200704, 175557, 222935, 205965, 200636, 185364, 195068, 170627,
486 229376, 211916, 206433, 180568, 200704, 175557, 222935, 205965,
487 175557, 153560, 188995, 174609, 165371, 144651, 200636, 185364,
488 195068, 170627, 175557, 153560, 188995, 174609, 165371, 144651,
491 static av_always_inline int dv_init_enc_block(EncBlockInfo* bi, uint8_t *data, int linesize, DVVideoContext *s, int bias)
494 const uint8_t* zigzag_scan;
495 LOCAL_ALIGNED_16(int16_t, blk, [64]);
497 /* We offer two different methods for class number assignment: the
498 method suggested in SMPTE 314M Table 22, and an improved
499 method. The SMPTE method is very conservative; it assigns class
500 3 (i.e. severe quantization) to any block where the largest AC
501 component is greater than 36. Libav's DV encoder tracks AC bit
502 consumption precisely, so there is no need to bias most blocks
503 towards strongly lossy compression. Instead, we assign class 2
504 to most blocks, and use class 3 only when strictly necessary
505 (for blocks whose largest AC component exceeds 255). */
507 #if 0 /* SMPTE spec method */
508 static const int classes[] = {12, 24, 36, 0xffff};
509 #else /* improved Libav method */
510 static const int classes[] = {-1, -1, 255, 0xffff};
512 int max = classes[0];
515 assert((((int)blk) & 15) == 0);
517 bi->area_q[0] = bi->area_q[1] = bi->area_q[2] = bi->area_q[3] = 0;
518 bi->partial_bit_count = 0;
519 bi->partial_bit_buffer = 0;
522 bi->dct_mode = dv_guess_dct_mode(s, data, linesize);
523 s->get_pixels(blk, data, linesize);
524 s->fdct[bi->dct_mode](blk);
526 /* We rely on the fact that encoding all zeros leads to an immediate EOB,
527 which is precisely what the spec calls for in the "dummy" blocks. */
528 memset(blk, 0, 64*sizeof(*blk));
533 zigzag_scan = bi->dct_mode ? ff_zigzag248_direct : ff_zigzag_direct;
534 weight = bi->dct_mode ? dv_weight_248 : dv_weight_88;
536 for (area = 0; area < 4; area++) {
537 bi->prev[area] = prev;
538 bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
539 for (i = mb_area_start[area]; i < mb_area_start[area+1]; i++) {
540 int level = blk[zigzag_scan[i]];
542 if (level + 15 > 30U) {
543 bi->sign[i] = (level >> 31) & 1;
544 /* weight it and and shift down into range, adding for rounding */
545 /* the extra division by a factor of 2^4 reverses the 8x expansion of the DCT
546 AND the 2x doubling of the weights */
547 level = (FFABS(level) * weight[i] + (1 << (dv_weight_bits+3))) >> (dv_weight_bits+4);
551 bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, level);
558 for (bi->cno = 0; max > classes[bi->cno]; bi->cno++);
566 for (area = 0; area < 4; area++) {
567 bi->prev[area] = prev;
568 bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
569 for (; i < mb_area_start[area+1]; i = bi->next[i]) {
573 bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, bi->mb[i]);
582 return bi->bit_size[0] + bi->bit_size[1] + bi->bit_size[2] + bi->bit_size[3];
585 static inline void dv_guess_qnos(EncBlockInfo* blks, int* qnos)
588 int i, j, k, a, prev, a2;
591 size[0] = size[1] = size[2] = size[3] = size[4] = 1 << 24;
594 for (i = 0; i < 5; i++) {
600 for (j = 0; j < 6; j++, b++) {
601 for (a = 0; a < 4; a++) {
602 if (b->area_q[a] != ff_dv_quant_shifts[qnos[i] + ff_dv_quant_offset[b->cno]][a]) {
603 b->bit_size[a] = 1; // 4 areas 4 bits for EOB :)
606 assert(b->next[prev] >= mb_area_start[a+1] || b->mb[prev]);
607 for (k = b->next[prev] ; k < mb_area_start[a+1]; k = b->next[k]) {
610 b->bit_size[a] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
613 if (b->next[k] >= mb_area_start[a+1] && b->next[k]<64){
614 for (a2 = a + 1; b->next[k] >= mb_area_start[a2+1]; a2++)
617 assert(b->mb[b->next[k]]);
618 b->bit_size[a2] += dv_rl2vlc_size(b->next[k] - prev - 1, b->mb[b->next[k]])
619 -dv_rl2vlc_size(b->next[k] - k - 1, b->mb[b->next[k]]);
620 assert(b->prev[a2] == k && (a2 + 1 >= 4 || b->prev[a2+1] != k));
623 b->next[prev] = b->next[k];
628 size[i] += b->bit_size[a];
631 if (vs_total_ac_bits >= size[0] + size[1] + size[2] + size[3] + size[4])
634 } while (qnos[0]|qnos[1]|qnos[2]|qnos[3]|qnos[4]);
637 for (a = 2; a == 2 || vs_total_ac_bits < size[0]; a += a){
639 size[0] = 5 * 6 * 4; //EOB
640 for (j = 0; j < 6 *5; j++, b++) {
642 for (k = b->next[prev]; k < 64; k = b->next[k]) {
643 if (b->mb[k] < a && b->mb[k] > -a){
644 b->next[prev] = b->next[k];
646 size[0] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
654 static int dv_encode_video_segment(AVCodecContext *avctx, void *arg)
656 DVVideoContext *s = avctx->priv_data;
657 DVwork_chunk *work_chunk = arg;
659 int mb_x, mb_y, c_offset, linesize, y_stride;
662 LOCAL_ALIGNED_8(uint8_t, scratch, [128]);
663 EncBlockInfo enc_blks[5*DV_MAX_BPM];
664 PutBitContext pbs[5*DV_MAX_BPM];
666 EncBlockInfo* enc_blk;
668 int qnos[5] = {15, 15, 15, 15, 15}; /* No quantization */
669 int* qnosp = &qnos[0];
671 dif = &s->buf[work_chunk->buf_offset*80];
672 enc_blk = &enc_blks[0];
673 for (mb_index = 0; mb_index < 5; mb_index++) {
674 dv_calculate_mb_xy(s, work_chunk, mb_index, &mb_x, &mb_y);
676 /* initializing luminance blocks */
677 if ((s->sys->pix_fmt == AV_PIX_FMT_YUV420P) ||
678 (s->sys->pix_fmt == AV_PIX_FMT_YUV411P && mb_x >= (704 / 8)) ||
679 (s->sys->height >= 720 && mb_y != 134)) {
680 y_stride = s->picture.linesize[0] << 3;
684 y_ptr = s->picture.data[0] + ((mb_y * s->picture.linesize[0] + mb_x) << 3);
685 linesize = s->picture.linesize[0];
687 if (s->sys->video_stype == 4) { /* SD 422 */
689 dv_init_enc_block(enc_blk+0, y_ptr , linesize, s, 0) +
690 dv_init_enc_block(enc_blk+1, NULL , linesize, s, 0) +
691 dv_init_enc_block(enc_blk+2, y_ptr + 8 , linesize, s, 0) +
692 dv_init_enc_block(enc_blk+3, NULL , linesize, s, 0);
695 dv_init_enc_block(enc_blk+0, y_ptr , linesize, s, 0) +
696 dv_init_enc_block(enc_blk+1, y_ptr + 8 , linesize, s, 0) +
697 dv_init_enc_block(enc_blk+2, y_ptr + y_stride, linesize, s, 0) +
698 dv_init_enc_block(enc_blk+3, y_ptr + 8 + y_stride, linesize, s, 0);
702 /* initializing chrominance blocks */
703 c_offset = (((mb_y >> (s->sys->pix_fmt == AV_PIX_FMT_YUV420P)) * s->picture.linesize[1] +
704 (mb_x >> ((s->sys->pix_fmt == AV_PIX_FMT_YUV411P) ? 2 : 1))) << 3);
705 for (j = 2; j; j--) {
706 uint8_t *c_ptr = s->picture.data[j] + c_offset;
707 linesize = s->picture.linesize[j];
708 y_stride = (mb_y == 134) ? 8 : (s->picture.linesize[j] << 3);
709 if (s->sys->pix_fmt == AV_PIX_FMT_YUV411P && mb_x >= (704 / 8)) {
711 uint8_t* b = scratch;
712 for (i = 0; i < 8; i++) {
713 d = c_ptr + (linesize << 3);
714 b[0] = c_ptr[0]; b[1] = c_ptr[1]; b[2] = c_ptr[2]; b[3] = c_ptr[3];
715 b[4] = d[0]; b[5] = d[1]; b[6] = d[2]; b[7] = d[3];
723 vs_bit_size += dv_init_enc_block( enc_blk++, c_ptr , linesize, s, 1);
724 if (s->sys->bpm == 8) {
725 vs_bit_size += dv_init_enc_block(enc_blk++, c_ptr + y_stride, linesize, s, 1);
730 if (vs_total_ac_bits < vs_bit_size)
731 dv_guess_qnos(&enc_blks[0], qnosp);
733 /* DIF encoding process */
734 for (j=0; j<5*s->sys->bpm;) {
740 /* First pass over individual cells only */
741 for (i=0; i<s->sys->bpm; i++, j++) {
742 int sz = s->sys->block_sizes[i]>>3;
744 init_put_bits(&pbs[j], dif, sz);
745 put_sbits(&pbs[j], 9, ((enc_blks[j].mb[0] >> 3) - 1024 + 2) >> 2);
746 put_bits(&pbs[j], 1, enc_blks[j].dct_mode);
747 put_bits(&pbs[j], 2, enc_blks[j].cno);
749 dv_encode_ac(&enc_blks[j], &pbs[j], &pbs[j+1]);
753 /* Second pass over each MB space */
755 for (i=0; i<s->sys->bpm; i++) {
756 if (enc_blks[start_mb+i].partial_bit_count)
757 pb = dv_encode_ac(&enc_blks[start_mb+i], pb, &pbs[start_mb+s->sys->bpm]);
761 /* Third and final pass over the whole video segment space */
763 for (j=0; j<5*s->sys->bpm; j++) {
764 if (enc_blks[j].partial_bit_count)
765 pb = dv_encode_ac(&enc_blks[j], pb, &pbs[s->sys->bpm*5]);
766 if (enc_blks[j].partial_bit_count)
767 av_log(avctx, AV_LOG_ERROR, "ac bitstream overflow\n");
770 for (j=0; j<5*s->sys->bpm; j++) {
772 int size = pbs[j].size_in_bits >> 3;
773 flush_put_bits(&pbs[j]);
774 pos = put_bits_count(&pbs[j]) >> 3;
776 av_log(avctx, AV_LOG_ERROR, "bitstream written beyond buffer size\n");
779 memset(pbs[j].buf + pos, 0xff, size - pos);
785 static inline int dv_write_pack(enum dv_pack_type pack_id, DVVideoContext *c,
789 * Here's what SMPTE314M says about these two:
790 * (page 6) APTn, AP1n, AP2n, AP3n: These data shall be identical
791 * as track application IDs (APTn = 001, AP1n =
792 * 001, AP2n = 001, AP3n = 001), if the source signal
793 * comes from a digital VCR. If the signal source is
794 * unknown, all bits for these data shall be set to 1.
795 * (page 12) STYPE: STYPE defines a signal type of video signal
796 * 00000b = 4:1:1 compression
797 * 00100b = 4:2:2 compression
799 * Now, I've got two problems with these statements:
800 * 1. it looks like APT == 111b should be a safe bet, but it isn't.
801 * It seems that for PAL as defined in IEC 61834 we have to set
802 * APT to 000 and for SMPTE314M to 001.
803 * 2. It is not at all clear what STYPE is used for 4:2:0 PAL
804 * compression scheme (if any).
806 int apt = (c->sys->pix_fmt == AV_PIX_FMT_YUV420P ? 0 : 1);
809 if ((int)(av_q2d(c->avctx->sample_aspect_ratio) * c->avctx->width / c->avctx->height * 10) >= 17) /* 16:9 */
812 buf[0] = (uint8_t)pack_id;
814 case dv_header525: /* I can't imagine why these two weren't defined as real */
815 case dv_header625: /* packs in SMPTE314M -- they definitely look like ones */
816 buf[1] = 0xf8 | /* reserved -- always 1 */
817 (apt & 0x07); /* APT: Track application ID */
818 buf[2] = (0 << 7) | /* TF1: audio data is 0 - valid; 1 - invalid */
819 (0x0f << 3) | /* reserved -- always 1 */
820 (apt & 0x07); /* AP1: Audio application ID */
821 buf[3] = (0 << 7) | /* TF2: video data is 0 - valid; 1 - invalid */
822 (0x0f << 3) | /* reserved -- always 1 */
823 (apt & 0x07); /* AP2: Video application ID */
824 buf[4] = (0 << 7) | /* TF3: subcode(SSYB) is 0 - valid; 1 - invalid */
825 (0x0f << 3) | /* reserved -- always 1 */
826 (apt & 0x07); /* AP3: Subcode application ID */
828 case dv_video_source:
829 buf[1] = 0xff; /* reserved -- always 1 */
830 buf[2] = (1 << 7) | /* B/W: 0 - b/w, 1 - color */
831 (1 << 6) | /* following CLF is valid - 0, invalid - 1 */
832 (3 << 4) | /* CLF: color frames ID (see ITU-R BT.470-4) */
833 0xf; /* reserved -- always 1 */
834 buf[3] = (3 << 6) | /* reserved -- always 1 */
835 (c->sys->dsf << 5) | /* system: 60fields/50fields */
836 c->sys->video_stype; /* signal type video compression */
837 buf[4] = 0xff; /* VISC: 0xff -- no information */
839 case dv_video_control:
840 buf[1] = (0 << 6) | /* Copy generation management (CGMS) 0 -- free */
841 0x3f; /* reserved -- always 1 */
842 buf[2] = 0xc8 | /* reserved -- always b11001xxx */
844 buf[3] = (1 << 7) | /* frame/field flag 1 -- frame, 0 -- field */
845 (1 << 6) | /* first/second field flag 0 -- field 2, 1 -- field 1 */
846 (1 << 5) | /* frame change flag 0 -- same picture as before, 1 -- different */
847 (1 << 4) | /* 1 - interlaced, 0 - noninterlaced */
848 0xc; /* reserved -- always b1100 */
849 buf[4] = 0xff; /* reserved -- always 1 */
852 buf[1] = buf[2] = buf[3] = buf[4] = 0xff;
857 #if CONFIG_DVVIDEO_ENCODER
858 static inline int dv_write_dif_id(enum dv_section_type t, uint8_t chan_num,
859 uint8_t seq_num, uint8_t dif_num,
862 buf[0] = (uint8_t)t; /* Section type */
863 buf[1] = (seq_num << 4) | /* DIF seq number 0-9 for 525/60; 0-11 for 625/50 */
864 (chan_num << 3) | /* FSC: for 50Mb/s 0 - first channel; 1 - second */
865 7; /* reserved -- always 1 */
866 buf[2] = dif_num; /* DIF block number Video: 0-134, Audio: 0-8 */
871 static inline int dv_write_ssyb_id(uint8_t syb_num, uint8_t fr, uint8_t* buf)
873 if (syb_num == 0 || syb_num == 6) {
874 buf[0] = (fr << 7) | /* FR ID 1 - first half of each channel; 0 - second */
875 (0 << 4) | /* AP3 (Subcode application ID) */
876 0x0f; /* reserved -- always 1 */
878 else if (syb_num == 11) {
879 buf[0] = (fr << 7) | /* FR ID 1 - first half of each channel; 0 - second */
880 0x7f; /* reserved -- always 1 */
883 buf[0] = (fr << 7) | /* FR ID 1 - first half of each channel; 0 - second */
884 (0 << 4) | /* APT (Track application ID) */
885 0x0f; /* reserved -- always 1 */
887 buf[1] = 0xf0 | /* reserved -- always 1 */
888 (syb_num & 0x0f); /* SSYB number 0 - 11 */
889 buf[2] = 0xff; /* reserved -- always 1 */
893 static void dv_format_frame(DVVideoContext* c, uint8_t* buf)
897 for (chan = 0; chan < c->sys->n_difchan; chan++) {
898 for (i = 0; i < c->sys->difseg_size; i++) {
899 memset(buf, 0xff, 80 * 6); /* first 6 DIF blocks are for control data */
901 /* DV header: 1DIF */
902 buf += dv_write_dif_id(dv_sect_header, chan, i, 0, buf);
903 buf += dv_write_pack((c->sys->dsf ? dv_header625 : dv_header525), c, buf);
904 buf += 72; /* unused bytes */
906 /* DV subcode: 2DIFs */
907 for (j = 0; j < 2; j++) {
908 buf += dv_write_dif_id(dv_sect_subcode, chan, i, j, buf);
909 for (k = 0; k < 6; k++)
910 buf += dv_write_ssyb_id(k, (i < c->sys->difseg_size/2), buf) + 5;
911 buf += 29; /* unused bytes */
915 for (j = 0; j < 3; j++) {
916 buf += dv_write_dif_id(dv_sect_vaux, chan, i, j, buf);
917 buf += dv_write_pack(dv_video_source, c, buf);
918 buf += dv_write_pack(dv_video_control, c, buf);
920 buf += dv_write_pack(dv_video_source, c, buf);
921 buf += dv_write_pack(dv_video_control, c, buf);
922 buf += 4*5 + 2; /* unused bytes */
925 /* DV Audio/Video: 135 Video DIFs + 9 Audio DIFs */
926 for (j = 0; j < 135; j++) {
928 memset(buf, 0xff, 80);
929 buf += dv_write_dif_id(dv_sect_audio, chan, i, j/15, buf);
930 buf += 77; /* audio control & shuffled PCM audio */
932 buf += dv_write_dif_id(dv_sect_video, chan, i, j, buf);
933 buf += 77; /* 1 video macroblock: 1 bytes control
934 4 * 14 bytes Y 8x8 data
936 10 bytes Cb 8x8 data */
943 static int dvvideo_encode_frame(AVCodecContext *c, AVPacket *pkt,
944 const AVFrame *frame, int *got_packet)
946 DVVideoContext *s = c->priv_data;
949 s->sys = avpriv_dv_codec_profile(c);
950 if (!s->sys || ff_dv_init_dynamic_tables(s->sys))
952 if ((ret = ff_alloc_packet(pkt, s->sys->frame_size)) < 0) {
953 av_log(c, AV_LOG_ERROR, "Error getting output packet.\n");
957 c->pix_fmt = s->sys->pix_fmt;
959 s->picture.key_frame = 1;
960 s->picture.pict_type = AV_PICTURE_TYPE_I;
963 c->execute(c, dv_encode_video_segment, s->sys->work_chunks, NULL,
964 dv_work_pool_size(s->sys), sizeof(DVwork_chunk));
968 dv_format_frame(s, pkt->data);
970 pkt->flags |= AV_PKT_FLAG_KEY;
976 AVCodec ff_dvvideo_encoder = {
978 .long_name = NULL_IF_CONFIG_SMALL("DV (Digital Video)"),
979 .type = AVMEDIA_TYPE_VIDEO,
980 .id = AV_CODEC_ID_DVVIDEO,
981 .priv_data_size = sizeof(DVVideoContext),
982 .init = dvvideo_init_encoder,
983 .encode2 = dvvideo_encode_frame,
984 .capabilities = CODEC_CAP_SLICE_THREADS,
985 .pix_fmts = (const enum AVPixelFormat[]) {
986 AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE
989 #endif // CONFIG_DVVIDEO_ENCODER