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