Libav
dvenc.c
Go to the documentation of this file.
1 /*
2  * DV encoder
3  * Copyright (c) 2003 Roman Shaposhnik
4  *
5  * This file is part of Libav.
6  *
7  * Libav is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * Libav is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with Libav; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
27 #include "libavutil/attributes.h"
28 #include "libavutil/pixdesc.h"
29 #include "config.h"
30 #include "avcodec.h"
31 #include "internal.h"
32 #include "put_bits.h"
33 #include "dv.h"
34 #include "dv_tablegen.h"
35 
37 {
38  if (!avpriv_dv_codec_profile(avctx)) {
39  av_log(avctx, AV_LOG_ERROR, "Found no DV profile for %ix%i %s video. "
40  "Valid DV profiles are:\n",
41  avctx->width, avctx->height, av_get_pix_fmt_name(avctx->pix_fmt));
43  return AVERROR(EINVAL);
44  }
45 
46  avctx->coded_frame = av_frame_alloc();
47  if (!avctx->coded_frame)
48  return AVERROR(ENOMEM);
49 
51 
52  return ff_dvvideo_init(avctx);
53 }
54 
55 /* bit budget for AC only in 5 MBs */
56 static const int vs_total_ac_bits = (100 * 4 + 68*2) * 5;
57 static const int mb_area_start[5] = { 1, 6, 21, 43, 64 };
58 
59 #if CONFIG_SMALL
60 /* Converts run and level (where level != 0) pair into VLC, returning bit size */
61 static av_always_inline int dv_rl2vlc(int run, int level, int sign, uint32_t* vlc)
62 {
63  int size;
64  if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {
65  *vlc = dv_vlc_map[run][level].vlc | sign;
66  size = dv_vlc_map[run][level].size;
67  }
68  else {
69  if (level < DV_VLC_MAP_LEV_SIZE) {
70  *vlc = dv_vlc_map[0][level].vlc | sign;
71  size = dv_vlc_map[0][level].size;
72  } else {
73  *vlc = 0xfe00 | (level << 1) | sign;
74  size = 16;
75  }
76  if (run) {
77  *vlc |= ((run < 16) ? dv_vlc_map[run-1][0].vlc :
78  (0x1f80 | (run - 1))) << size;
79  size += (run < 16) ? dv_vlc_map[run-1][0].size : 13;
80  }
81  }
82 
83  return size;
84 }
85 
86 static av_always_inline int dv_rl2vlc_size(int run, int level)
87 {
88  int size;
89 
90  if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {
91  size = dv_vlc_map[run][level].size;
92  }
93  else {
94  size = (level < DV_VLC_MAP_LEV_SIZE) ? dv_vlc_map[0][level].size : 16;
95  if (run) {
96  size += (run < 16) ? dv_vlc_map[run-1][0].size : 13;
97  }
98  }
99  return size;
100 }
101 #else
102 static av_always_inline int dv_rl2vlc(int run, int l, int sign, uint32_t* vlc)
103 {
104  *vlc = dv_vlc_map[run][l].vlc | sign;
105  return dv_vlc_map[run][l].size;
106 }
107 
108 static av_always_inline int dv_rl2vlc_size(int run, int l)
109 {
110  return dv_vlc_map[run][l].size;
111 }
112 #endif
113 
114 typedef struct EncBlockInfo {
115  int area_q[4];
116  int bit_size[4];
117  int prev[5];
118  int cur_ac;
119  int cno;
120  int dct_mode;
121  int16_t mb[64];
123  uint8_t sign[64];
125  uint32_t partial_bit_buffer; /* we can't use uint16_t here */
126 } EncBlockInfo;
127 
129  PutBitContext* pb_pool,
130  PutBitContext* pb_end)
131 {
132  int prev, bits_left;
133  PutBitContext* pb = pb_pool;
134  int size = bi->partial_bit_count;
135  uint32_t vlc = bi->partial_bit_buffer;
136 
138  for (;;){
139  /* Find suitable storage space */
140  for (; size > (bits_left = put_bits_left(pb)); pb++) {
141  if (bits_left) {
142  size -= bits_left;
143  put_bits(pb, bits_left, vlc >> size);
144  vlc = vlc & ((1 << size) - 1);
145  }
146  if (pb + 1 >= pb_end) {
147  bi->partial_bit_count = size;
148  bi->partial_bit_buffer = vlc;
149  return pb;
150  }
151  }
152 
153  /* Store VLC */
154  put_bits(pb, size, vlc);
155 
156  if (bi->cur_ac >= 64)
157  break;
158 
159  /* Construct the next VLC */
160  prev = bi->cur_ac;
161  bi->cur_ac = bi->next[prev];
162  if (bi->cur_ac < 64){
163  size = dv_rl2vlc(bi->cur_ac - prev - 1, bi->mb[bi->cur_ac], bi->sign[bi->cur_ac], &vlc);
164  } else {
165  size = 4; vlc = 6; /* End Of Block stamp */
166  }
167  }
168  return pb;
169 }
170 
173  int ps = s->ildct_cmp(NULL, data, NULL, linesize, 8) - 400;
174  if (ps > 0) {
175  int is = s->ildct_cmp(NULL, data , NULL, linesize<<1, 4) +
176  s->ildct_cmp(NULL, data + linesize, NULL, linesize<<1, 4);
177  return ps > is;
178  }
179  }
180 
181  return 0;
182 }
183 
184 static const int dv_weight_bits = 18;
185 static const int dv_weight_88[64] = {
186  131072, 257107, 257107, 242189, 252167, 242189, 235923, 237536,
187  237536, 235923, 229376, 231390, 223754, 231390, 229376, 222935,
188  224969, 217965, 217965, 224969, 222935, 200636, 218652, 211916,
189  212325, 211916, 218652, 200636, 188995, 196781, 205965, 206433,
190  206433, 205965, 196781, 188995, 185364, 185364, 200636, 200704,
191  200636, 185364, 185364, 174609, 180568, 195068, 195068, 180568,
192  174609, 170091, 175557, 189591, 175557, 170091, 165371, 170627,
193  170627, 165371, 160727, 153560, 160727, 144651, 144651, 136258,
194 };
195 static const int dv_weight_248[64] = {
196  131072, 242189, 257107, 237536, 229376, 200636, 242189, 223754,
197  224969, 196781, 262144, 242189, 229376, 200636, 257107, 237536,
198  211916, 185364, 235923, 217965, 229376, 211916, 206433, 180568,
199  242189, 223754, 224969, 196781, 211916, 185364, 235923, 217965,
200  200704, 175557, 222935, 205965, 200636, 185364, 195068, 170627,
201  229376, 211916, 206433, 180568, 200704, 175557, 222935, 205965,
202  175557, 153560, 188995, 174609, 165371, 144651, 200636, 185364,
203  195068, 170627, 175557, 153560, 188995, 174609, 165371, 144651,
204 };
205 
206 static av_always_inline int dv_init_enc_block(EncBlockInfo* bi, uint8_t *data, int linesize, DVVideoContext *s, int bias)
207 {
208  const int *weight;
209  const uint8_t* zigzag_scan;
210  LOCAL_ALIGNED_16(int16_t, blk, [64]);
211  int i, area;
212  /* We offer two different methods for class number assignment: the
213  method suggested in SMPTE 314M Table 22, and an improved
214  method. The SMPTE method is very conservative; it assigns class
215  3 (i.e. severe quantization) to any block where the largest AC
216  component is greater than 36. Libav's DV encoder tracks AC bit
217  consumption precisely, so there is no need to bias most blocks
218  towards strongly lossy compression. Instead, we assign class 2
219  to most blocks, and use class 3 only when strictly necessary
220  (for blocks whose largest AC component exceeds 255). */
221 
222 #if 0 /* SMPTE spec method */
223  static const int classes[] = {12, 24, 36, 0xffff};
224 #else /* improved Libav method */
225  static const int classes[] = {-1, -1, 255, 0xffff};
226 #endif
227  int max = classes[0];
228  int prev = 0;
229 
230  assert((((int)blk) & 15) == 0);
231 
232  bi->area_q[0] = bi->area_q[1] = bi->area_q[2] = bi->area_q[3] = 0;
233  bi->partial_bit_count = 0;
234  bi->partial_bit_buffer = 0;
235  bi->cur_ac = 0;
236  if (data) {
237  bi->dct_mode = dv_guess_dct_mode(s, data, linesize);
238  s->get_pixels(blk, data, linesize);
239  s->fdct[bi->dct_mode](blk);
240  } else {
241  /* We rely on the fact that encoding all zeros leads to an immediate EOB,
242  which is precisely what the spec calls for in the "dummy" blocks. */
243  memset(blk, 0, 64*sizeof(*blk));
244  bi->dct_mode = 0;
245  }
246  bi->mb[0] = blk[0];
247 
248  zigzag_scan = bi->dct_mode ? ff_zigzag248_direct : ff_zigzag_direct;
249  weight = bi->dct_mode ? dv_weight_248 : dv_weight_88;
250 
251  for (area = 0; area < 4; area++) {
252  bi->prev[area] = prev;
253  bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
254  for (i = mb_area_start[area]; i < mb_area_start[area+1]; i++) {
255  int level = blk[zigzag_scan[i]];
256 
257  if (level + 15 > 30U) {
258  bi->sign[i] = (level >> 31) & 1;
259  /* weight it and and shift down into range, adding for rounding */
260  /* the extra division by a factor of 2^4 reverses the 8x expansion of the DCT
261  AND the 2x doubling of the weights */
262  level = (FFABS(level) * weight[i] + (1 << (dv_weight_bits+3))) >> (dv_weight_bits+4);
263  bi->mb[i] = level;
264  if (level > max)
265  max = level;
266  bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, level);
267  bi->next[prev]= i;
268  prev = i;
269  }
270  }
271  }
272  bi->next[prev]= i;
273  for (bi->cno = 0; max > classes[bi->cno]; bi->cno++);
274 
275  bi->cno += bias;
276 
277  if (bi->cno >= 3) {
278  bi->cno = 3;
279  prev = 0;
280  i = bi->next[prev];
281  for (area = 0; area < 4; area++) {
282  bi->prev[area] = prev;
283  bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
284  for (; i < mb_area_start[area+1]; i = bi->next[i]) {
285  bi->mb[i] >>= 1;
286 
287  if (bi->mb[i]) {
288  bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, bi->mb[i]);
289  bi->next[prev]= i;
290  prev = i;
291  }
292  }
293  }
294  bi->next[prev]= i;
295  }
296 
297  return bi->bit_size[0] + bi->bit_size[1] + bi->bit_size[2] + bi->bit_size[3];
298 }
299 
300 static inline void dv_guess_qnos(EncBlockInfo* blks, int* qnos)
301 {
302  int size[5];
303  int i, j, k, a, prev, a2;
304  EncBlockInfo* b;
305 
306  size[0] = size[1] = size[2] = size[3] = size[4] = 1 << 24;
307  do {
308  b = blks;
309  for (i = 0; i < 5; i++) {
310  if (!qnos[i])
311  continue;
312 
313  qnos[i]--;
314  size[i] = 0;
315  for (j = 0; j < 6; j++, b++) {
316  for (a = 0; a < 4; a++) {
317  if (b->area_q[a] != ff_dv_quant_shifts[qnos[i] + ff_dv_quant_offset[b->cno]][a]) {
318  b->bit_size[a] = 1; // 4 areas 4 bits for EOB :)
319  b->area_q[a]++;
320  prev = b->prev[a];
321  assert(b->next[prev] >= mb_area_start[a+1] || b->mb[prev]);
322  for (k = b->next[prev] ; k < mb_area_start[a+1]; k = b->next[k]) {
323  b->mb[k] >>= 1;
324  if (b->mb[k]) {
325  b->bit_size[a] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
326  prev = k;
327  } else {
328  if (b->next[k] >= mb_area_start[a+1] && b->next[k]<64){
329  for (a2 = a + 1; b->next[k] >= mb_area_start[a2+1]; a2++)
330  b->prev[a2] = prev;
331  assert(a2 < 4);
332  assert(b->mb[b->next[k]]);
333  b->bit_size[a2] += dv_rl2vlc_size(b->next[k] - prev - 1, b->mb[b->next[k]])
334  -dv_rl2vlc_size(b->next[k] - k - 1, b->mb[b->next[k]]);
335  assert(b->prev[a2] == k && (a2 + 1 >= 4 || b->prev[a2+1] != k));
336  b->prev[a2] = prev;
337  }
338  b->next[prev] = b->next[k];
339  }
340  }
341  b->prev[a+1]= prev;
342  }
343  size[i] += b->bit_size[a];
344  }
345  }
346  if (vs_total_ac_bits >= size[0] + size[1] + size[2] + size[3] + size[4])
347  return;
348  }
349  } while (qnos[0]|qnos[1]|qnos[2]|qnos[3]|qnos[4]);
350 
351 
352  for (a = 2; a == 2 || vs_total_ac_bits < size[0]; a += a){
353  b = blks;
354  size[0] = 5 * 6 * 4; //EOB
355  for (j = 0; j < 6 *5; j++, b++) {
356  prev = b->prev[0];
357  for (k = b->next[prev]; k < 64; k = b->next[k]) {
358  if (b->mb[k] < a && b->mb[k] > -a){
359  b->next[prev] = b->next[k];
360  }else{
361  size[0] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
362  prev = k;
363  }
364  }
365  }
366  }
367 }
368 
369 static int dv_encode_video_segment(AVCodecContext *avctx, void *arg)
370 {
371  DVVideoContext *s = avctx->priv_data;
372  DVwork_chunk *work_chunk = arg;
373  int mb_index, i, j;
374  int mb_x, mb_y, c_offset, linesize, y_stride;
375  uint8_t* y_ptr;
376  uint8_t* dif;
377  LOCAL_ALIGNED_8(uint8_t, scratch, [128]);
378  EncBlockInfo enc_blks[5*DV_MAX_BPM];
379  PutBitContext pbs[5*DV_MAX_BPM];
380  PutBitContext* pb;
381  EncBlockInfo* enc_blk;
382  int vs_bit_size = 0;
383  int qnos[5] = {15, 15, 15, 15, 15}; /* No quantization */
384  int* qnosp = &qnos[0];
385 
386  dif = &s->buf[work_chunk->buf_offset*80];
387  enc_blk = &enc_blks[0];
388  for (mb_index = 0; mb_index < 5; mb_index++) {
389  dv_calculate_mb_xy(s, work_chunk, mb_index, &mb_x, &mb_y);
390 
391  /* initializing luminance blocks */
392  if ((s->sys->pix_fmt == AV_PIX_FMT_YUV420P) ||
393  (s->sys->pix_fmt == AV_PIX_FMT_YUV411P && mb_x >= (704 / 8)) ||
394  (s->sys->height >= 720 && mb_y != 134)) {
395  y_stride = s->frame->linesize[0] << 3;
396  } else {
397  y_stride = 16;
398  }
399  y_ptr = s->frame->data[0] + ((mb_y * s->frame->linesize[0] + mb_x) << 3);
400  linesize = s->frame->linesize[0];
401 
402  if (s->sys->video_stype == 4) { /* SD 422 */
403  vs_bit_size +=
404  dv_init_enc_block(enc_blk+0, y_ptr , linesize, s, 0) +
405  dv_init_enc_block(enc_blk+1, NULL , linesize, s, 0) +
406  dv_init_enc_block(enc_blk+2, y_ptr + 8 , linesize, s, 0) +
407  dv_init_enc_block(enc_blk+3, NULL , linesize, s, 0);
408  } else {
409  vs_bit_size +=
410  dv_init_enc_block(enc_blk+0, y_ptr , linesize, s, 0) +
411  dv_init_enc_block(enc_blk+1, y_ptr + 8 , linesize, s, 0) +
412  dv_init_enc_block(enc_blk+2, y_ptr + y_stride, linesize, s, 0) +
413  dv_init_enc_block(enc_blk+3, y_ptr + 8 + y_stride, linesize, s, 0);
414  }
415  enc_blk += 4;
416 
417  /* initializing chrominance blocks */
418  c_offset = (((mb_y >> (s->sys->pix_fmt == AV_PIX_FMT_YUV420P)) * s->frame->linesize[1] +
419  (mb_x >> ((s->sys->pix_fmt == AV_PIX_FMT_YUV411P) ? 2 : 1))) << 3);
420  for (j = 2; j; j--) {
421  uint8_t *c_ptr = s->frame->data[j] + c_offset;
422  linesize = s->frame->linesize[j];
423  y_stride = (mb_y == 134) ? 8 : (s->frame->linesize[j] << 3);
424  if (s->sys->pix_fmt == AV_PIX_FMT_YUV411P && mb_x >= (704 / 8)) {
425  uint8_t* d;
426  uint8_t* b = scratch;
427  for (i = 0; i < 8; i++) {
428  d = c_ptr + (linesize << 3);
429  b[0] = c_ptr[0]; b[1] = c_ptr[1]; b[2] = c_ptr[2]; b[3] = c_ptr[3];
430  b[4] = d[0]; b[5] = d[1]; b[6] = d[2]; b[7] = d[3];
431  c_ptr += linesize;
432  b += 16;
433  }
434  c_ptr = scratch;
435  linesize = 16;
436  }
437 
438  vs_bit_size += dv_init_enc_block( enc_blk++, c_ptr , linesize, s, 1);
439  if (s->sys->bpm == 8) {
440  vs_bit_size += dv_init_enc_block(enc_blk++, c_ptr + y_stride, linesize, s, 1);
441  }
442  }
443  }
444 
445  if (vs_total_ac_bits < vs_bit_size)
446  dv_guess_qnos(&enc_blks[0], qnosp);
447 
448  /* DIF encoding process */
449  for (j=0; j<5*s->sys->bpm;) {
450  int start_mb = j;
451 
452  dif[3] = *qnosp++;
453  dif += 4;
454 
455  /* First pass over individual cells only */
456  for (i=0; i<s->sys->bpm; i++, j++) {
457  int sz = s->sys->block_sizes[i]>>3;
458 
459  init_put_bits(&pbs[j], dif, sz);
460  put_sbits(&pbs[j], 9, ((enc_blks[j].mb[0] >> 3) - 1024 + 2) >> 2);
461  put_bits(&pbs[j], 1, enc_blks[j].dct_mode);
462  put_bits(&pbs[j], 2, enc_blks[j].cno);
463 
464  dv_encode_ac(&enc_blks[j], &pbs[j], &pbs[j+1]);
465  dif += sz;
466  }
467 
468  /* Second pass over each MB space */
469  pb = &pbs[start_mb];
470  for (i=0; i<s->sys->bpm; i++) {
471  if (enc_blks[start_mb+i].partial_bit_count)
472  pb = dv_encode_ac(&enc_blks[start_mb+i], pb, &pbs[start_mb+s->sys->bpm]);
473  }
474  }
475 
476  /* Third and final pass over the whole video segment space */
477  pb = &pbs[0];
478  for (j=0; j<5*s->sys->bpm; j++) {
479  if (enc_blks[j].partial_bit_count)
480  pb = dv_encode_ac(&enc_blks[j], pb, &pbs[s->sys->bpm*5]);
481  if (enc_blks[j].partial_bit_count)
482  av_log(avctx, AV_LOG_ERROR, "ac bitstream overflow\n");
483  }
484 
485  for (j=0; j<5*s->sys->bpm; j++) {
486  int pos;
487  int size = pbs[j].size_in_bits >> 3;
488  flush_put_bits(&pbs[j]);
489  pos = put_bits_count(&pbs[j]) >> 3;
490  if (pos > size) {
491  av_log(avctx, AV_LOG_ERROR, "bitstream written beyond buffer size\n");
492  return -1;
493  }
494  memset(pbs[j].buf + pos, 0xff, size - pos);
495  }
496 
497  return 0;
498 }
499 
500 static inline int dv_write_pack(enum dv_pack_type pack_id, DVVideoContext *c,
501  uint8_t* buf)
502 {
503  /*
504  * Here's what SMPTE314M says about these two:
505  * (page 6) APTn, AP1n, AP2n, AP3n: These data shall be identical
506  * as track application IDs (APTn = 001, AP1n =
507  * 001, AP2n = 001, AP3n = 001), if the source signal
508  * comes from a digital VCR. If the signal source is
509  * unknown, all bits for these data shall be set to 1.
510  * (page 12) STYPE: STYPE defines a signal type of video signal
511  * 00000b = 4:1:1 compression
512  * 00100b = 4:2:2 compression
513  * XXXXXX = Reserved
514  * Now, I've got two problems with these statements:
515  * 1. it looks like APT == 111b should be a safe bet, but it isn't.
516  * It seems that for PAL as defined in IEC 61834 we have to set
517  * APT to 000 and for SMPTE314M to 001.
518  * 2. It is not at all clear what STYPE is used for 4:2:0 PAL
519  * compression scheme (if any).
520  */
521  int apt = (c->sys->pix_fmt == AV_PIX_FMT_YUV420P ? 0 : 1);
522 
523  uint8_t aspect = 0;
524  if ((int)(av_q2d(c->avctx->sample_aspect_ratio) * c->avctx->width / c->avctx->height * 10) >= 17) /* 16:9 */
525  aspect = 0x02;
526 
527  buf[0] = (uint8_t)pack_id;
528  switch (pack_id) {
529  case dv_header525: /* I can't imagine why these two weren't defined as real */
530  case dv_header625: /* packs in SMPTE314M -- they definitely look like ones */
531  buf[1] = 0xf8 | /* reserved -- always 1 */
532  (apt & 0x07); /* APT: Track application ID */
533  buf[2] = (0 << 7) | /* TF1: audio data is 0 - valid; 1 - invalid */
534  (0x0f << 3) | /* reserved -- always 1 */
535  (apt & 0x07); /* AP1: Audio application ID */
536  buf[3] = (0 << 7) | /* TF2: video data is 0 - valid; 1 - invalid */
537  (0x0f << 3) | /* reserved -- always 1 */
538  (apt & 0x07); /* AP2: Video application ID */
539  buf[4] = (0 << 7) | /* TF3: subcode(SSYB) is 0 - valid; 1 - invalid */
540  (0x0f << 3) | /* reserved -- always 1 */
541  (apt & 0x07); /* AP3: Subcode application ID */
542  break;
543  case dv_video_source:
544  buf[1] = 0xff; /* reserved -- always 1 */
545  buf[2] = (1 << 7) | /* B/W: 0 - b/w, 1 - color */
546  (1 << 6) | /* following CLF is valid - 0, invalid - 1 */
547  (3 << 4) | /* CLF: color frames ID (see ITU-R BT.470-4) */
548  0xf; /* reserved -- always 1 */
549  buf[3] = (3 << 6) | /* reserved -- always 1 */
550  (c->sys->dsf << 5) | /* system: 60fields/50fields */
551  c->sys->video_stype; /* signal type video compression */
552  buf[4] = 0xff; /* VISC: 0xff -- no information */
553  break;
554  case dv_video_control:
555  buf[1] = (0 << 6) | /* Copy generation management (CGMS) 0 -- free */
556  0x3f; /* reserved -- always 1 */
557  buf[2] = 0xc8 | /* reserved -- always b11001xxx */
558  aspect;
559  buf[3] = (1 << 7) | /* frame/field flag 1 -- frame, 0 -- field */
560  (1 << 6) | /* first/second field flag 0 -- field 2, 1 -- field 1 */
561  (1 << 5) | /* frame change flag 0 -- same picture as before, 1 -- different */
562  (1 << 4) | /* 1 - interlaced, 0 - noninterlaced */
563  0xc; /* reserved -- always b1100 */
564  buf[4] = 0xff; /* reserved -- always 1 */
565  break;
566  default:
567  buf[1] = buf[2] = buf[3] = buf[4] = 0xff;
568  }
569  return 5;
570 }
571 
572 static inline int dv_write_dif_id(enum dv_section_type t, uint8_t chan_num,
573  uint8_t seq_num, uint8_t dif_num,
574  uint8_t* buf)
575 {
576  buf[0] = (uint8_t)t; /* Section type */
577  buf[1] = (seq_num << 4) | /* DIF seq number 0-9 for 525/60; 0-11 for 625/50 */
578  (chan_num << 3) | /* FSC: for 50Mb/s 0 - first channel; 1 - second */
579  7; /* reserved -- always 1 */
580  buf[2] = dif_num; /* DIF block number Video: 0-134, Audio: 0-8 */
581  return 3;
582 }
583 
584 
585 static inline int dv_write_ssyb_id(uint8_t syb_num, uint8_t fr, uint8_t* buf)
586 {
587  if (syb_num == 0 || syb_num == 6) {
588  buf[0] = (fr << 7) | /* FR ID 1 - first half of each channel; 0 - second */
589  (0 << 4) | /* AP3 (Subcode application ID) */
590  0x0f; /* reserved -- always 1 */
591  }
592  else if (syb_num == 11) {
593  buf[0] = (fr << 7) | /* FR ID 1 - first half of each channel; 0 - second */
594  0x7f; /* reserved -- always 1 */
595  }
596  else {
597  buf[0] = (fr << 7) | /* FR ID 1 - first half of each channel; 0 - second */
598  (0 << 4) | /* APT (Track application ID) */
599  0x0f; /* reserved -- always 1 */
600  }
601  buf[1] = 0xf0 | /* reserved -- always 1 */
602  (syb_num & 0x0f); /* SSYB number 0 - 11 */
603  buf[2] = 0xff; /* reserved -- always 1 */
604  return 3;
605 }
606 
608 {
609  int chan, i, j, k;
610 
611  for (chan = 0; chan < c->sys->n_difchan; chan++) {
612  for (i = 0; i < c->sys->difseg_size; i++) {
613  memset(buf, 0xff, 80 * 6); /* first 6 DIF blocks are for control data */
614 
615  /* DV header: 1DIF */
616  buf += dv_write_dif_id(dv_sect_header, chan, i, 0, buf);
617  buf += dv_write_pack((c->sys->dsf ? dv_header625 : dv_header525), c, buf);
618  buf += 72; /* unused bytes */
619 
620  /* DV subcode: 2DIFs */
621  for (j = 0; j < 2; j++) {
622  buf += dv_write_dif_id(dv_sect_subcode, chan, i, j, buf);
623  for (k = 0; k < 6; k++)
624  buf += dv_write_ssyb_id(k, (i < c->sys->difseg_size/2), buf) + 5;
625  buf += 29; /* unused bytes */
626  }
627 
628  /* DV VAUX: 3DIFS */
629  for (j = 0; j < 3; j++) {
630  buf += dv_write_dif_id(dv_sect_vaux, chan, i, j, buf);
631  buf += dv_write_pack(dv_video_source, c, buf);
632  buf += dv_write_pack(dv_video_control, c, buf);
633  buf += 7*5;
634  buf += dv_write_pack(dv_video_source, c, buf);
635  buf += dv_write_pack(dv_video_control, c, buf);
636  buf += 4*5 + 2; /* unused bytes */
637  }
638 
639  /* DV Audio/Video: 135 Video DIFs + 9 Audio DIFs */
640  for (j = 0; j < 135; j++) {
641  if (j%15 == 0) {
642  memset(buf, 0xff, 80);
643  buf += dv_write_dif_id(dv_sect_audio, chan, i, j/15, buf);
644  buf += 77; /* audio control & shuffled PCM audio */
645  }
646  buf += dv_write_dif_id(dv_sect_video, chan, i, j, buf);
647  buf += 77; /* 1 video macroblock: 1 bytes control
648  4 * 14 bytes Y 8x8 data
649  10 bytes Cr 8x8 data
650  10 bytes Cb 8x8 data */
651  }
652  }
653  }
654 }
655 
656 
658  const AVFrame *frame, int *got_packet)
659 {
660  DVVideoContext *s = c->priv_data;
661  int ret;
662 
664  if (!s->sys || ff_dv_init_dynamic_tables(s->sys))
665  return -1;
666  if ((ret = ff_alloc_packet(pkt, s->sys->frame_size)) < 0) {
667  av_log(c, AV_LOG_ERROR, "Error getting output packet.\n");
668  return ret;
669  }
670 
671  c->pix_fmt = s->sys->pix_fmt;
672  s->frame = frame;
673  c->coded_frame->key_frame = 1;
675 
676  s->buf = pkt->data;
678  dv_work_pool_size(s->sys), sizeof(DVwork_chunk));
679 
680  emms_c();
681 
682  dv_format_frame(s, pkt->data);
683 
684  pkt->flags |= AV_PKT_FLAG_KEY;
685  *got_packet = 1;
686 
687  return 0;
688 }
689 
691 {
692  av_frame_free(&avctx->coded_frame);
693  return 0;
694 }
695 
697  .name = "dvvideo",
698  .long_name = NULL_IF_CONFIG_SMALL("DV (Digital Video)"),
699  .type = AVMEDIA_TYPE_VIDEO,
700  .id = AV_CODEC_ID_DVVIDEO,
701  .priv_data_size = sizeof(DVVideoContext),
703  .encode2 = dvvideo_encode_frame,
705  .capabilities = CODEC_CAP_SLICE_THREADS,
706  .pix_fmts = (const enum AVPixelFormat[]) {
708  },
709 };