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  * quant_deadzone code and fixes sponsored by NOA GmbH
22  */
23 
24 /**
25  * @file
26  * DV encoder
27  */
28 
29 #include "config.h"
30 
31 #include "libavutil/attributes.h"
32 #include "libavutil/internal.h"
33 #include "libavutil/opt.h"
34 #include "libavutil/pixdesc.h"
35 
36 #include "avcodec.h"
37 #include "dv.h"
38 #include "dv_profile_internal.h"
39 #include "dv_tablegen.h"
40 #include "fdctdsp.h"
41 #include "internal.h"
42 #include "mathops.h"
43 #include "me_cmp.h"
44 #include "pixblockdsp.h"
45 #include "put_bits.h"
46 
48 {
49  DVVideoContext *s = avctx->priv_data;
50  FDCTDSPContext fdsp;
51  MECmpContext mecc;
52  PixblockDSPContext pdsp;
53  int ret;
54 
55  s->sys = av_dv_codec_profile2(avctx->width, avctx->height, avctx->pix_fmt, avctx->time_base);
56  if (!s->sys) {
57  av_log(avctx, AV_LOG_ERROR, "Found no DV profile for %ix%i %s video. "
58  "Valid DV profiles are:\n",
59  avctx->width, avctx->height, av_get_pix_fmt_name(avctx->pix_fmt));
61  return AVERROR(EINVAL);
62  }
63  if (avctx->height > 576) {
64  av_log(avctx, AV_LOG_ERROR, "DVCPRO HD encoding is not supported.\n");
65  return AVERROR_PATCHWELCOME;
66  }
67  ret = ff_dv_init_dynamic_tables(s, s->sys);
68  if (ret < 0) {
69  av_log(avctx, AV_LOG_ERROR, "Error initializing work tables.\n");
70  return ret;
71  }
72 
74 
75  memset(&fdsp,0, sizeof(fdsp));
76  memset(&mecc,0, sizeof(mecc));
77  memset(&pdsp,0, sizeof(pdsp));
78  ff_fdctdsp_init(&fdsp, avctx);
79  ff_me_cmp_init(&mecc, avctx);
80  ff_pixblockdsp_init(&pdsp, avctx);
81  ff_set_cmp(&mecc, mecc.ildct_cmp, avctx->ildct_cmp);
82 
83  s->get_pixels = pdsp.get_pixels;
84  s->ildct_cmp = mecc.ildct_cmp[5];
85 
86  s->fdct[0] = fdsp.fdct;
87  s->fdct[1] = fdsp.fdct248;
88 
89  return ff_dvvideo_init(avctx);
90 }
91 
92 /* bit budget for AC only in 5 MBs */
93 static const int vs_total_ac_bits = (100 * 4 + 68 * 2) * 5;
94 static const int mb_area_start[5] = { 1, 6, 21, 43, 64 };
95 
96 #if CONFIG_SMALL
97 /* Convert run and level (where level != 0) pair into VLC, returning bit size */
98 static av_always_inline int dv_rl2vlc(int run, int level, int sign,
99  uint32_t *vlc)
100 {
101  int size;
102  if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {
103  *vlc = dv_vlc_map[run][level].vlc | sign;
104  size = dv_vlc_map[run][level].size;
105  } else {
106  if (level < DV_VLC_MAP_LEV_SIZE) {
107  *vlc = dv_vlc_map[0][level].vlc | sign;
108  size = dv_vlc_map[0][level].size;
109  } else {
110  *vlc = 0xfe00 | (level << 1) | sign;
111  size = 16;
112  }
113  if (run) {
114  *vlc |= ((run < 16) ? dv_vlc_map[run - 1][0].vlc :
115  (0x1f80 | (run - 1))) << size;
116  size += (run < 16) ? dv_vlc_map[run - 1][0].size : 13;
117  }
118  }
119 
120  return size;
121 }
122 
123 static av_always_inline int dv_rl2vlc_size(int run, int level)
124 {
125  int size;
126 
127  if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {
128  size = dv_vlc_map[run][level].size;
129  } else {
130  size = (level < DV_VLC_MAP_LEV_SIZE) ? dv_vlc_map[0][level].size : 16;
131  if (run)
132  size += (run < 16) ? dv_vlc_map[run - 1][0].size : 13;
133  }
134  return size;
135 }
136 #else
137 static av_always_inline int dv_rl2vlc(int run, int l, int sign, uint32_t *vlc)
138 {
139  *vlc = dv_vlc_map[run][l].vlc | sign;
140  return dv_vlc_map[run][l].size;
141 }
142 
143 static av_always_inline int dv_rl2vlc_size(int run, int l)
144 {
145  return dv_vlc_map[run][l].size;
146 }
147 #endif
148 
149 typedef struct EncBlockInfo {
150  int area_q[4];
151  int bit_size[4];
152  int prev[5];
153  int cur_ac;
154  int cno;
155  int dct_mode;
156  int16_t mb[64];
158  uint8_t sign[64];
160  uint32_t partial_bit_buffer; /* we can't use uint16_t here */
161 } EncBlockInfo;
162 
164  PutBitContext *pb_pool,
165  PutBitContext *pb_end)
166 {
167  int prev, bits_left;
168  PutBitContext *pb = pb_pool;
169  int size = bi->partial_bit_count;
170  uint32_t vlc = bi->partial_bit_buffer;
171 
172  bi->partial_bit_count =
173  bi->partial_bit_buffer = 0;
174  for (;;) {
175  /* Find suitable storage space */
176  for (; size > (bits_left = put_bits_left(pb)); pb++) {
177  if (bits_left) {
178  size -= bits_left;
179  put_bits(pb, bits_left, vlc >> size);
180  vlc = av_mod_uintp2(vlc, size);
181  }
182  if (pb + 1 >= pb_end) {
183  bi->partial_bit_count = size;
184  bi->partial_bit_buffer = vlc;
185  return pb;
186  }
187  }
188 
189  /* Store VLC */
190  put_bits(pb, size, vlc);
191 
192  if (bi->cur_ac >= 64)
193  break;
194 
195  /* Construct the next VLC */
196  prev = bi->cur_ac;
197  bi->cur_ac = bi->next[prev];
198  if (bi->cur_ac < 64) {
199  size = dv_rl2vlc(bi->cur_ac - prev - 1, bi->mb[bi->cur_ac],
200  bi->sign[bi->cur_ac], &vlc);
201  } else {
202  size = 4;
203  vlc = 6; /* End Of Block stamp */
204  }
205  }
206  return pb;
207 }
208 
210  ptrdiff_t linesize)
211 {
213  int ps = s->ildct_cmp(NULL, data, NULL, linesize, 8) - 400;
214  if (ps > 0) {
215  int is = s->ildct_cmp(NULL, data, NULL, linesize << 1, 4) +
216  s->ildct_cmp(NULL, data + linesize, NULL, linesize << 1, 4);
217  return ps > is;
218  }
219  }
220 
221  return 0;
222 }
223 
224 static const int dv_weight_bits = 18;
225 static const int dv_weight_88[64] = {
226  131072, 257107, 257107, 242189, 252167, 242189, 235923, 237536,
227  237536, 235923, 229376, 231390, 223754, 231390, 229376, 222935,
228  224969, 217965, 217965, 224969, 222935, 200636, 218652, 211916,
229  212325, 211916, 218652, 200636, 188995, 196781, 205965, 206433,
230  206433, 205965, 196781, 188995, 185364, 185364, 200636, 200704,
231  200636, 185364, 185364, 174609, 180568, 195068, 195068, 180568,
232  174609, 170091, 175557, 189591, 175557, 170091, 165371, 170627,
233  170627, 165371, 160727, 153560, 160727, 144651, 144651, 136258,
234 };
235 static const int dv_weight_248[64] = {
236  131072, 262144, 257107, 257107, 242189, 242189, 242189, 242189,
237  237536, 237536, 229376, 229376, 200636, 200636, 224973, 224973,
238  223754, 223754, 235923, 235923, 229376, 229376, 217965, 217965,
239  211916, 211916, 196781, 196781, 185364, 185364, 206433, 206433,
240  211916, 211916, 222935, 222935, 200636, 200636, 205964, 205964,
241  200704, 200704, 180568, 180568, 175557, 175557, 195068, 195068,
242  185364, 185364, 188995, 188995, 174606, 174606, 175557, 175557,
243  170627, 170627, 153560, 153560, 165371, 165371, 144651, 144651,
244 };
245 
247  ptrdiff_t linesize,
248  DVVideoContext *s, int bias)
249 {
250  const int *weight;
251  const uint8_t *zigzag_scan;
252  LOCAL_ALIGNED_16(int16_t, blk, [64]);
253  int i, area;
254  /* We offer two different methods for class number assignment: the
255  * method suggested in SMPTE 314M Table 22, and an improved
256  * method. The SMPTE method is very conservative; it assigns class
257  * 3 (i.e. severe quantization) to any block where the largest AC
258  * component is greater than 36. FFmpeg's DV encoder tracks AC bit
259  * consumption precisely, so there is no need to bias most blocks
260  * towards strongly lossy compression. Instead, we assign class 2
261  * to most blocks, and use class 3 only when strictly necessary
262  * (for blocks whose largest AC component exceeds 255). */
263 
264 #if 0 /* SMPTE spec method */
265  static const int classes[] = { 12, 24, 36, 0xffff };
266 #else /* improved FFmpeg method */
267  static const int classes[] = { -1, -1, 255, 0xffff };
268 #endif
269  int max = classes[0];
270  int prev = 0;
271  const unsigned deadzone = s->quant_deadzone;
272  const unsigned threshold = 2 * deadzone;
273 
274  av_assert2((((int) blk) & 15) == 0);
275 
276  bi->area_q[0] =
277  bi->area_q[1] =
278  bi->area_q[2] =
279  bi->area_q[3] = 0;
280  bi->partial_bit_count = 0;
281  bi->partial_bit_buffer = 0;
282  bi->cur_ac = 0;
283  if (data) {
284  bi->dct_mode = dv_guess_dct_mode(s, data, linesize);
285  s->get_pixels(blk, data, linesize);
286  s->fdct[bi->dct_mode](blk);
287  } else {
288  /* We rely on the fact that encoding all zeros leads to an immediate
289  * EOB, which is precisely what the spec calls for in the "dummy"
290  * blocks. */
291  memset(blk, 0, 64 * sizeof(*blk));
292  bi->dct_mode = 0;
293  }
294  bi->mb[0] = blk[0];
295 
296  zigzag_scan = bi->dct_mode ? ff_dv_zigzag248_direct : ff_zigzag_direct;
297  weight = bi->dct_mode ? dv_weight_248 : dv_weight_88;
298 
299  for (area = 0; area < 4; area++) {
300  bi->prev[area] = prev;
301  bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
302  for (i = mb_area_start[area]; i < mb_area_start[area + 1]; i++) {
303  int level = blk[zigzag_scan[i]];
304 
305  if (level + deadzone > threshold) {
306  bi->sign[i] = (level >> 31) & 1;
307  /* Weight it and shift down into range, adding for rounding.
308  * The extra division by a factor of 2^4 reverses the 8x
309  * expansion of the DCT AND the 2x doubling of the weights. */
310  level = (FFABS(level) * weight[i] + (1 << (dv_weight_bits + 3))) >>
311  (dv_weight_bits + 4);
312  if (!level)
313  continue;
314  bi->mb[i] = level;
315  if (level > max)
316  max = level;
317  bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, level);
318  bi->next[prev] = i;
319  prev = i;
320  }
321  }
322  }
323  bi->next[prev] = i;
324  for (bi->cno = 0; max > classes[bi->cno]; bi->cno++)
325  ;
326 
327  bi->cno += bias;
328 
329  if (bi->cno >= 3) {
330  bi->cno = 3;
331  prev = 0;
332  i = bi->next[prev];
333  for (area = 0; area < 4; area++) {
334  bi->prev[area] = prev;
335  bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
336  for (; i < mb_area_start[area + 1]; i = bi->next[i]) {
337  bi->mb[i] >>= 1;
338 
339  if (bi->mb[i]) {
340  bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, bi->mb[i]);
341  bi->next[prev] = i;
342  prev = i;
343  }
344  }
345  }
346  bi->next[prev] = i;
347  }
348 
349  return bi->bit_size[0] + bi->bit_size[1] +
350  bi->bit_size[2] + bi->bit_size[3];
351 }
352 
353 static inline void dv_guess_qnos(EncBlockInfo *blks, int *qnos)
354 {
355  int size[5];
356  int i, j, k, a, prev, a2;
357  EncBlockInfo *b;
358 
359  size[0] =
360  size[1] =
361  size[2] =
362  size[3] =
363  size[4] = 1 << 24;
364  do {
365  b = blks;
366  for (i = 0; i < 5; i++) {
367  if (!qnos[i])
368  continue;
369 
370  qnos[i]--;
371  size[i] = 0;
372  for (j = 0; j < 6; j++, b++) {
373  for (a = 0; a < 4; a++) {
374  if (b->area_q[a] != ff_dv_quant_shifts[qnos[i] + ff_dv_quant_offset[b->cno]][a]) {
375  b->bit_size[a] = 1; // 4 areas 4 bits for EOB :)
376  b->area_q[a]++;
377  prev = b->prev[a];
378  av_assert2(b->next[prev] >= mb_area_start[a + 1] || b->mb[prev]);
379  for (k = b->next[prev]; k < mb_area_start[a + 1]; k = b->next[k]) {
380  b->mb[k] >>= 1;
381  if (b->mb[k]) {
382  b->bit_size[a] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
383  prev = k;
384  } else {
385  if (b->next[k] >= mb_area_start[a + 1] && b->next[k] < 64) {
386  for (a2 = a + 1; b->next[k] >= mb_area_start[a2 + 1]; a2++)
387  b->prev[a2] = prev;
388  av_assert2(a2 < 4);
389  av_assert2(b->mb[b->next[k]]);
390  b->bit_size[a2] += dv_rl2vlc_size(b->next[k] - prev - 1, b->mb[b->next[k]]) -
391  dv_rl2vlc_size(b->next[k] - k - 1, b->mb[b->next[k]]);
392  av_assert2(b->prev[a2] == k && (a2 + 1 >= 4 || b->prev[a2 + 1] != k));
393  b->prev[a2] = prev;
394  }
395  b->next[prev] = b->next[k];
396  }
397  }
398  b->prev[a + 1] = prev;
399  }
400  size[i] += b->bit_size[a];
401  }
402  }
403  if (vs_total_ac_bits >= size[0] + size[1] + size[2] + size[3] + size[4])
404  return;
405  }
406  } while (qnos[0] | qnos[1] | qnos[2] | qnos[3] | qnos[4]);
407 
408  for (a = 2; a == 2 || vs_total_ac_bits < size[0]; a += a) {
409  b = blks;
410  size[0] = 5 * 6 * 4; // EOB
411  for (j = 0; j < 6 * 5; j++, b++) {
412  prev = b->prev[0];
413  for (k = b->next[prev]; k < 64; k = b->next[k]) {
414  if (b->mb[k] < a && b->mb[k] > -a) {
415  b->next[prev] = b->next[k];
416  } else {
417  size[0] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
418  prev = k;
419  }
420  }
421  }
422  }
423 }
424 
425 static int dv_encode_video_segment(AVCodecContext *avctx, void *arg)
426 {
427  DVVideoContext *s = avctx->priv_data;
428  DVwork_chunk *work_chunk = arg;
429  int mb_index, i, j;
430  int mb_x, mb_y, c_offset;
431  ptrdiff_t linesize, y_stride;
432  uint8_t *y_ptr;
433  uint8_t *dif;
434  LOCAL_ALIGNED_8(uint8_t, scratch, [128]);
435  EncBlockInfo enc_blks[5 * DV_MAX_BPM];
436  PutBitContext pbs[5 * DV_MAX_BPM];
437  PutBitContext *pb;
438  EncBlockInfo *enc_blk;
439  int vs_bit_size = 0;
440  int qnos[5] = { 15, 15, 15, 15, 15 }; /* No quantization */
441  int *qnosp = &qnos[0];
442 
443  dif = &s->buf[work_chunk->buf_offset * 80];
444  enc_blk = &enc_blks[0];
445  for (mb_index = 0; mb_index < 5; mb_index++) {
446  dv_calculate_mb_xy(s, work_chunk, mb_index, &mb_x, &mb_y);
447 
448  /* initializing luminance blocks */
449  if ((s->sys->pix_fmt == AV_PIX_FMT_YUV420P) ||
450  (s->sys->pix_fmt == AV_PIX_FMT_YUV411P && mb_x >= (704 / 8)) ||
451  (s->sys->height >= 720 && mb_y != 134)) {
452  y_stride = s->frame->linesize[0] << 3;
453  } else {
454  y_stride = 16;
455  }
456  y_ptr = s->frame->data[0] +
457  ((mb_y * s->frame->linesize[0] + mb_x) << 3);
458  linesize = s->frame->linesize[0];
459 
460  if (s->sys->video_stype == 4) { /* SD 422 */
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, NULL, linesize, s, 0) +
464  dv_init_enc_block(enc_blk + 2, y_ptr + 8, linesize, s, 0) +
465  dv_init_enc_block(enc_blk + 3, NULL, linesize, s, 0);
466  } else {
467  vs_bit_size +=
468  dv_init_enc_block(enc_blk + 0, y_ptr, linesize, s, 0) +
469  dv_init_enc_block(enc_blk + 1, y_ptr + 8, linesize, s, 0) +
470  dv_init_enc_block(enc_blk + 2, y_ptr + y_stride, linesize, s, 0) +
471  dv_init_enc_block(enc_blk + 3, y_ptr + 8 + y_stride, linesize, s, 0);
472  }
473  enc_blk += 4;
474 
475  /* initializing chrominance blocks */
476  c_offset = (((mb_y >> (s->sys->pix_fmt == AV_PIX_FMT_YUV420P)) * s->frame->linesize[1] +
477  (mb_x >> ((s->sys->pix_fmt == AV_PIX_FMT_YUV411P) ? 2 : 1))) << 3);
478  for (j = 2; j; j--) {
479  uint8_t *c_ptr = s->frame->data[j] + c_offset;
480  linesize = s->frame->linesize[j];
481  y_stride = (mb_y == 134) ? 8 : (s->frame->linesize[j] << 3);
482  if (s->sys->pix_fmt == AV_PIX_FMT_YUV411P && mb_x >= (704 / 8)) {
483  uint8_t *d;
484  uint8_t *b = scratch;
485  for (i = 0; i < 8; i++) {
486  d = c_ptr + (linesize << 3);
487  b[0] = c_ptr[0];
488  b[1] = c_ptr[1];
489  b[2] = c_ptr[2];
490  b[3] = c_ptr[3];
491  b[4] = d[0];
492  b[5] = d[1];
493  b[6] = d[2];
494  b[7] = d[3];
495  c_ptr += linesize;
496  b += 16;
497  }
498  c_ptr = scratch;
499  linesize = 16;
500  }
501 
502  vs_bit_size += dv_init_enc_block(enc_blk++, c_ptr, linesize, s, 1);
503  if (s->sys->bpm == 8)
504  vs_bit_size += dv_init_enc_block(enc_blk++, c_ptr + y_stride,
505  linesize, s, 1);
506  }
507  }
508 
509  if (vs_total_ac_bits < vs_bit_size)
510  dv_guess_qnos(&enc_blks[0], qnosp);
511 
512  /* DIF encoding process */
513  for (j = 0; j < 5 * s->sys->bpm;) {
514  int start_mb = j;
515 
516  dif[3] = *qnosp++;
517  dif += 4;
518 
519  /* First pass over individual cells only */
520  for (i = 0; i < s->sys->bpm; i++, j++) {
521  int sz = s->sys->block_sizes[i] >> 3;
522 
523  init_put_bits(&pbs[j], dif, sz);
524  put_sbits(&pbs[j], 9, ((enc_blks[j].mb[0] >> 3) - 1024 + 2) >> 2);
525  put_bits(&pbs[j], 1, enc_blks[j].dct_mode);
526  put_bits(&pbs[j], 2, enc_blks[j].cno);
527 
528  dv_encode_ac(&enc_blks[j], &pbs[j], &pbs[j + 1]);
529  dif += sz;
530  }
531 
532  /* Second pass over each MB space */
533  pb = &pbs[start_mb];
534  for (i = 0; i < s->sys->bpm; i++)
535  if (enc_blks[start_mb + i].partial_bit_count)
536  pb = dv_encode_ac(&enc_blks[start_mb + i], pb,
537  &pbs[start_mb + s->sys->bpm]);
538  }
539 
540  /* Third and final pass over the whole video segment space */
541  pb = &pbs[0];
542  for (j = 0; j < 5 * s->sys->bpm; j++) {
543  if (enc_blks[j].partial_bit_count)
544  pb = dv_encode_ac(&enc_blks[j], pb, &pbs[s->sys->bpm * 5]);
545  if (enc_blks[j].partial_bit_count)
546  av_log(avctx, AV_LOG_ERROR, "ac bitstream overflow\n");
547  }
548 
549  for (j = 0; j < 5 * s->sys->bpm; j++) {
550  int pos;
551  int size = pbs[j].size_in_bits >> 3;
552  flush_put_bits(&pbs[j]);
553  pos = put_bits_count(&pbs[j]) >> 3;
554  if (pos > size) {
555  av_log(avctx, AV_LOG_ERROR,
556  "bitstream written beyond buffer size\n");
557  return -1;
558  }
559  memset(pbs[j].buf + pos, 0xff, size - pos);
560  }
561 
562  return 0;
563 }
564 
565 static inline int dv_write_pack(enum dv_pack_type pack_id, DVVideoContext *c,
566  uint8_t *buf)
567 {
568  /*
569  * Here's what SMPTE314M says about these two:
570  * (page 6) APTn, AP1n, AP2n, AP3n: These data shall be identical
571  * as track application IDs (APTn = 001, AP1n =
572  * 001, AP2n = 001, AP3n = 001), if the source signal
573  * comes from a digital VCR. If the signal source is
574  * unknown, all bits for these data shall be set to 1.
575  * (page 12) STYPE: STYPE defines a signal type of video signal
576  * 00000b = 4:1:1 compression
577  * 00100b = 4:2:2 compression
578  * XXXXXX = Reserved
579  * Now, I've got two problems with these statements:
580  * 1. it looks like APT == 111b should be a safe bet, but it isn't.
581  * It seems that for PAL as defined in IEC 61834 we have to set
582  * APT to 000 and for SMPTE314M to 001.
583  * 2. It is not at all clear what STYPE is used for 4:2:0 PAL
584  * compression scheme (if any).
585  */
586  int apt = (c->sys->pix_fmt == AV_PIX_FMT_YUV420P ? 0 : 1);
587  int fs = c->frame->top_field_first ? 0x00 : 0x40;
588 
589  uint8_t aspect = 0;
590  if ((int) (av_q2d(c->avctx->sample_aspect_ratio) *
591  c->avctx->width / c->avctx->height * 10) >= 17) /* 16:9 */
592  aspect = 0x02;
593 
594  buf[0] = (uint8_t) pack_id;
595  switch (pack_id) {
596  case dv_header525: /* I can't imagine why these two weren't defined as real */
597  case dv_header625: /* packs in SMPTE314M -- they definitely look like ones */
598  buf[1] = 0xf8 | /* reserved -- always 1 */
599  (apt & 0x07); /* APT: Track application ID */
600  buf[2] = (0 << 7) | /* TF1: audio data is 0 - valid; 1 - invalid */
601  (0x0f << 3) | /* reserved -- always 1 */
602  (apt & 0x07); /* AP1: Audio application ID */
603  buf[3] = (0 << 7) | /* TF2: video data is 0 - valid; 1 - invalid */
604  (0x0f << 3) | /* reserved -- always 1 */
605  (apt & 0x07); /* AP2: Video application ID */
606  buf[4] = (0 << 7) | /* TF3: subcode(SSYB) is 0 - valid; 1 - invalid */
607  (0x0f << 3) | /* reserved -- always 1 */
608  (apt & 0x07); /* AP3: Subcode application ID */
609  break;
610  case dv_video_source:
611  buf[1] = 0xff; /* reserved -- always 1 */
612  buf[2] = (1 << 7) | /* B/W: 0 - b/w, 1 - color */
613  (1 << 6) | /* following CLF is valid - 0, invalid - 1 */
614  (3 << 4) | /* CLF: color frames ID (see ITU-R BT.470-4) */
615  0xf; /* reserved -- always 1 */
616  buf[3] = (3 << 6) | /* reserved -- always 1 */
617  (c->sys->dsf << 5) | /* system: 60fields/50fields */
618  c->sys->video_stype; /* signal type video compression */
619  buf[4] = 0xff; /* VISC: 0xff -- no information */
620  break;
621  case dv_video_control:
622  buf[1] = (0 << 6) | /* Copy generation management (CGMS) 0 -- free */
623  0x3f; /* reserved -- always 1 */
624  buf[2] = 0xc8 | /* reserved -- always b11001xxx */
625  aspect;
626  buf[3] = (1 << 7) | /* frame/field flag 1 -- frame, 0 -- field */
627  fs | /* first/second field flag 0 -- field 2, 1 -- field 1 */
628  (1 << 5) | /* frame change flag 0 -- same picture as before, 1 -- different */
629  (1 << 4) | /* 1 - interlaced, 0 - noninterlaced */
630  0xc; /* reserved -- always b1100 */
631  buf[4] = 0xff; /* reserved -- always 1 */
632  break;
633  default:
634  buf[1] =
635  buf[2] =
636  buf[3] =
637  buf[4] = 0xff;
638  }
639  return 5;
640 }
641 
642 static inline int dv_write_dif_id(enum dv_section_type t, uint8_t chan_num,
643  uint8_t seq_num, uint8_t dif_num,
644  uint8_t *buf)
645 {
646  buf[0] = (uint8_t) t; /* Section type */
647  buf[1] = (seq_num << 4) | /* DIF seq number 0-9 for 525/60; 0-11 for 625/50 */
648  (chan_num << 3) | /* FSC: for 50Mb/s 0 - first channel; 1 - second */
649  7; /* reserved -- always 1 */
650  buf[2] = dif_num; /* DIF block number Video: 0-134, Audio: 0-8 */
651  return 3;
652 }
653 
654 static inline int dv_write_ssyb_id(uint8_t syb_num, uint8_t fr, uint8_t *buf)
655 {
656  if (syb_num == 0 || syb_num == 6) {
657  buf[0] = (fr << 7) | /* FR ID 1 - first half of each channel; 0 - second */
658  (0 << 4) | /* AP3 (Subcode application ID) */
659  0x0f; /* reserved -- always 1 */
660  } else if (syb_num == 11) {
661  buf[0] = (fr << 7) | /* FR ID 1 - first half of each channel; 0 - second */
662  0x7f; /* reserved -- always 1 */
663  } else {
664  buf[0] = (fr << 7) | /* FR ID 1 - first half of each channel; 0 - second */
665  (0 << 4) | /* APT (Track application ID) */
666  0x0f; /* reserved -- always 1 */
667  }
668  buf[1] = 0xf0 | /* reserved -- always 1 */
669  (syb_num & 0x0f); /* SSYB number 0 - 11 */
670  buf[2] = 0xff; /* reserved -- always 1 */
671  return 3;
672 }
673 
675 {
676  int chan, i, j, k;
677 
678  for (chan = 0; chan < c->sys->n_difchan; chan++) {
679  for (i = 0; i < c->sys->difseg_size; i++) {
680  memset(buf, 0xff, 80 * 6); /* first 6 DIF blocks are for control data */
681 
682  /* DV header: 1DIF */
683  buf += dv_write_dif_id(dv_sect_header, chan, i, 0, buf);
684  buf += dv_write_pack((c->sys->dsf ? dv_header625 : dv_header525),
685  c, buf);
686  buf += 72; /* unused bytes */
687 
688  /* DV subcode: 2DIFs */
689  for (j = 0; j < 2; j++) {
690  buf += dv_write_dif_id(dv_sect_subcode, chan, i, j, buf);
691  for (k = 0; k < 6; k++)
692  buf += dv_write_ssyb_id(k, (i < c->sys->difseg_size / 2), buf) + 5;
693  buf += 29; /* unused bytes */
694  }
695 
696  /* DV VAUX: 3DIFS */
697  for (j = 0; j < 3; j++) {
698  buf += dv_write_dif_id(dv_sect_vaux, chan, i, j, buf);
699  buf += dv_write_pack(dv_video_source, c, buf);
700  buf += dv_write_pack(dv_video_control, c, buf);
701  buf += 7 * 5;
702  buf += dv_write_pack(dv_video_source, c, buf);
703  buf += dv_write_pack(dv_video_control, c, buf);
704  buf += 4 * 5 + 2; /* unused bytes */
705  }
706 
707  /* DV Audio/Video: 135 Video DIFs + 9 Audio DIFs */
708  for (j = 0; j < 135; j++) {
709  if (j % 15 == 0) {
710  memset(buf, 0xff, 80);
711  buf += dv_write_dif_id(dv_sect_audio, chan, i, j / 15, buf);
712  buf += 77; /* audio control & shuffled PCM audio */
713  }
714  buf += dv_write_dif_id(dv_sect_video, chan, i, j, buf);
715  buf += 77; /* 1 video macroblock: 1 bytes control
716  * 4 * 14 bytes Y 8x8 data
717  * 10 bytes Cr 8x8 data
718  * 10 bytes Cb 8x8 data */
719  }
720  }
721  }
722 }
723 
725  const AVFrame *frame, int *got_packet)
726 {
727  DVVideoContext *s = c->priv_data;
728  int ret;
729 
730  if ((ret = ff_alloc_packet2(c, pkt, s->sys->frame_size, 0)) < 0)
731  return ret;
732 
733  c->pix_fmt = s->sys->pix_fmt;
734  s->frame = frame;
735 #if FF_API_CODED_FRAME
737  c->coded_frame->key_frame = 1;
740 #endif
741 
742  s->buf = pkt->data;
744  dv_work_pool_size(s->sys), sizeof(DVwork_chunk));
745 
746  emms_c();
747 
748  dv_format_frame(s, pkt->data);
749 
750  pkt->flags |= AV_PKT_FLAG_KEY;
751  *got_packet = 1;
752 
753  return 0;
754 }
755 
756 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
757 #define OFFSET(x) offsetof(DVVideoContext, x)
758 static const AVOption dv_options[] = {
759  { "quant_deadzone", "Quantizer dead zone", OFFSET(quant_deadzone), AV_OPT_TYPE_INT, { .i64 = 7 }, 0, 1024, VE },
760  { NULL },
761 };
762 
764  .class_name = "dvvideo encoder",
765  .item_name = av_default_item_name,
766  .option = dv_options,
767  .version = LIBAVUTIL_VERSION_INT,
768 };
769 
771  .name = "dvvideo",
772  .long_name = NULL_IF_CONFIG_SMALL("DV (Digital Video)"),
773  .type = AVMEDIA_TYPE_VIDEO,
774  .id = AV_CODEC_ID_DVVIDEO,
775  .priv_data_size = sizeof(DVVideoContext),
777  .encode2 = dvvideo_encode_frame,
779  .pix_fmts = (const enum AVPixelFormat[]) {
782  },
783  .priv_class = &dvvideo_encode_class,
784 };
av_cold void ff_me_cmp_init(MECmpContext *c, AVCodecContext *avctx)
Definition: me_cmp.c:1009
#define NULL
Definition: coverity.c:32
const char * s
Definition: avisynth_c.h:768
This structure describes decoded (raw) audio or video data.
Definition: frame.h:201
AVOption.
Definition: opt.h:246
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:101
#define AV_CODEC_FLAG_INTERLACED_DCT
Use interlaced DCT.
Definition: avcodec.h:871
static av_always_inline int dv_init_enc_block(EncBlockInfo *bi, uint8_t *data, ptrdiff_t linesize, DVVideoContext *s, int bias)
Definition: dvenc.c:246
static const AVOption dv_options[]
Definition: dvenc.c:758
static void put_sbits(PutBitContext *pb, int n, int32_t value)
Definition: put_bits.h:240
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
Definition: j2kenc.c:207
const uint8_t * block_sizes
Definition: dv_profile.h:52
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
static int dv_write_ssyb_id(uint8_t syb_num, uint8_t fr, uint8_t *buf)
Definition: dvenc.c:654
const char * b
Definition: vf_curves.c:113
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:193
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown) That is the width of a pixel divided by the height of the pixel...
Definition: avcodec.h:1866
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1697
me_cmp_func ildct_cmp
Definition: dv.h:52
int quant_deadzone
Definition: dv.h:56
int ildct_cmp
interlaced DCT comparison function
Definition: avcodec.h:1891
uint8_t run
Definition: svq3.c:206
static AVPacket pkt
const uint8_t ff_dv_quant_offset[4]
Definition: dvdata.c:70
av_cold void ff_fdctdsp_init(FDCTDSPContext *c, AVCodecContext *avctx)
Definition: fdctdsp.c:26
#define blk(i)
Definition: sha.c:185
AVCodec.
Definition: avcodec.h:3351
Macro definitions for various function/variable attributes.
#define AV_CODEC_CAP_INTRA_ONLY
Codec is intra only.
Definition: avcodec.h:1042
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...
Definition: avcodec.h:1610
uint8_t * buf
Definition: dv.h:45
static av_always_inline int dv_guess_dct_mode(DVVideoContext *s, uint8_t *data, ptrdiff_t linesize)
Definition: dvenc.c:209
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:72
void ff_dv_print_profiles(void *logctx, int loglevel)
Print all allowed DV profiles into logctx at specified logging level.
int ff_alloc_packet2(AVCodecContext *avctx, AVPacket *avpkt, int64_t size, int64_t min_size)
Check AVPacket size and/or allocate data.
Definition: encode.c:32
AVCodecContext * avctx
Definition: dv.h:44
#define VE
Definition: dvenc.c:756
dv_pack_type
Definition: dv.h:67
uint8_t
#define av_cold
Definition: attributes.h:82
#define mb
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
Definition: avassert.h:64
AVOptions.
const uint8_t ff_dv_zigzag248_direct[64]
Definition: dvdata.c:33
static av_cold void dv_vlc_map_tableinit(void)
Definition: dv_tablegen.h:51
static AVFrame * frame
int difseg_size
Definition: dv_profile.h:43
uint8_t * data
Definition: avcodec.h:1400
static double av_q2d(AVRational a)
Convert an AVRational to a double.
Definition: rational.h:104
enum AVPixelFormat pix_fmt
Definition: dv_profile.h:50
ptrdiff_t size
Definition: opengl_enc.c:101
static int dv_encode_video_segment(AVCodecContext *avctx, void *arg)
Definition: dvenc.c:425
static const int dv_weight_bits
Definition: dvenc.c:224
#define av_log(a,...)
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: avcodec.h:1432
#define LOCAL_ALIGNED_8(t, v,...)
Definition: internal.h:125
static const int dv_weight_88[64]
Definition: dvenc.c:225
DVwork_chunk work_chunks[4 *12 *27]
Definition: dv.h:53
int size_in_bits
Definition: put_bits.h:39
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
AVCodec ff_dvvideo_encoder
Definition: dvenc.c:770
uint8_t partial_bit_count
Definition: dvenc.c:159
static int put_bits_left(PutBitContext *s)
Definition: put_bits.h:93
#define AVERROR(e)
Definition: error.h:43
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:186
static int dv_work_pool_size(const AVDVProfile *d)
Definition: dv.h:104
void(* get_pixels)(int16_t *av_restrict block, const uint8_t *pixels, ptrdiff_t stride)
Definition: pixblockdsp.h:29
int frame_size
Definition: dv_profile.h:42
const AVFrame * frame
Definition: dv.h:43
const char * arg
Definition: jacosubdec.c:66
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:1568
uint32_t partial_bit_buffer
Definition: dvenc.c:160
int cno
Definition: dvenc.c:154
const char * name
Name of the codec implementation.
Definition: avcodec.h:3358
av_cold void ff_pixblockdsp_init(PixblockDSPContext *c, AVCodecContext *avctx)
Definition: pixblockdsp.c:81
int dct_mode
Definition: dvenc.c:155
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
Definition: avcodec.h:1012
int flags
A combination of AV_PKT_FLAG values.
Definition: avcodec.h:1406
static int put_bits_count(PutBitContext *s)
Definition: put_bits.h:85
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
Definition: pixfmt.h:66
common internal API header
static const int vs_total_ac_bits
Definition: dvenc.c:93
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:284
static int dv_write_pack(enum dv_pack_type pack_id, DVVideoContext *c, uint8_t *buf)
Definition: dvenc.c:565
int cur_ac
Definition: dvenc.c:153
uint32_t vlc
Definition: dv_tablegen.h:41
#define DV_VLC_MAP_RUN_SIZE
Definition: dv_tablegen.h:35
#define DV_MAX_BPM
maximum number of blocks per macroblock in any DV format
Definition: dv.h:94
int width
picture width / height.
Definition: avcodec.h:1660
uint8_t sign[64]
Definition: dvenc.c:158
#define a2
Definition: regdef.h:48
static av_always_inline int dv_rl2vlc(int run, int l, int sign, uint32_t *vlc)
Definition: dvenc.c:137
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:72
void(* get_pixels)(int16_t *block, const uint8_t *pixels, ptrdiff_t linesize)
Definition: dv.h:49
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
#define AV_CODEC_CAP_SLICE_THREADS
Codec supports slice-based (or partition-based) multithreading.
Definition: avcodec.h:1016
int prev[5]
Definition: dvenc.c:152
static const int mb_area_start[5]
Definition: dvenc.c:94
void(* fdct[2])(int16_t *block)
Definition: dv.h:50
static void dv_guess_qnos(EncBlockInfo *blks, int *qnos)
Definition: dvenc.c:353
Libavcodec external API header.
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:232
int bit_size[4]
Definition: dvenc.c:151
void ff_set_cmp(MECmpContext *c, me_cmp_func *cmp, int type)
Definition: me_cmp.c:440
void(* fdct)(int16_t *block)
Definition: fdctdsp.h:27
main external API structure.
Definition: avcodec.h:1488
#define DV_VLC_MAP_LEV_SIZE
Definition: dv_tablegen.h:36
int16_t mb[64]
Definition: dvenc.c:156
void * buf
Definition: avisynth_c.h:690
Describe the class of an AVClass context structure.
Definition: log.h:67
static void dv_format_frame(DVVideoContext *c, uint8_t *buf)
Definition: dvenc.c:674
#define OFFSET(x)
Definition: dvenc.c:757
av_cold int ff_dvvideo_init(AVCodecContext *avctx)
Definition: dv.c:198
const uint8_t ff_zigzag_direct[64]
Definition: mathtables.c:98
int video_stype
Definition: dv_profile.h:41
uint32_t size
Definition: dv_tablegen.h:42
static int weight(int i, int blen, int offset)
Definition: diracdec.c:1523
static av_cold int dvvideo_encode_init(AVCodecContext *avctx)
Definition: dvenc.c:47
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:266
static int dvvideo_encode_frame(AVCodecContext *c, AVPacket *pkt, const AVFrame *frame, int *got_packet)
Definition: dvenc.c:724
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:215
uint8_t level
Definition: svq3.c:207
static av_always_inline PutBitContext * dv_encode_ac(EncBlockInfo *bi, PutBitContext *pb_pool, PutBitContext *pb_end)
Definition: dvenc.c:163
dv_section_type
Definition: dv.h:59
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:62
const uint8_t ff_dv_quant_shifts[22][4]
Definition: dvdata.c:45
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:84
common internal api header.
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
Definition: put_bits.h:101
static double c[64]
attribute_deprecated AVFrame * coded_frame
the picture in the bitstream
Definition: avcodec.h:2730
planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples)
Definition: pixfmt.h:69
static int dv_write_dif_id(enum dv_section_type t, uint8_t chan_num, uint8_t seq_num, uint8_t dif_num, uint8_t *buf)
Definition: dvenc.c:642
Constants for DV codec.
static void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)
Initialize the PutBitContext s.
Definition: put_bits.h:48
void(* fdct248)(int16_t *block)
Definition: fdctdsp.h:28
int ff_dv_init_dynamic_tables(DVVideoContext *ctx, const AVDVProfile *d)
Definition: dv.c:175
const AVDVProfile * av_dv_codec_profile2(int width, int height, enum AVPixelFormat pix_fmt, AVRational frame_rate)
Get a DV profile for the provided stream parameters.
Definition: dv_profile.c:316
uint16_t buf_offset
Definition: dv.h:36
void * priv_data
Definition: avcodec.h:1515
int(* execute)(struct AVCodecContext *c, int(*func)(struct AVCodecContext *c2, void *arg), void *arg2, int *ret, int count, int size)
The codec may call this to execute several independent things.
Definition: avcodec.h:2779
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:85
int top_field_first
If the content is interlaced, is top field displayed first.
Definition: frame.h:353
static void dv_calculate_mb_xy(DVVideoContext *s, DVwork_chunk *work_chunk, int m, int *mb_x, int *mb_y)
Definition: dv.h:114
int area_q[4]
Definition: dvenc.c:150
static const int dv_weight_248[64]
Definition: dvenc.c:235
const AVDVProfile * sys
Definition: dv.h:42
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:279
static const AVClass dvvideo_encode_class
Definition: dvenc.c:763
#define LOCAL_ALIGNED_16(t, v,...)
Definition: internal.h:131
#define av_always_inline
Definition: attributes.h:39
int n_difchan
Definition: dv_profile.h:44
const char * av_get_pix_fmt_name(enum AVPixelFormat pix_fmt)
Return the short name for a pixel format, NULL in case pix_fmt is unknown.
Definition: pixdesc.c:2279
static struct dv_vlc_pair dv_vlc_map[DV_VLC_MAP_RUN_SIZE][DV_VLC_MAP_LEV_SIZE]
Definition: dv_tablegen.h:49
static av_always_inline int dv_rl2vlc_size(int run, int l)
Definition: dvenc.c:143
AVPixelFormat
Pixel format.
Definition: pixfmt.h:60
This structure stores compressed data.
Definition: avcodec.h:1377
uint8_t next[64]
Definition: dvenc.c:157
me_cmp_func ildct_cmp[6]
Definition: me_cmp.h:75
bitstream writer API