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