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