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