3 * Copyright (c) 2002 Fabrice Bellard
4 * Copyright (c) 2004 Roman Shaposhnik
7 * Copyright (c) 2003 Roman Shaposhnik
9 * 50 Mbps (DVCPRO50) support
10 * Copyright (c) 2006 Daniel Maas <dmaas@maasdigital.com>
12 * 100 Mbps (DVCPRO HD) support
13 * Initial code by Daniel Maas <dmaas@maasdigital.com> (funded by BBC R&D)
14 * Final code by Roman Shaposhnik
16 * Many thanks to Dan Dennedy <dan@dennedy.org> for providing wealth
17 * of DV technical info.
19 * This file is part of FFmpeg.
21 * FFmpeg is free software; you can redistribute it and/or
22 * modify it under the terms of the GNU Lesser General Public
23 * License as published by the Free Software Foundation; either
24 * version 2.1 of the License, or (at your option) any later version.
26 * FFmpeg is distributed in the hope that it will be useful,
27 * but WITHOUT ANY WARRANTY; without even the implied warranty of
28 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
29 * Lesser General Public License for more details.
31 * You should have received a copy of the GNU Lesser General Public
32 * License along with FFmpeg; if not, write to the Free Software
33 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
41 #include "libavutil/pixdesc.h"
47 #include "simple_idct.h"
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. "
327 "Valid DV profiles are:\n",
328 avctx->width, avctx->height, av_get_pix_fmt_name(avctx->pix_fmt));
329 ff_dv_print_profiles(avctx, AV_LOG_ERROR);
330 return AVERROR(EINVAL);
333 return ff_dvvideo_init(avctx);
336 /* bit budget for AC only in 5 MBs */
337 static const int vs_total_ac_bits = (100 * 4 + 68*2) * 5;
338 static const int mb_area_start[5] = { 1, 6, 21, 43, 64 };
340 static inline int put_bits_left(PutBitContext* s)
342 return (s->buf_end - s->buf) * 8 - put_bits_count(s);
346 /* Converts run and level (where level != 0) pair into VLC, returning bit size */
347 static av_always_inline int dv_rl2vlc(int run, int level, int sign, uint32_t* vlc)
350 if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {
351 *vlc = dv_vlc_map[run][level].vlc | sign;
352 size = dv_vlc_map[run][level].size;
355 if (level < DV_VLC_MAP_LEV_SIZE) {
356 *vlc = dv_vlc_map[0][level].vlc | sign;
357 size = dv_vlc_map[0][level].size;
359 *vlc = 0xfe00 | (level << 1) | sign;
363 *vlc |= ((run < 16) ? dv_vlc_map[run-1][0].vlc :
364 (0x1f80 | (run - 1))) << size;
365 size += (run < 16) ? dv_vlc_map[run-1][0].size : 13;
372 static av_always_inline int dv_rl2vlc_size(int run, int level)
376 if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {
377 size = dv_vlc_map[run][level].size;
380 size = (level < DV_VLC_MAP_LEV_SIZE) ? dv_vlc_map[0][level].size : 16;
382 size += (run < 16) ? dv_vlc_map[run-1][0].size : 13;
388 static av_always_inline int dv_rl2vlc(int run, int l, int sign, uint32_t* vlc)
390 *vlc = dv_vlc_map[run][l].vlc | sign;
391 return dv_vlc_map[run][l].size;
394 static av_always_inline int dv_rl2vlc_size(int run, int l)
396 return dv_vlc_map[run][l].size;
400 typedef struct EncBlockInfo {
410 uint8_t partial_bit_count;
411 uint32_t partial_bit_buffer; /* we can't use uint16_t here */
414 static av_always_inline PutBitContext* dv_encode_ac(EncBlockInfo* bi,
415 PutBitContext* pb_pool,
416 PutBitContext* pb_end)
419 PutBitContext* pb = pb_pool;
420 int size = bi->partial_bit_count;
421 uint32_t vlc = bi->partial_bit_buffer;
423 bi->partial_bit_count = bi->partial_bit_buffer = 0;
425 /* Find suitable storage space */
426 for (; size > (bits_left = put_bits_left(pb)); pb++) {
429 put_bits(pb, bits_left, vlc >> size);
430 vlc = vlc & ((1 << size) - 1);
432 if (pb + 1 >= pb_end) {
433 bi->partial_bit_count = size;
434 bi->partial_bit_buffer = vlc;
440 put_bits(pb, size, vlc);
442 if (bi->cur_ac >= 64)
445 /* Construct the next VLC */
447 bi->cur_ac = bi->next[prev];
448 if (bi->cur_ac < 64){
449 size = dv_rl2vlc(bi->cur_ac - prev - 1, bi->mb[bi->cur_ac], bi->sign[bi->cur_ac], &vlc);
451 size = 4; vlc = 6; /* End Of Block stamp */
457 static av_always_inline int dv_guess_dct_mode(DVVideoContext *s, uint8_t *data, int linesize) {
458 if (s->avctx->flags & CODEC_FLAG_INTERLACED_DCT) {
459 int ps = s->ildct_cmp(NULL, data, NULL, linesize, 8) - 400;
461 int is = s->ildct_cmp(NULL, data , NULL, linesize<<1, 4) +
462 s->ildct_cmp(NULL, data + linesize, NULL, linesize<<1, 4);
470 static av_always_inline int dv_init_enc_block(EncBlockInfo* bi, uint8_t *data, int linesize, DVVideoContext *s, int bias)
473 const uint8_t* zigzag_scan;
474 LOCAL_ALIGNED_16(DCTELEM, blk, [64]);
476 /* We offer two different methods for class number assignment: the
477 method suggested in SMPTE 314M Table 22, and an improved
478 method. The SMPTE method is very conservative; it assigns class
479 3 (i.e. severe quantization) to any block where the largest AC
480 component is greater than 36. FFmpeg's DV encoder tracks AC bit
481 consumption precisely, so there is no need to bias most blocks
482 towards strongly lossy compression. Instead, we assign class 2
483 to most blocks, and use class 3 only when strictly necessary
484 (for blocks whose largest AC component exceeds 255). */
486 #if 0 /* SMPTE spec method */
487 static const int classes[] = {12, 24, 36, 0xffff};
488 #else /* improved FFmpeg method */
489 static const int classes[] = {-1, -1, 255, 0xffff};
491 int max = classes[0];
494 assert((((int)blk) & 15) == 0);
496 bi->area_q[0] = bi->area_q[1] = bi->area_q[2] = bi->area_q[3] = 0;
497 bi->partial_bit_count = 0;
498 bi->partial_bit_buffer = 0;
501 bi->dct_mode = dv_guess_dct_mode(s, data, linesize);
502 s->get_pixels(blk, data, linesize);
503 s->fdct[bi->dct_mode](blk);
505 /* We rely on the fact that encoding all zeros leads to an immediate EOB,
506 which is precisely what the spec calls for in the "dummy" blocks. */
507 memset(blk, 0, 64*sizeof(*blk));
512 zigzag_scan = bi->dct_mode ? ff_zigzag248_direct : ff_zigzag_direct;
513 weight = bi->dct_mode ? dv_weight_248 : dv_weight_88;
515 for (area = 0; area < 4; area++) {
516 bi->prev[area] = prev;
517 bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
518 for (i = mb_area_start[area]; i < mb_area_start[area+1]; i++) {
519 int level = blk[zigzag_scan[i]];
521 if (level + 15 > 30U) {
522 bi->sign[i] = (level >> 31) & 1;
523 /* weight it and and shift down into range, adding for rounding */
524 /* the extra division by a factor of 2^4 reverses the 8x expansion of the DCT
525 AND the 2x doubling of the weights */
526 level = (FFABS(level) * weight[i] + (1 << (dv_weight_bits+3))) >> (dv_weight_bits+4);
530 bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, level);
537 for (bi->cno = 0; max > classes[bi->cno]; bi->cno++);
545 for (area = 0; area < 4; area++) {
546 bi->prev[area] = prev;
547 bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
548 for (; i < mb_area_start[area+1]; i = bi->next[i]) {
552 bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, bi->mb[i]);
561 return bi->bit_size[0] + bi->bit_size[1] + bi->bit_size[2] + bi->bit_size[3];
564 static inline void dv_guess_qnos(EncBlockInfo* blks, int* qnos)
567 int i, j, k, a, prev, a2;
570 size[0] = size[1] = size[2] = size[3] = size[4] = 1 << 24;
573 for (i = 0; i < 5; i++) {
579 for (j = 0; j < 6; j++, b++) {
580 for (a = 0; a < 4; a++) {
581 if (b->area_q[a] != dv_quant_shifts[qnos[i] + dv_quant_offset[b->cno]][a]) {
582 b->bit_size[a] = 1; // 4 areas 4 bits for EOB :)
585 assert(b->next[prev] >= mb_area_start[a+1] || b->mb[prev]);
586 for (k = b->next[prev] ; k < mb_area_start[a+1]; k = b->next[k]) {
589 b->bit_size[a] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
592 if (b->next[k] >= mb_area_start[a+1] && b->next[k]<64){
593 for (a2 = a + 1; b->next[k] >= mb_area_start[a2+1]; a2++)
596 assert(b->mb[b->next[k]]);
597 b->bit_size[a2] += dv_rl2vlc_size(b->next[k] - prev - 1, b->mb[b->next[k]])
598 -dv_rl2vlc_size(b->next[k] - k - 1, b->mb[b->next[k]]);
599 assert(b->prev[a2] == k && (a2 + 1 >= 4 || b->prev[a2+1] != k));
602 b->next[prev] = b->next[k];
607 size[i] += b->bit_size[a];
610 if (vs_total_ac_bits >= size[0] + size[1] + size[2] + size[3] + size[4])
613 } while (qnos[0]|qnos[1]|qnos[2]|qnos[3]|qnos[4]);
616 for (a = 2; a == 2 || vs_total_ac_bits < size[0]; a += a){
618 size[0] = 5 * 6 * 4; //EOB
619 for (j = 0; j < 6 *5; j++, b++) {
621 for (k = b->next[prev]; k < 64; k = b->next[k]) {
622 if (b->mb[k] < a && b->mb[k] > -a){
623 b->next[prev] = b->next[k];
625 size[0] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
633 static int dv_encode_video_segment(AVCodecContext *avctx, void *arg)
635 DVVideoContext *s = avctx->priv_data;
636 DVwork_chunk *work_chunk = arg;
638 int mb_x, mb_y, c_offset, linesize, y_stride;
641 LOCAL_ALIGNED_8(uint8_t, scratch, [64]);
642 EncBlockInfo enc_blks[5*DV_MAX_BPM];
643 PutBitContext pbs[5*DV_MAX_BPM];
645 EncBlockInfo* enc_blk;
647 int qnos[5] = {15, 15, 15, 15, 15}; /* No quantization */
648 int* qnosp = &qnos[0];
650 dif = &s->buf[work_chunk->buf_offset*80];
651 enc_blk = &enc_blks[0];
652 for (mb_index = 0; mb_index < 5; mb_index++) {
653 dv_calculate_mb_xy(s, work_chunk, mb_index, &mb_x, &mb_y);
655 /* initializing luminance blocks */
656 if ((s->sys->pix_fmt == PIX_FMT_YUV420P) ||
657 (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8)) ||
658 (s->sys->height >= 720 && mb_y != 134)) {
659 y_stride = s->picture.linesize[0] << 3;
663 y_ptr = s->picture.data[0] + ((mb_y * s->picture.linesize[0] + mb_x) << 3);
664 linesize = s->picture.linesize[0];
666 if (s->sys->video_stype == 4) { /* SD 422 */
668 dv_init_enc_block(enc_blk+0, y_ptr , linesize, s, 0) +
669 dv_init_enc_block(enc_blk+1, NULL , linesize, s, 0) +
670 dv_init_enc_block(enc_blk+2, y_ptr + 8 , linesize, s, 0) +
671 dv_init_enc_block(enc_blk+3, NULL , linesize, s, 0);
674 dv_init_enc_block(enc_blk+0, y_ptr , linesize, s, 0) +
675 dv_init_enc_block(enc_blk+1, y_ptr + 8 , linesize, s, 0) +
676 dv_init_enc_block(enc_blk+2, y_ptr + y_stride, linesize, s, 0) +
677 dv_init_enc_block(enc_blk+3, y_ptr + 8 + y_stride, linesize, s, 0);
681 /* initializing chrominance blocks */
682 c_offset = (((mb_y >> (s->sys->pix_fmt == PIX_FMT_YUV420P)) * s->picture.linesize[1] +
683 (mb_x >> ((s->sys->pix_fmt == PIX_FMT_YUV411P) ? 2 : 1))) << 3);
684 for (j = 2; j; j--) {
685 uint8_t *c_ptr = s->picture.data[j] + c_offset;
686 linesize = s->picture.linesize[j];
687 y_stride = (mb_y == 134) ? 8 : (s->picture.linesize[j] << 3);
688 if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8)) {
690 uint8_t* b = scratch;
691 for (i = 0; i < 8; i++) {
692 d = c_ptr + (linesize << 3);
693 b[0] = c_ptr[0]; b[1] = c_ptr[1]; b[2] = c_ptr[2]; b[3] = c_ptr[3];
694 b[4] = d[0]; b[5] = d[1]; b[6] = d[2]; b[7] = d[3];
702 vs_bit_size += dv_init_enc_block( enc_blk++, c_ptr , linesize, s, 1);
703 if (s->sys->bpm == 8) {
704 vs_bit_size += dv_init_enc_block(enc_blk++, c_ptr + y_stride, linesize, s, 1);
709 if (vs_total_ac_bits < vs_bit_size)
710 dv_guess_qnos(&enc_blks[0], qnosp);
712 /* DIF encoding process */
713 for (j=0; j<5*s->sys->bpm;) {
719 /* First pass over individual cells only */
720 for (i=0; i<s->sys->bpm; i++, j++) {
721 int sz = s->sys->block_sizes[i]>>3;
723 init_put_bits(&pbs[j], dif, sz);
724 put_sbits(&pbs[j], 9, ((enc_blks[j].mb[0] >> 3) - 1024 + 2) >> 2);
725 put_bits(&pbs[j], 1, enc_blks[j].dct_mode);
726 put_bits(&pbs[j], 2, enc_blks[j].cno);
728 dv_encode_ac(&enc_blks[j], &pbs[j], &pbs[j+1]);
732 /* Second pass over each MB space */
734 for (i=0; i<s->sys->bpm; i++) {
735 if (enc_blks[start_mb+i].partial_bit_count)
736 pb = dv_encode_ac(&enc_blks[start_mb+i], pb, &pbs[start_mb+s->sys->bpm]);
740 /* Third and final pass over the whole video segment space */
742 for (j=0; j<5*s->sys->bpm; j++) {
743 if (enc_blks[j].partial_bit_count)
744 pb = dv_encode_ac(&enc_blks[j], pb, &pbs[s->sys->bpm*5]);
745 if (enc_blks[j].partial_bit_count)
746 av_log(avctx, AV_LOG_ERROR, "ac bitstream overflow\n");
749 for (j=0; j<5*s->sys->bpm; j++) {
751 int size = pbs[j].size_in_bits >> 3;
752 flush_put_bits(&pbs[j]);
753 pos = put_bits_count(&pbs[j]) >> 3;
755 av_log(avctx, AV_LOG_ERROR, "bitstream written beyond buffer size\n");
758 memset(pbs[j].buf + pos, 0xff, size - pos);
764 static inline int dv_write_pack(enum dv_pack_type pack_id, DVVideoContext *c,
768 * Here's what SMPTE314M says about these two:
769 * (page 6) APTn, AP1n, AP2n, AP3n: These data shall be identical
770 * as track application IDs (APTn = 001, AP1n =
771 * 001, AP2n = 001, AP3n = 001), if the source signal
772 * comes from a digital VCR. If the signal source is
773 * unknown, all bits for these data shall be set to 1.
774 * (page 12) STYPE: STYPE defines a signal type of video signal
775 * 00000b = 4:1:1 compression
776 * 00100b = 4:2:2 compression
778 * Now, I've got two problems with these statements:
779 * 1. it looks like APT == 111b should be a safe bet, but it isn't.
780 * It seems that for PAL as defined in IEC 61834 we have to set
781 * APT to 000 and for SMPTE314M to 001.
782 * 2. It is not at all clear what STYPE is used for 4:2:0 PAL
783 * compression scheme (if any).
785 int apt = (c->sys->pix_fmt == PIX_FMT_YUV420P ? 0 : 1);
788 if ((int)(av_q2d(c->avctx->sample_aspect_ratio) * c->avctx->width / c->avctx->height * 10) >= 17) /* 16:9 */
791 buf[0] = (uint8_t)pack_id;
793 case dv_header525: /* I can't imagine why these two weren't defined as real */
794 case dv_header625: /* packs in SMPTE314M -- they definitely look like ones */
795 buf[1] = 0xf8 | /* reserved -- always 1 */
796 (apt & 0x07); /* APT: Track application ID */
797 buf[2] = (0 << 7) | /* TF1: audio data is 0 - valid; 1 - invalid */
798 (0x0f << 3) | /* reserved -- always 1 */
799 (apt & 0x07); /* AP1: Audio application ID */
800 buf[3] = (0 << 7) | /* TF2: video data is 0 - valid; 1 - invalid */
801 (0x0f << 3) | /* reserved -- always 1 */
802 (apt & 0x07); /* AP2: Video application ID */
803 buf[4] = (0 << 7) | /* TF3: subcode(SSYB) is 0 - valid; 1 - invalid */
804 (0x0f << 3) | /* reserved -- always 1 */
805 (apt & 0x07); /* AP3: Subcode application ID */
807 case dv_video_source:
808 buf[1] = 0xff; /* reserved -- always 1 */
809 buf[2] = (1 << 7) | /* B/W: 0 - b/w, 1 - color */
810 (1 << 6) | /* following CLF is valid - 0, invalid - 1 */
811 (3 << 4) | /* CLF: color frames ID (see ITU-R BT.470-4) */
812 0xf; /* reserved -- always 1 */
813 buf[3] = (3 << 6) | /* reserved -- always 1 */
814 (c->sys->dsf << 5) | /* system: 60fields/50fields */
815 c->sys->video_stype; /* signal type video compression */
816 buf[4] = 0xff; /* VISC: 0xff -- no information */
818 case dv_video_control:
819 buf[1] = (0 << 6) | /* Copy generation management (CGMS) 0 -- free */
820 0x3f; /* reserved -- always 1 */
821 buf[2] = 0xc8 | /* reserved -- always b11001xxx */
823 buf[3] = (1 << 7) | /* frame/field flag 1 -- frame, 0 -- field */
824 (1 << 6) | /* first/second field flag 0 -- field 2, 1 -- field 1 */
825 (1 << 5) | /* frame change flag 0 -- same picture as before, 1 -- different */
826 (1 << 4) | /* 1 - interlaced, 0 - noninterlaced */
827 0xc; /* reserved -- always b1100 */
828 buf[4] = 0xff; /* reserved -- always 1 */
831 buf[1] = buf[2] = buf[3] = buf[4] = 0xff;
836 #if CONFIG_DVVIDEO_ENCODER
837 static inline int dv_write_dif_id(enum dv_section_type t, uint8_t chan_num,
838 uint8_t seq_num, uint8_t dif_num,
841 buf[0] = (uint8_t)t; /* Section type */
842 buf[1] = (seq_num << 4) | /* DIF seq number 0-9 for 525/60; 0-11 for 625/50 */
843 (chan_num << 3) | /* FSC: for 50Mb/s 0 - first channel; 1 - second */
844 7; /* reserved -- always 1 */
845 buf[2] = dif_num; /* DIF block number Video: 0-134, Audio: 0-8 */
850 static inline int dv_write_ssyb_id(uint8_t syb_num, uint8_t fr, uint8_t* buf)
852 if (syb_num == 0 || syb_num == 6) {
853 buf[0] = (fr << 7) | /* FR ID 1 - first half of each channel; 0 - second */
854 (0 << 4) | /* AP3 (Subcode application ID) */
855 0x0f; /* reserved -- always 1 */
857 else if (syb_num == 11) {
858 buf[0] = (fr << 7) | /* FR ID 1 - first half of each channel; 0 - second */
859 0x7f; /* reserved -- always 1 */
862 buf[0] = (fr << 7) | /* FR ID 1 - first half of each channel; 0 - second */
863 (0 << 4) | /* APT (Track application ID) */
864 0x0f; /* reserved -- always 1 */
866 buf[1] = 0xf0 | /* reserved -- always 1 */
867 (syb_num & 0x0f); /* SSYB number 0 - 11 */
868 buf[2] = 0xff; /* reserved -- always 1 */
872 static void dv_format_frame(DVVideoContext* c, uint8_t* buf)
876 for (chan = 0; chan < c->sys->n_difchan; chan++) {
877 for (i = 0; i < c->sys->difseg_size; i++) {
878 memset(buf, 0xff, 80 * 6); /* first 6 DIF blocks are for control data */
880 /* DV header: 1DIF */
881 buf += dv_write_dif_id(dv_sect_header, chan, i, 0, buf);
882 buf += dv_write_pack((c->sys->dsf ? dv_header625 : dv_header525), c, buf);
883 buf += 72; /* unused bytes */
885 /* DV subcode: 2DIFs */
886 for (j = 0; j < 2; j++) {
887 buf += dv_write_dif_id(dv_sect_subcode, chan, i, j, buf);
888 for (k = 0; k < 6; k++)
889 buf += dv_write_ssyb_id(k, (i < c->sys->difseg_size/2), buf) + 5;
890 buf += 29; /* unused bytes */
894 for (j = 0; j < 3; j++) {
895 buf += dv_write_dif_id(dv_sect_vaux, chan, i, j, buf);
896 buf += dv_write_pack(dv_video_source, c, buf);
897 buf += dv_write_pack(dv_video_control, c, buf);
899 buf += dv_write_pack(dv_video_source, c, buf);
900 buf += dv_write_pack(dv_video_control, c, buf);
901 buf += 4*5 + 2; /* unused bytes */
904 /* DV Audio/Video: 135 Video DIFs + 9 Audio DIFs */
905 for (j = 0; j < 135; j++) {
907 memset(buf, 0xff, 80);
908 buf += dv_write_dif_id(dv_sect_audio, chan, i, j/15, buf);
909 buf += 77; /* audio control & shuffled PCM audio */
911 buf += dv_write_dif_id(dv_sect_video, chan, i, j, buf);
912 buf += 77; /* 1 video macroblock: 1 bytes control
913 4 * 14 bytes Y 8x8 data
915 10 bytes Cb 8x8 data */
922 static int dvvideo_encode_frame(AVCodecContext *c, AVPacket *pkt,
923 const AVFrame *frame, int *got_packet)
925 DVVideoContext *s = c->priv_data;
928 s->sys = avpriv_dv_codec_profile(c);
929 if (!s->sys || ff_dv_init_dynamic_tables(s->sys))
931 if ((ret = ff_alloc_packet2(c, pkt, s->sys->frame_size)) < 0)
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