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