FFmpeg
dvenc.c
Go to the documentation of this file.
1 /*
2  * DV encoder
3  * Copyright (c) 2003 Roman Shaposhnik
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  *
21  * quant_deadzone code and fixes sponsored by NOA GmbH
22  */
23 
24 /**
25  * @file
26  * DV encoder
27  */
28 
29 #include "config.h"
30 
31 #include "libavutil/attributes.h"
32 #include "libavutil/internal.h"
33 #include "libavutil/mem_internal.h"
34 #include "libavutil/opt.h"
35 #include "libavutil/pixdesc.h"
36 #include "libavutil/thread.h"
37 
38 #include "avcodec.h"
39 #include "codec_internal.h"
40 #include "dv.h"
41 #include "dv_internal.h"
42 #include "dv_profile_internal.h"
43 #include "dv_tablegen.h"
44 #include "encode.h"
45 #include "fdctdsp.h"
46 #include "mathops.h"
47 #include "me_cmp.h"
48 #include "pixblockdsp.h"
49 #include "put_bits.h"
50 
51 typedef struct DVEncContext {
52  const AVClass *class;
53  const AVDVProfile *sys;
54  const AVFrame *frame;
56  uint8_t *buf;
57 
58  void (*get_pixels)(int16_t *block, const uint8_t *pixels, ptrdiff_t linesize);
59  void (*fdct[2])(int16_t *block);
60 
62  DVwork_chunk work_chunks[4 * 12 * 27];
63 
65 } DVEncContext;
66 
67 
69 {
70  DVEncContext *s = avctx->priv_data;
71  FDCTDSPContext fdsp;
72  MECmpContext mecc;
73  PixblockDSPContext pdsp;
74  int ret;
75 
76  s->avctx = avctx;
77 
80  av_log(avctx, AV_LOG_WARNING, "Only top-left chroma location is supported "
81  "in DV, input value is: %s\n", name ? name : "unknown");
83  return AVERROR(EINVAL);
84  }
85 
86  s->sys = av_dv_codec_profile2(avctx->width, avctx->height, avctx->pix_fmt, avctx->time_base);
87  if (!s->sys) {
88  av_log(avctx, AV_LOG_ERROR, "Found no DV profile for %ix%i %s video. "
89  "Valid DV profiles are:\n",
90  avctx->width, avctx->height, av_get_pix_fmt_name(avctx->pix_fmt));
92  return AVERROR(EINVAL);
93  }
94 
95  ret = ff_dv_init_dynamic_tables(s->work_chunks, s->sys);
96  if (ret < 0) {
97  av_log(avctx, AV_LOG_ERROR, "Error initializing work tables.\n");
98  return ret;
99  }
100 
101  memset(&fdsp,0, sizeof(fdsp));
102  memset(&mecc,0, sizeof(mecc));
103  memset(&pdsp,0, sizeof(pdsp));
104  ff_fdctdsp_init(&fdsp, avctx);
105  ff_me_cmp_init(&mecc, avctx);
106  ff_pixblockdsp_init(&pdsp, avctx);
107  ret = ff_set_cmp(&mecc, mecc.ildct_cmp, avctx->ildct_cmp);
108  if (ret < 0)
109  return AVERROR(EINVAL);
110 
111  s->get_pixels = pdsp.get_pixels;
112  s->ildct_cmp = mecc.ildct_cmp[5];
113 
114  s->fdct[0] = fdsp.fdct;
115  s->fdct[1] = fdsp.fdct248;
116 
117 #if !CONFIG_HARDCODED_TABLES
118  {
119  static AVOnce init_static_once = AV_ONCE_INIT;
120  ff_thread_once(&init_static_once, dv_vlc_map_tableinit);
121  }
122 #endif
123 
124  return 0;
125 }
126 
127 /* bit budget for AC only in 5 MBs */
128 static const int vs_total_ac_bits_hd = (68 * 6 + 52*2) * 5;
129 static const int vs_total_ac_bits = (100 * 4 + 68 * 2) * 5;
130 static const int mb_area_start[5] = { 1, 6, 21, 43, 64 };
131 
132 #if CONFIG_SMALL
133 /* Convert run and level (where level != 0) pair into VLC, returning bit size */
134 static av_always_inline int dv_rl2vlc(int run, int level, int sign,
135  uint32_t *vlc)
136 {
137  int size;
139  *vlc = dv_vlc_map[run][level].vlc | sign;
141  } else {
142  if (level < DV_VLC_MAP_LEV_SIZE) {
143  *vlc = dv_vlc_map[0][level].vlc | sign;
144  size = dv_vlc_map[0][level].size;
145  } else {
146  *vlc = 0xfe00 | (level << 1) | sign;
147  size = 16;
148  }
149  if (run) {
150  *vlc |= ((run < 16) ? dv_vlc_map[run - 1][0].vlc :
151  (0x1f80 | (run - 1))) << size;
152  size += (run < 16) ? dv_vlc_map[run - 1][0].size : 13;
153  }
154  }
155 
156  return size;
157 }
158 
159 static av_always_inline int dv_rl2vlc_size(int run, int level)
160 {
161  int size;
162 
165  } else {
167  if (run)
168  size += (run < 16) ? dv_vlc_map[run - 1][0].size : 13;
169  }
170  return size;
171 }
172 #else
173 static av_always_inline int dv_rl2vlc(int run, int l, int sign, uint32_t *vlc)
174 {
175  *vlc = dv_vlc_map[run][l].vlc | sign;
176  return dv_vlc_map[run][l].size;
177 }
178 
179 static av_always_inline int dv_rl2vlc_size(int run, int l)
180 {
181  return dv_vlc_map[run][l].size;
182 }
183 #endif
184 
185 typedef struct EncBlockInfo {
186  int area_q[4];
187  int bit_size[4];
188  int prev[5];
189  int cur_ac;
190  int cno;
191  int dct_mode;
192  int16_t mb[64];
193  uint8_t next[64];
194  uint8_t sign[64];
196  uint32_t partial_bit_buffer; /* we can't use uint16_t here */
197  /* used by DV100 only: a copy of the weighted and classified but
198  not-yet-quantized AC coefficients. This is necessary for
199  re-quantizing at different steps. */
200  int16_t save[64];
201  int min_qlevel; /* DV100 only: minimum qlevel (for AC coefficients >255) */
202 } EncBlockInfo;
203 
205  PutBitContext *pb_pool,
206  PutBitContext *pb_end)
207 {
208  int prev, bits_left;
209  PutBitContext *pb = pb_pool;
210  int size = bi->partial_bit_count;
211  uint32_t vlc = bi->partial_bit_buffer;
212 
213  bi->partial_bit_count =
214  bi->partial_bit_buffer = 0;
215  for (;;) {
216  /* Find suitable storage space */
217  for (; size > (bits_left = put_bits_left(pb)); pb++) {
218  if (bits_left) {
219  size -= bits_left;
220  put_bits(pb, bits_left, vlc >> size);
221  vlc = av_mod_uintp2(vlc, size);
222  }
223  if (pb + 1 >= pb_end) {
224  bi->partial_bit_count = size;
225  bi->partial_bit_buffer = vlc;
226  return pb;
227  }
228  }
229 
230  /* Store VLC */
231  put_bits(pb, size, vlc);
232 
233  if (bi->cur_ac >= 64)
234  break;
235 
236  /* Construct the next VLC */
237  prev = bi->cur_ac;
238  bi->cur_ac = bi->next[prev];
239  if (bi->cur_ac < 64) {
240  size = dv_rl2vlc(bi->cur_ac - prev - 1, bi->mb[bi->cur_ac],
241  bi->sign[bi->cur_ac], &vlc);
242  } else {
243  size = 4;
244  vlc = 6; /* End Of Block stamp */
245  }
246  }
247  return pb;
248 }
249 
251  ptrdiff_t linesize)
252 {
253  if (s->avctx->flags & AV_CODEC_FLAG_INTERLACED_DCT) {
254  int ps = s->ildct_cmp(NULL, data, NULL, linesize, 8) - 400;
255  if (ps > 0) {
256  int is = s->ildct_cmp(NULL, data, NULL, linesize * 2, 4) +
257  s->ildct_cmp(NULL, data + linesize, NULL, linesize * 2, 4);
258  return ps > is;
259  }
260  }
261 
262  return 0;
263 }
264 
265 static const int dv_weight_bits = 18;
266 static const int dv_weight_88[64] = {
267  131072, 257107, 257107, 242189, 252167, 242189, 235923, 237536,
268  237536, 235923, 229376, 231390, 223754, 231390, 229376, 222935,
269  224969, 217965, 217965, 224969, 222935, 200636, 218652, 211916,
270  212325, 211916, 218652, 200636, 188995, 196781, 205965, 206433,
271  206433, 205965, 196781, 188995, 185364, 185364, 200636, 200704,
272  200636, 185364, 185364, 174609, 180568, 195068, 195068, 180568,
273  174609, 170091, 175557, 189591, 175557, 170091, 165371, 170627,
274  170627, 165371, 160727, 153560, 160727, 144651, 144651, 136258,
275 };
276 static const int dv_weight_248[64] = {
277  131072, 262144, 257107, 257107, 242189, 242189, 242189, 242189,
278  237536, 237536, 229376, 229376, 200636, 200636, 224973, 224973,
279  223754, 223754, 235923, 235923, 229376, 229376, 217965, 217965,
280  211916, 211916, 196781, 196781, 185364, 185364, 206433, 206433,
281  211916, 211916, 222935, 222935, 200636, 200636, 205964, 205964,
282  200704, 200704, 180568, 180568, 175557, 175557, 195068, 195068,
283  185364, 185364, 188995, 188995, 174606, 174606, 175557, 175557,
284  170627, 170627, 153560, 153560, 165371, 165371, 144651, 144651,
285 };
286 
287 /* setting this to 1 results in a faster codec but
288  * somewhat lower image quality */
289 #define DV100_SACRIFICE_QUALITY_FOR_SPEED 1
290 #define DV100_ENABLE_FINER 1
291 
292 /* pack combination of QNO and CNO into a single 8-bit value */
293 #define DV100_MAKE_QLEVEL(qno,cno) ((qno<<2) | (cno))
294 #define DV100_QLEVEL_QNO(qlevel) (qlevel>>2)
295 #define DV100_QLEVEL_CNO(qlevel) (qlevel&0x3)
296 
297 #define DV100_NUM_QLEVELS 31
298 
299 /* The quantization step is determined by a combination of QNO and
300  CNO. We refer to these combinations as "qlevels" (this term is our
301  own, it's not mentioned in the spec). We use CNO, a multiplier on
302  the quantization step, to "fill in the gaps" between quantization
303  steps associated with successive values of QNO. e.g. there is no
304  QNO for a quantization step of 10, but we can use QNO=5 CNO=1 to
305  get the same result. The table below encodes combinations of QNO
306  and CNO in order of increasing quantization coarseness. */
307 static const uint8_t dv100_qlevels[DV100_NUM_QLEVELS] = {
308  DV100_MAKE_QLEVEL( 1,0), // 1*1= 1
309  DV100_MAKE_QLEVEL( 1,0), // 1*1= 1
310  DV100_MAKE_QLEVEL( 2,0), // 2*1= 2
311  DV100_MAKE_QLEVEL( 3,0), // 3*1= 3
312  DV100_MAKE_QLEVEL( 4,0), // 4*1= 4
313  DV100_MAKE_QLEVEL( 5,0), // 5*1= 5
314  DV100_MAKE_QLEVEL( 6,0), // 6*1= 6
315  DV100_MAKE_QLEVEL( 7,0), // 7*1= 7
316  DV100_MAKE_QLEVEL( 8,0), // 8*1= 8
317  DV100_MAKE_QLEVEL( 5,1), // 5*2=10
318  DV100_MAKE_QLEVEL( 6,1), // 6*2=12
319  DV100_MAKE_QLEVEL( 7,1), // 7*2=14
320  DV100_MAKE_QLEVEL( 9,0), // 16*1=16
321  DV100_MAKE_QLEVEL(10,0), // 18*1=18
322  DV100_MAKE_QLEVEL(11,0), // 20*1=20
323  DV100_MAKE_QLEVEL(12,0), // 22*1=22
324  DV100_MAKE_QLEVEL(13,0), // 24*1=24
325  DV100_MAKE_QLEVEL(14,0), // 28*1=28
326  DV100_MAKE_QLEVEL( 9,1), // 16*2=32
327  DV100_MAKE_QLEVEL(10,1), // 18*2=36
328  DV100_MAKE_QLEVEL(11,1), // 20*2=40
329  DV100_MAKE_QLEVEL(12,1), // 22*2=44
330  DV100_MAKE_QLEVEL(13,1), // 24*2=48
331  DV100_MAKE_QLEVEL(15,0), // 52*1=52
332  DV100_MAKE_QLEVEL(14,1), // 28*2=56
333  DV100_MAKE_QLEVEL( 9,2), // 16*4=64
334  DV100_MAKE_QLEVEL(10,2), // 18*4=72
335  DV100_MAKE_QLEVEL(11,2), // 20*4=80
336  DV100_MAKE_QLEVEL(12,2), // 22*4=88
337  DV100_MAKE_QLEVEL(13,2), // 24*4=96
338  // ...
339  DV100_MAKE_QLEVEL(15,3), // 52*8=416
340 };
341 
342 static const int dv100_min_bias = 0;
343 static const int dv100_chroma_bias = 0;
344 static const int dv100_starting_qno = 1;
345 
346 #if DV100_SACRIFICE_QUALITY_FOR_SPEED
347 static const int dv100_qlevel_inc = 4;
348 #else
349 static const int dv100_qlevel_inc = 1;
350 #endif
351 
352 // 1/qstep, shifted up by 16 bits
353 static const int dv100_qstep_bits = 16;
354 static const int dv100_qstep_inv[16] = {
355  65536, 65536, 32768, 21845, 16384, 13107, 10923, 9362, 8192, 4096, 3641, 3277, 2979, 2731, 2341, 1260,
356 };
357 
358 /* DV100 weights are pre-zigzagged, inverted and multiplied by 2^16
359  (in DV100 the AC components are divided by the spec weights) */
360 static const int dv_weight_1080[2][64] = {
361  { 8192, 65536, 65536, 61681, 61681, 61681, 58254, 58254,
362  58254, 58254, 58254, 58254, 55188, 58254, 58254, 55188,
363  55188, 55188, 55188, 55188, 55188, 24966, 27594, 26214,
364  26214, 26214, 27594, 24966, 23831, 24385, 25575, 25575,
365  25575, 25575, 24385, 23831, 23302, 23302, 24966, 24966,
366  24966, 23302, 23302, 21845, 22795, 24385, 24385, 22795,
367  21845, 21400, 21845, 23831, 21845, 21400, 10382, 10700,
368  10700, 10382, 10082, 9620, 10082, 9039, 9039, 8525, },
369  { 8192, 65536, 65536, 61681, 61681, 61681, 41943, 41943,
370  41943, 41943, 40330, 41943, 40330, 41943, 40330, 40330,
371  40330, 38836, 38836, 40330, 40330, 24966, 27594, 26214,
372  26214, 26214, 27594, 24966, 23831, 24385, 25575, 25575,
373  25575, 25575, 24385, 23831, 11523, 11523, 12483, 12483,
374  12483, 11523, 11523, 10923, 11275, 12193, 12193, 11275,
375  10923, 5323, 5490, 5924, 5490, 5323, 5165, 5323,
376  5323, 5165, 5017, 4788, 5017, 4520, 4520, 4263, }
377 };
378 
379 static const int dv_weight_720[2][64] = {
380  { 8192, 65536, 65536, 61681, 61681, 61681, 58254, 58254,
381  58254, 58254, 58254, 58254, 55188, 58254, 58254, 55188,
382  55188, 55188, 55188, 55188, 55188, 24966, 27594, 26214,
383  26214, 26214, 27594, 24966, 23831, 24385, 25575, 25575,
384  25575, 25575, 24385, 23831, 15420, 15420, 16644, 16644,
385  16644, 15420, 15420, 10923, 11398, 12193, 12193, 11398,
386  10923, 10700, 10923, 11916, 10923, 10700, 5191, 5350,
387  5350, 5191, 5041, 4810, 5041, 4520, 4520, 4263, },
388  { 8192, 43691, 43691, 40330, 40330, 40330, 29127, 29127,
389  29127, 29127, 29127, 29127, 27594, 29127, 29127, 27594,
390  27594, 27594, 27594, 27594, 27594, 12483, 13797, 13107,
391  13107, 13107, 13797, 12483, 11916, 12193, 12788, 12788,
392  12788, 12788, 12193, 11916, 5761, 5761, 6242, 6242,
393  6242, 5761, 5761, 5461, 5638, 5461, 6096, 5638,
394  5461, 2661, 2745, 2962, 2745, 2661, 2583, 2661,
395  2661, 2583, 2509, 2394, 2509, 2260, 2260, 2131, }
396 };
397 
399  int16_t *blk, EncBlockInfo *bi,
400  const uint8_t *zigzag_scan,
401  const int *weight, int bias)
402 {
403  int i, area;
404  /* We offer two different methods for class number assignment: the
405  * method suggested in SMPTE 314M Table 22, and an improved
406  * method. The SMPTE method is very conservative; it assigns class
407  * 3 (i.e. severe quantization) to any block where the largest AC
408  * component is greater than 36. FFmpeg's DV encoder tracks AC bit
409  * consumption precisely, so there is no need to bias most blocks
410  * towards strongly lossy compression. Instead, we assign class 2
411  * to most blocks, and use class 3 only when strictly necessary
412  * (for blocks whose largest AC component exceeds 255). */
413 
414 #if 0 /* SMPTE spec method */
415  static const int classes[] = { 12, 24, 36, 0xffff };
416 #else /* improved FFmpeg method */
417  static const int classes[] = { -1, -1, 255, 0xffff };
418 #endif
419  int max = classes[0];
420  int prev = 0;
421  const unsigned deadzone = s->quant_deadzone;
422  const unsigned threshold = 2 * deadzone;
423 
424  bi->mb[0] = blk[0];
425 
426  for (area = 0; area < 4; area++) {
427  bi->prev[area] = prev;
428  bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
429  for (i = mb_area_start[area]; i < mb_area_start[area + 1]; i++) {
430  int level = blk[zigzag_scan[i]];
431 
432  if (level + deadzone > threshold) {
433  bi->sign[i] = (level >> 31) & 1;
434  /* Weight it and shift down into range, adding for rounding.
435  * The extra division by a factor of 2^4 reverses the 8x
436  * expansion of the DCT AND the 2x doubling of the weights. */
437  level = (FFABS(level) * weight[i] + (1 << (dv_weight_bits + 3))) >>
438  (dv_weight_bits + 4);
439  if (!level)
440  continue;
441  bi->mb[i] = level;
442  if (level > max)
443  max = level;
444  bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, level);
445  bi->next[prev] = i;
446  prev = i;
447  }
448  }
449  }
450  bi->next[prev] = i;
451  for (bi->cno = 0; max > classes[bi->cno]; bi->cno++)
452  ;
453 
454  bi->cno += bias;
455 
456  if (bi->cno >= 3) {
457  bi->cno = 3;
458  prev = 0;
459  i = bi->next[prev];
460  for (area = 0; area < 4; area++) {
461  bi->prev[area] = prev;
462  bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
463  for (; i < mb_area_start[area + 1]; i = bi->next[i]) {
464  bi->mb[i] >>= 1;
465 
466  if (bi->mb[i]) {
467  bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, bi->mb[i]);
468  bi->next[prev] = i;
469  prev = i;
470  }
471  }
472  }
473  bi->next[prev] = i;
474  }
475 
476  return bi->bit_size[0] + bi->bit_size[1] +
477  bi->bit_size[2] + bi->bit_size[3];
478 }
479 
480 /* this function just copies the DCT coefficients and performs
481  the initial (non-)quantization. */
483  int16_t *blk, EncBlockInfo *bi,
484  const uint8_t *zigzag_scan,
485  const int *weight, int bias)
486 {
487  int i, max = 0;
488 
489  /* the first quantization (none at all) */
490  bi->area_q[0] = 1;
491 
492  /* weigh AC components and store to save[] */
493  /* (i=0 is the DC component; we only include it to make the
494  number of loop iterations even, for future possible SIMD optimization) */
495  for (i = 0; i < 64; i += 2) {
496  int level0, level1;
497 
498  /* get the AC component (in zig-zag order) */
499  level0 = blk[zigzag_scan[i+0]];
500  level1 = blk[zigzag_scan[i+1]];
501 
502  /* extract sign and make it the lowest bit */
503  bi->sign[i+0] = (level0>>31)&1;
504  bi->sign[i+1] = (level1>>31)&1;
505 
506  /* take absolute value of the level */
507  level0 = FFABS(level0);
508  level1 = FFABS(level1);
509 
510  /* weigh it */
511  level0 = (level0*weight[i+0] + 4096 + (1<<17)) >> 18;
512  level1 = (level1*weight[i+1] + 4096 + (1<<17)) >> 18;
513 
514  /* save unquantized value */
515  bi->save[i+0] = level0;
516  bi->save[i+1] = level1;
517 
518  /* find max component */
519  if (bi->save[i+0] > max)
520  max = bi->save[i+0];
521  if (bi->save[i+1] > max)
522  max = bi->save[i+1];
523  }
524 
525  /* copy DC component */
526  bi->mb[0] = blk[0];
527 
528  /* the EOB code is 4 bits */
529  bi->bit_size[0] = 4;
530  bi->bit_size[1] = bi->bit_size[2] = bi->bit_size[3] = 0;
531 
532  /* ensure that no AC coefficients are cut off */
533  bi->min_qlevel = ((max+256) >> 8);
534 
535  bi->area_q[0] = 25; /* set to an "impossible" value */
536  bi->cno = 0;
537 }
538 
539 static av_always_inline int dv_init_enc_block(EncBlockInfo* bi, const uint8_t *data, int linesize,
540  DVEncContext *s, int chroma)
541 {
542  LOCAL_ALIGNED_16(int16_t, blk, [64]);
543 
544  bi->area_q[0] = bi->area_q[1] = bi->area_q[2] = bi->area_q[3] = 0;
545  bi->partial_bit_count = 0;
546  bi->partial_bit_buffer = 0;
547  bi->cur_ac = 0;
548 
549  if (data) {
550  if (DV_PROFILE_IS_HD(s->sys)) {
551  s->get_pixels(blk, data, linesize * (1 << bi->dct_mode));
552  s->fdct[0](blk);
553  } else {
554  bi->dct_mode = dv_guess_dct_mode(s, data, linesize);
555  s->get_pixels(blk, data, linesize);
556  s->fdct[bi->dct_mode](blk);
557  }
558  } else {
559  /* We rely on the fact that encoding all zeros leads to an immediate EOB,
560  which is precisely what the spec calls for in the "dummy" blocks. */
561  memset(blk, 0, 64*sizeof(*blk));
562  bi->dct_mode = 0;
563  }
564 
565  if (DV_PROFILE_IS_HD(s->sys)) {
566  const int *weights;
567  if (s->sys->height == 1080) {
569  } else { /* 720p */
571  }
574  weights,
576  } else {
580  chroma);
581  }
582 
583  return bi->bit_size[0] + bi->bit_size[1] + bi->bit_size[2] + bi->bit_size[3];
584 }
585 
586 /* DV100 quantize
587  Perform quantization by divinding the AC component by the qstep.
588  As an optimization we use a fixed-point integer multiply instead
589  of a divide. */
590 static av_always_inline int dv100_quantize(int level, int qsinv)
591 {
592  /* this code is equivalent to */
593  /* return (level + qs/2) / qs; */
594 
595  return (level * qsinv + 1024 + (1<<(dv100_qstep_bits-1))) >> dv100_qstep_bits;
596 
597  /* the extra +1024 is needed to make the rounding come out right. */
598 
599  /* I (DJM) have verified that the results are exactly the same as
600  division for level 0-2048 at all QNOs. */
601 }
602 
603 static int dv100_actual_quantize(EncBlockInfo *b, int qlevel)
604 {
605  int prev, k, qsinv;
606 
607  int qno = DV100_QLEVEL_QNO(dv100_qlevels[qlevel]);
608  int cno = DV100_QLEVEL_CNO(dv100_qlevels[qlevel]);
609 
610  if (b->area_q[0] == qno && b->cno == cno)
611  return b->bit_size[0];
612 
613  qsinv = dv100_qstep_inv[qno];
614 
615  /* record the new qstep */
616  b->area_q[0] = qno;
617  b->cno = cno;
618 
619  /* reset encoded size (EOB = 4 bits) */
620  b->bit_size[0] = 4;
621 
622  /* visit nonzero components and quantize */
623  prev = 0;
624  for (k = 1; k < 64; k++) {
625  /* quantize */
626  int ac = dv100_quantize(b->save[k], qsinv) >> cno;
627  if (ac) {
628  if (ac > 255)
629  ac = 255;
630  b->mb[k] = ac;
631  b->bit_size[0] += dv_rl2vlc_size(k - prev - 1, ac);
632  b->next[prev] = k;
633  prev = k;
634  }
635  }
636  b->next[prev] = k;
637 
638  return b->bit_size[0];
639 }
640 
641 static inline void dv_guess_qnos_hd(EncBlockInfo *blks, int *qnos)
642 {
643  EncBlockInfo *b;
644  int min_qlevel[5];
645  int qlevels[5];
646  int size[5];
647  int i, j;
648  /* cache block sizes at hypothetical qlevels */
649  uint16_t size_cache[5*8][DV100_NUM_QLEVELS] = {{0}};
650 
651  /* get minimum qlevels */
652  for (i = 0; i < 5; i++) {
653  min_qlevel[i] = 1;
654  for (j = 0; j < 8; j++) {
655  if (blks[8*i+j].min_qlevel > min_qlevel[i])
656  min_qlevel[i] = blks[8*i+j].min_qlevel;
657  }
658  }
659 
660  /* initialize sizes */
661  for (i = 0; i < 5; i++) {
662  qlevels[i] = dv100_starting_qno;
663  if (qlevels[i] < min_qlevel[i])
664  qlevels[i] = min_qlevel[i];
665 
666  qnos[i] = DV100_QLEVEL_QNO(dv100_qlevels[qlevels[i]]);
667  size[i] = 0;
668  for (j = 0; j < 8; j++) {
669  size_cache[8*i+j][qlevels[i]] = dv100_actual_quantize(&blks[8*i+j], qlevels[i]);
670  size[i] += size_cache[8*i+j][qlevels[i]];
671  }
672  }
673 
674  /* must we go coarser? */
675  if (size[0]+size[1]+size[2]+size[3]+size[4] > vs_total_ac_bits_hd) {
676  int largest = size[0] % 5; /* 'random' number */
677  int qlevels_done = 0;
678 
679  do {
680  /* find the macroblock with the lowest qlevel */
681  for (i = 0; i < 5; i++) {
682  if (qlevels[i] < qlevels[largest])
683  largest = i;
684  }
685 
686  i = largest;
687  /* ensure that we don't enter infinite loop */
688  largest = (largest+1) % 5;
689 
690  /* quantize a little bit more */
691  qlevels[i] += dv100_qlevel_inc;
692  if (qlevels[i] > DV100_NUM_QLEVELS-1) {
693  qlevels[i] = DV100_NUM_QLEVELS-1;
694  qlevels_done++;
695  }
696 
697  qnos[i] = DV100_QLEVEL_QNO(dv100_qlevels[qlevels[i]]);
698  size[i] = 0;
699 
700  /* for each block */
701  b = &blks[8*i];
702  for (j = 0; j < 8; j++, b++) {
703  /* accumulate block size into macroblock */
704  if(size_cache[8*i+j][qlevels[i]] == 0) {
705  /* it is safe to use actual_quantize() here because we only go from finer to coarser,
706  and it saves the final actual_quantize() down below */
707  size_cache[8*i+j][qlevels[i]] = dv100_actual_quantize(b, qlevels[i]);
708  }
709  size[i] += size_cache[8*i+j][qlevels[i]];
710  } /* for each block */
711 
712  } while (vs_total_ac_bits_hd < size[0] + size[1] + size[2] + size[3] + size[4] && qlevels_done < 5);
713 
714  // can we go finer?
715  } else if (DV100_ENABLE_FINER &&
716  size[0]+size[1]+size[2]+size[3]+size[4] < vs_total_ac_bits_hd) {
717  int save_qlevel;
718  int largest = size[0] % 5; /* 'random' number */
719 
720  while (qlevels[0] > min_qlevel[0] ||
721  qlevels[1] > min_qlevel[1] ||
722  qlevels[2] > min_qlevel[2] ||
723  qlevels[3] > min_qlevel[3] ||
724  qlevels[4] > min_qlevel[4]) {
725 
726  /* find the macroblock with the highest qlevel */
727  for (i = 0; i < 5; i++) {
728  if (qlevels[i] > min_qlevel[i] && qlevels[i] > qlevels[largest])
729  largest = i;
730  }
731 
732  i = largest;
733 
734  /* ensure that we don't enter infinite loop */
735  largest = (largest+1) % 5;
736 
737  if (qlevels[i] <= min_qlevel[i]) {
738  /* can't unquantize any more */
739  continue;
740  }
741  /* quantize a little bit less */
742  save_qlevel = qlevels[i];
743  qlevels[i] -= dv100_qlevel_inc;
744  if (qlevels[i] < min_qlevel[i])
745  qlevels[i] = min_qlevel[i];
746 
747  qnos[i] = DV100_QLEVEL_QNO(dv100_qlevels[qlevels[i]]);
748 
749  size[i] = 0;
750 
751  /* for each block */
752  b = &blks[8*i];
753  for (j = 0; j < 8; j++, b++) {
754  /* accumulate block size into macroblock */
755  if(size_cache[8*i+j][qlevels[i]] == 0) {
756  size_cache[8*i+j][qlevels[i]] = dv100_actual_quantize(b, qlevels[i]);
757  }
758  size[i] += size_cache[8*i+j][qlevels[i]];
759  } /* for each block */
760 
761  /* did we bust the limit? */
762  if (vs_total_ac_bits_hd < size[0] + size[1] + size[2] + size[3] + size[4]) {
763  /* go back down and exit */
764  qlevels[i] = save_qlevel;
765  qnos[i] = DV100_QLEVEL_QNO(dv100_qlevels[qlevels[i]]);
766  break;
767  }
768  }
769  }
770 
771  /* now do the actual quantization */
772  for (i = 0; i < 5; i++) {
773  /* for each block */
774  b = &blks[8*i];
775  size[i] = 0;
776  for (j = 0; j < 8; j++, b++) {
777  /* accumulate block size into macroblock */
778  size[i] += dv100_actual_quantize(b, qlevels[i]);
779  } /* for each block */
780  }
781 }
782 
783 static inline void dv_guess_qnos(EncBlockInfo *blks, int *qnos)
784 {
785  int size[5];
786  int i, j, k, a, prev, a2;
787  EncBlockInfo *b;
788 
789  size[0] =
790  size[1] =
791  size[2] =
792  size[3] =
793  size[4] = 1 << 24;
794  do {
795  b = blks;
796  for (i = 0; i < 5; i++) {
797  if (!qnos[i])
798  continue;
799 
800  qnos[i]--;
801  size[i] = 0;
802  for (j = 0; j < 6; j++, b++) {
803  for (a = 0; a < 4; a++) {
804  if (b->area_q[a] != ff_dv_quant_shifts[qnos[i] + ff_dv_quant_offset[b->cno]][a]) {
805  b->bit_size[a] = 1; // 4 areas 4 bits for EOB :)
806  b->area_q[a]++;
807  prev = b->prev[a];
808  av_assert2(b->next[prev] >= mb_area_start[a + 1] || b->mb[prev]);
809  for (k = b->next[prev]; k < mb_area_start[a + 1]; k = b->next[k]) {
810  b->mb[k] >>= 1;
811  if (b->mb[k]) {
812  b->bit_size[a] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
813  prev = k;
814  } else {
815  if (b->next[k] >= mb_area_start[a + 1] && b->next[k] < 64) {
816  for (a2 = a + 1; b->next[k] >= mb_area_start[a2 + 1]; a2++)
817  b->prev[a2] = prev;
818  av_assert2(a2 < 4);
819  av_assert2(b->mb[b->next[k]]);
820  b->bit_size[a2] += dv_rl2vlc_size(b->next[k] - prev - 1, b->mb[b->next[k]]) -
821  dv_rl2vlc_size(b->next[k] - k - 1, b->mb[b->next[k]]);
822  av_assert2(b->prev[a2] == k && (a2 + 1 >= 4 || b->prev[a2 + 1] != k));
823  b->prev[a2] = prev;
824  }
825  b->next[prev] = b->next[k];
826  }
827  }
828  b->prev[a + 1] = prev;
829  }
830  size[i] += b->bit_size[a];
831  }
832  }
833  if (vs_total_ac_bits >= size[0] + size[1] + size[2] + size[3] + size[4])
834  return;
835  }
836  } while (qnos[0] | qnos[1] | qnos[2] | qnos[3] | qnos[4]);
837 
838  for (a = 2; a == 2 || vs_total_ac_bits < size[0]; a += a) {
839  b = blks;
840  size[0] = 5 * 6 * 4; // EOB
841  for (j = 0; j < 6 * 5; j++, b++) {
842  prev = b->prev[0];
843  for (k = b->next[prev]; k < 64; k = b->next[k]) {
844  if (b->mb[k] < a && b->mb[k] > -a) {
845  b->next[prev] = b->next[k];
846  } else {
847  size[0] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
848  prev = k;
849  }
850  }
851  }
852  }
853 }
854 
855 /* update all cno values into the blocks, over-writing the old values without
856  touching anything else. (only used for DV100) */
857 static inline void dv_revise_cnos(uint8_t *dif, EncBlockInfo *blk, const AVDVProfile *profile)
858 {
859  uint8_t *data;
860  int mb_index, i;
861 
862  for (mb_index = 0; mb_index < 5; mb_index++) {
863  data = dif + mb_index*80 + 4;
864  for (i = 0; i < profile->bpm; i++) {
865  /* zero out the class number */
866  data[1] &= 0xCF;
867  /* add the new one */
868  data[1] |= blk[profile->bpm*mb_index+i].cno << 4;
869 
870  data += profile->block_sizes[i] >> 3;
871  }
872  }
873 }
874 
875 static int dv_encode_video_segment(AVCodecContext *avctx, void *arg)
876 {
877  DVEncContext *s = avctx->priv_data;
878  DVwork_chunk *work_chunk = arg;
879  int mb_index, i, j;
880  int mb_x, mb_y, c_offset;
881  ptrdiff_t linesize, y_stride;
882  const uint8_t *y_ptr;
883  uint8_t *dif, *p;
884  LOCAL_ALIGNED_8(uint8_t, scratch, [128]);
885  EncBlockInfo enc_blks[5 * DV_MAX_BPM];
886  PutBitContext pbs[5 * DV_MAX_BPM];
887  PutBitContext *pb;
888  EncBlockInfo *enc_blk;
889  int vs_bit_size = 0;
890  int qnos[5];
891  int *qnosp = &qnos[0];
892 
893  p = dif = &s->buf[work_chunk->buf_offset * 80];
894  enc_blk = &enc_blks[0];
895  for (mb_index = 0; mb_index < 5; mb_index++) {
896  dv_calculate_mb_xy(s->sys, s->buf, work_chunk, mb_index, &mb_x, &mb_y);
897 
898  qnos[mb_index] = DV_PROFILE_IS_HD(s->sys) ? 1 : 15;
899 
900  y_ptr = s->frame->data[0] + (mb_y * s->frame->linesize[0] + mb_x) * 8;
901  linesize = s->frame->linesize[0];
902 
903  if (s->sys->height == 1080 && mb_y < 134)
904  enc_blk->dct_mode = dv_guess_dct_mode(s, y_ptr, linesize);
905  else
906  enc_blk->dct_mode = 0;
907  for (i = 1; i < 8; i++)
908  enc_blk[i].dct_mode = enc_blk->dct_mode;
909 
910  /* initializing luminance blocks */
911  if ((s->sys->pix_fmt == AV_PIX_FMT_YUV420P) ||
912  (s->sys->pix_fmt == AV_PIX_FMT_YUV411P && mb_x >= (704 / 8)) ||
913  (s->sys->height >= 720 && mb_y != 134)) {
914  y_stride = s->frame->linesize[0] * (1 << (3*!enc_blk->dct_mode));
915  } else {
916  y_stride = 16;
917  }
918  y_ptr = s->frame->data[0] +
919  (mb_y * s->frame->linesize[0] + mb_x) * 8;
920  linesize = s->frame->linesize[0];
921 
922  if (s->sys->video_stype == 4) { /* SD 422 */
923  vs_bit_size +=
924  dv_init_enc_block(enc_blk + 0, y_ptr, linesize, s, 0) +
925  dv_init_enc_block(enc_blk + 1, NULL, linesize, s, 0) +
926  dv_init_enc_block(enc_blk + 2, y_ptr + 8, linesize, s, 0) +
927  dv_init_enc_block(enc_blk + 3, NULL, linesize, s, 0);
928  } else {
929  vs_bit_size +=
930  dv_init_enc_block(enc_blk + 0, y_ptr, linesize, s, 0) +
931  dv_init_enc_block(enc_blk + 1, y_ptr + 8, linesize, s, 0) +
932  dv_init_enc_block(enc_blk + 2, y_ptr + y_stride, linesize, s, 0) +
933  dv_init_enc_block(enc_blk + 3, y_ptr + 8 + y_stride, linesize, s, 0);
934  }
935  enc_blk += 4;
936 
937  /* initializing chrominance blocks */
938  c_offset = ((mb_y >> (s->sys->pix_fmt == AV_PIX_FMT_YUV420P)) * s->frame->linesize[1] +
939  (mb_x >> ((s->sys->pix_fmt == AV_PIX_FMT_YUV411P) ? 2 : 1))) * 8;
940  for (j = 2; j; j--) {
941  const uint8_t *c_ptr = s->frame->data[j] + c_offset;
942  linesize = s->frame->linesize[j];
943  y_stride = (mb_y == 134) ? 8 : (s->frame->linesize[j] * (1 << (3*!enc_blk->dct_mode)));
944  if (s->sys->pix_fmt == AV_PIX_FMT_YUV411P && mb_x >= (704 / 8)) {
945  uint8_t *b = scratch;
946  for (i = 0; i < 8; i++) {
947  const uint8_t *d = c_ptr + linesize * 8;
948  b[0] = c_ptr[0];
949  b[1] = c_ptr[1];
950  b[2] = c_ptr[2];
951  b[3] = c_ptr[3];
952  b[4] = d[0];
953  b[5] = d[1];
954  b[6] = d[2];
955  b[7] = d[3];
956  c_ptr += linesize;
957  b += 16;
958  }
959  c_ptr = scratch;
960  linesize = 16;
961  }
962 
963  vs_bit_size += dv_init_enc_block(enc_blk++, c_ptr, linesize, s, 1);
964  if (s->sys->bpm == 8)
965  vs_bit_size += dv_init_enc_block(enc_blk++, c_ptr + y_stride,
966  linesize, s, 1);
967  }
968  }
969 
970  if (DV_PROFILE_IS_HD(s->sys)) {
971  /* unconditional */
972  dv_guess_qnos_hd(&enc_blks[0], qnosp);
973  } else if (vs_total_ac_bits < vs_bit_size) {
974  dv_guess_qnos(&enc_blks[0], qnosp);
975  }
976 
977  /* DIF encoding process */
978  for (j = 0; j < 5 * s->sys->bpm;) {
979  int start_mb = j;
980 
981  p[3] = *qnosp++;
982  p += 4;
983 
984  /* First pass over individual cells only */
985  for (i = 0; i < s->sys->bpm; i++, j++) {
986  int sz = s->sys->block_sizes[i] >> 3;
987 
988  init_put_bits(&pbs[j], p, sz);
989  put_sbits(&pbs[j], 9, ((enc_blks[j].mb[0] >> 3) - 1024 + 2) >> 2);
990  put_bits(&pbs[j], 1, DV_PROFILE_IS_HD(s->sys) && i ? 1 : enc_blks[j].dct_mode);
991  put_bits(&pbs[j], 2, enc_blks[j].cno);
992 
993  dv_encode_ac(&enc_blks[j], &pbs[j], &pbs[j + 1]);
994  p += sz;
995  }
996 
997  /* Second pass over each MB space */
998  pb = &pbs[start_mb];
999  for (i = 0; i < s->sys->bpm; i++)
1000  if (enc_blks[start_mb + i].partial_bit_count)
1001  pb = dv_encode_ac(&enc_blks[start_mb + i], pb,
1002  &pbs[start_mb + s->sys->bpm]);
1003  }
1004 
1005  /* Third and final pass over the whole video segment space */
1006  pb = &pbs[0];
1007  for (j = 0; j < 5 * s->sys->bpm; j++) {
1008  if (enc_blks[j].partial_bit_count)
1009  pb = dv_encode_ac(&enc_blks[j], pb, &pbs[s->sys->bpm * 5]);
1010  if (enc_blks[j].partial_bit_count)
1011  av_log(avctx, AV_LOG_ERROR, "ac bitstream overflow\n");
1012  }
1013 
1014  for (j = 0; j < 5 * s->sys->bpm; j++) {
1015  flush_put_bits(&pbs[j]);
1016  memset(put_bits_ptr(&pbs[j]), 0xff, put_bytes_left(&pbs[j], 0));
1017  }
1018 
1019  if (DV_PROFILE_IS_HD(s->sys))
1020  dv_revise_cnos(dif, enc_blks, s->sys);
1021 
1022  return 0;
1023 }
1024 
1025 static inline int dv_write_pack(enum DVPackType pack_id, DVEncContext *c,
1026  uint8_t *buf)
1027 {
1028  /*
1029  * Here's what SMPTE314M says about these two:
1030  * (page 6) APTn, AP1n, AP2n, AP3n: These data shall be identical
1031  * as track application IDs (APTn = 001, AP1n =
1032  * 001, AP2n = 001, AP3n = 001), if the source signal
1033  * comes from a digital VCR. If the signal source is
1034  * unknown, all bits for these data shall be set to 1.
1035  * (page 12) STYPE: STYPE defines a signal type of video signal
1036  * 00000b = 4:1:1 compression
1037  * 00100b = 4:2:2 compression
1038  * XXXXXX = Reserved
1039  * Now, I've got two problems with these statements:
1040  * 1. it looks like APT == 111b should be a safe bet, but it isn't.
1041  * It seems that for PAL as defined in IEC 61834 we have to set
1042  * APT to 000 and for SMPTE314M to 001.
1043  * 2. It is not at all clear what STYPE is used for 4:2:0 PAL
1044  * compression scheme (if any).
1045  */
1046  uint8_t aspect = 0;
1047  int apt = (c->sys->pix_fmt == AV_PIX_FMT_YUV420P ? 0 : 1);
1048  int fs;
1049 
1050  if (c->avctx->height >= 720)
1051  fs = c->avctx->height == 720 || (c->frame->flags & AV_FRAME_FLAG_TOP_FIELD_FIRST) ? 0x40 : 0x00;
1052  else
1053  fs = (c->frame->flags & AV_FRAME_FLAG_TOP_FIELD_FIRST) ? 0x00 : 0x40;
1054 
1055  if (DV_PROFILE_IS_HD(c->sys) ||
1056  (int)(av_q2d(c->avctx->sample_aspect_ratio) *
1057  c->avctx->width / c->avctx->height * 10) >= 17)
1058  /* HD formats are always 16:9 */
1059  aspect = 0x02;
1060 
1061  buf[0] = (uint8_t) pack_id;
1062  switch (pack_id) {
1063  case DV_HEADER525: /* I can't imagine why these two weren't defined as real */
1064  case DV_HEADER625: /* packs in SMPTE314M -- they definitely look like ones */
1065  buf[1] = 0xf8 | /* reserved -- always 1 */
1066  (apt & 0x07); /* APT: Track application ID */
1067  buf[2] = (0 << 7) | /* TF1: audio data is 0 - valid; 1 - invalid */
1068  (0x0f << 3) | /* reserved -- always 1 */
1069  (apt & 0x07); /* AP1: Audio application ID */
1070  buf[3] = (0 << 7) | /* TF2: video data is 0 - valid; 1 - invalid */
1071  (0x0f << 3) | /* reserved -- always 1 */
1072  (apt & 0x07); /* AP2: Video application ID */
1073  buf[4] = (0 << 7) | /* TF3: subcode(SSYB) is 0 - valid; 1 - invalid */
1074  (0x0f << 3) | /* reserved -- always 1 */
1075  (apt & 0x07); /* AP3: Subcode application ID */
1076  break;
1077  case DV_VIDEO_SOURCE:
1078  buf[1] = 0xff; /* reserved -- always 1 */
1079  buf[2] = (1 << 7) | /* B/W: 0 - b/w, 1 - color */
1080  (1 << 6) | /* following CLF is valid - 0, invalid - 1 */
1081  (3 << 4) | /* CLF: color frames ID (see ITU-R BT.470-4) */
1082  0xf; /* reserved -- always 1 */
1083  buf[3] = (3 << 6) | /* reserved -- always 1 */
1084  (c->sys->dsf << 5) | /* system: 60fields/50fields */
1085  c->sys->video_stype; /* signal type video compression */
1086  buf[4] = 0xff; /* VISC: 0xff -- no information */
1087  break;
1088  case DV_VIDEO_CONTROL:
1089  buf[1] = (0 << 6) | /* Copy generation management (CGMS) 0 -- free */
1090  0x3f; /* reserved -- always 1 */
1091  buf[2] = 0xc8 | /* reserved -- always b11001xxx */
1092  aspect;
1093  buf[3] = (1 << 7) | /* frame/field flag 1 -- frame, 0 -- field */
1094  fs | /* first/second field flag 0 -- field 2, 1 -- field 1 */
1095  (1 << 5) | /* frame change flag 0 -- same picture as before, 1 -- different */
1096  (1 << 4) | /* 1 - interlaced, 0 - noninterlaced */
1097  0xc; /* reserved -- always b1100 */
1098  buf[4] = 0xff; /* reserved -- always 1 */
1099  break;
1100  default:
1101  buf[1] =
1102  buf[2] =
1103  buf[3] =
1104  buf[4] = 0xff;
1105  }
1106  return 5;
1107 }
1108 
1109 static inline int dv_write_dif_id(enum DVSectionType t, uint8_t chan_num,
1110  uint8_t seq_num, uint8_t dif_num,
1111  uint8_t *buf)
1112 {
1113  int fsc = chan_num & 1;
1114  int fsp = 1 - (chan_num >> 1);
1115 
1116  buf[0] = (uint8_t) t; /* Section type */
1117  buf[1] = (seq_num << 4) | /* DIF seq number 0-9 for 525/60; 0-11 for 625/50 */
1118  (fsc << 3) | /* FSC: for 50 and 100Mb/s 0 - first channel; 1 - second */
1119  (fsp << 2) | /* FSP: for 100Mb/s 1 - channels 0-1; 0 - channels 2-3 */
1120  3; /* reserved -- always 1 */
1121  buf[2] = dif_num; /* DIF block number Video: 0-134, Audio: 0-8 */
1122  return 3;
1123 }
1124 
1125 static inline int dv_write_ssyb_id(uint8_t syb_num, uint8_t fr, uint8_t *buf)
1126 {
1127  if (syb_num == 0 || syb_num == 6) {
1128  buf[0] = (fr << 7) | /* FR ID 1 - first half of each channel; 0 - second */
1129  (0 << 4) | /* AP3 (Subcode application ID) */
1130  0x0f; /* reserved -- always 1 */
1131  } else if (syb_num == 11) {
1132  buf[0] = (fr << 7) | /* FR ID 1 - first half of each channel; 0 - second */
1133  0x7f; /* reserved -- always 1 */
1134  } else {
1135  buf[0] = (fr << 7) | /* FR ID 1 - first half of each channel; 0 - second */
1136  (0 << 4) | /* APT (Track application ID) */
1137  0x0f; /* reserved -- always 1 */
1138  }
1139  buf[1] = 0xf0 | /* reserved -- always 1 */
1140  (syb_num & 0x0f); /* SSYB number 0 - 11 */
1141  buf[2] = 0xff; /* reserved -- always 1 */
1142  return 3;
1143 }
1144 
1145 static void dv_format_frame(DVEncContext *c, uint8_t *buf)
1146 {
1147  int chan, i, j, k;
1148  /* We work with 720p frames split in half. The odd half-frame is chan 2,3 */
1149  int chan_offset = 2*(c->sys->height == 720 && c->avctx->frame_num & 1);
1150 
1151  for (chan = 0; chan < c->sys->n_difchan; chan++) {
1152  for (i = 0; i < c->sys->difseg_size; i++) {
1153  memset(buf, 0xff, 80 * 6); /* first 6 DIF blocks are for control data */
1154 
1155  /* DV header: 1DIF */
1156  buf += dv_write_dif_id(DV_SECT_HEADER, chan+chan_offset, i, 0, buf);
1157  buf += dv_write_pack((c->sys->dsf ? DV_HEADER625 : DV_HEADER525),
1158  c, buf);
1159  buf += 72; /* unused bytes */
1160 
1161  /* DV subcode: 2DIFs */
1162  for (j = 0; j < 2; j++) {
1163  buf += dv_write_dif_id(DV_SECT_SUBCODE, chan+chan_offset, i, j, buf);
1164  for (k = 0; k < 6; k++)
1165  buf += dv_write_ssyb_id(k, (i < c->sys->difseg_size / 2), buf) + 5;
1166  buf += 29; /* unused bytes */
1167  }
1168 
1169  /* DV VAUX: 3DIFS */
1170  for (j = 0; j < 3; j++) {
1171  buf += dv_write_dif_id(DV_SECT_VAUX, chan+chan_offset, i, j, buf);
1172  buf += dv_write_pack(DV_VIDEO_SOURCE, c, buf);
1173  buf += dv_write_pack(DV_VIDEO_CONTROL, c, buf);
1174  buf += 7 * 5;
1175  buf += dv_write_pack(DV_VIDEO_SOURCE, c, buf);
1176  buf += dv_write_pack(DV_VIDEO_CONTROL, c, buf);
1177  buf += 4 * 5 + 2; /* unused bytes */
1178  }
1179 
1180  /* DV Audio/Video: 135 Video DIFs + 9 Audio DIFs */
1181  for (j = 0; j < 135; j++) {
1182  if (j % 15 == 0) {
1183  memset(buf, 0xff, 80);
1184  buf += dv_write_dif_id(DV_SECT_AUDIO, chan+chan_offset, i, j/15, buf);
1185  buf += 77; /* audio control & shuffled PCM audio */
1186  }
1187  buf += dv_write_dif_id(DV_SECT_VIDEO, chan+chan_offset, i, j, buf);
1188  buf += 77; /* 1 video macroblock: 1 bytes control
1189  * 4 * 14 bytes Y 8x8 data
1190  * 10 bytes Cr 8x8 data
1191  * 10 bytes Cb 8x8 data */
1192  }
1193  }
1194  }
1195 }
1196 
1198  const AVFrame *frame, int *got_packet)
1199 {
1200  DVEncContext *s = c->priv_data;
1201  int ret;
1202 
1203  if ((ret = ff_get_encode_buffer(c, pkt, s->sys->frame_size, 0)) < 0)
1204  return ret;
1205  /* Fixme: Only zero the part that is not overwritten later. */
1206  memset(pkt->data, 0, pkt->size);
1207 
1208  c->pix_fmt = s->sys->pix_fmt;
1209  s->frame = frame;
1210  s->buf = pkt->data;
1211 
1213 
1214  c->execute(c, dv_encode_video_segment, s->work_chunks, NULL,
1215  dv_work_pool_size(s->sys), sizeof(DVwork_chunk));
1216 
1217  emms_c();
1218 
1219  *got_packet = 1;
1220 
1221  return 0;
1222 }
1223 
1224 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
1225 #define OFFSET(x) offsetof(DVEncContext, x)
1226 static const AVOption dv_options[] = {
1227  { "quant_deadzone", "Quantizer dead zone", OFFSET(quant_deadzone), AV_OPT_TYPE_INT, { .i64 = 7 }, 0, 1024, VE },
1228  { NULL },
1229 };
1230 
1232  .class_name = "dvvideo encoder",
1233  .item_name = av_default_item_name,
1234  .option = dv_options,
1235  .version = LIBAVUTIL_VERSION_INT,
1236 };
1237 
1239  .p.name = "dvvideo",
1240  CODEC_LONG_NAME("DV (Digital Video)"),
1241  .p.type = AVMEDIA_TYPE_VIDEO,
1242  .p.id = AV_CODEC_ID_DVVIDEO,
1243  .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS |
1246  .priv_data_size = sizeof(DVEncContext),
1249  .p.pix_fmts = (const enum AVPixelFormat[]) {
1252  },
1253  .p.priv_class = &dvvideo_encode_class,
1254 };
EncBlockInfo::mb
int16_t mb[64]
Definition: dvenc.c:192
dv_guess_qnos
static void dv_guess_qnos(EncBlockInfo *blks, int *qnos)
Definition: dvenc.c:783
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
dv_set_class_number_sd
static av_always_inline int dv_set_class_number_sd(DVEncContext *s, int16_t *blk, EncBlockInfo *bi, const uint8_t *zigzag_scan, const int *weight, int bias)
Definition: dvenc.c:398
dv_format_frame
static void dv_format_frame(DVEncContext *c, uint8_t *buf)
Definition: dvenc.c:1145
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
name
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf default minimum maximum flags name is the option name
Definition: writing_filters.txt:88
level
uint8_t level
Definition: svq3.c:204
dv100_qstep_inv
static const int dv100_qstep_inv[16]
Definition: dvenc.c:354
DV_MAX_BPM
#define DV_MAX_BPM
maximum number of blocks per macroblock in any DV format
Definition: dv.h:72
DVEncContext
Definition: dvenc.c:51
dv_vlc_map_tableinit
static av_cold void dv_vlc_map_tableinit(void)
Definition: dv_tablegen.h:51
DV_VIDEO_SOURCE
@ DV_VIDEO_SOURCE
Definition: dv.h:46
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
opt.h
DV100_ENABLE_FINER
#define DV100_ENABLE_FINER
Definition: dvenc.c:290
DVwork_chunk::buf_offset
uint16_t buf_offset
Definition: dv_internal.h:31
FDCTDSPContext::fdct248
void(* fdct248)(int16_t *block)
Definition: fdctdsp.h:28
mem_internal.h
EncBlockInfo::prev
int prev[5]
Definition: dvenc.c:188
is
The official guide to swscale for confused that is
Definition: swscale.txt:28
dv_profile_internal.h
dv_weight_1080
static const int dv_weight_1080[2][64]
Definition: dvenc.c:360
dv_rl2vlc
static av_always_inline int dv_rl2vlc(int run, int l, int sign, uint32_t *vlc)
Definition: dvenc.c:173
thread.h
dv_weight_720
static const int dv_weight_720[2][64]
Definition: dvenc.c:379
DV_SECT_AUDIO
@ DV_SECT_AUDIO
Definition: dv.h:34
dv_tablegen.h
put_sbits
static void put_sbits(PutBitContext *pb, int n, int32_t value)
Definition: put_bits.h:281
init_put_bits
static void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)
Initialize the PutBitContext s.
Definition: put_bits.h:62
av_mod_uintp2
#define av_mod_uintp2
Definition: common.h:122
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:330
put_bits
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
Definition: j2kenc.c:222
pixdesc.h
DVwork_chunk
Definition: dv_internal.h:30
EncBlockInfo::partial_bit_count
uint8_t partial_bit_count
Definition: dvenc.c:195
dv_vlc_pair::vlc
uint32_t vlc
Definition: dv_tablegen.h:41
AVPacket::data
uint8_t * data
Definition: packet.h:374
AVOption
AVOption.
Definition: opt.h:251
encode.h
b
#define b
Definition: input.c:41
chroma
static av_always_inline void chroma(WaveformContext *s, AVFrame *in, AVFrame *out, int component, int intensity, int offset_y, int offset_x, int column, int mirror, int jobnr, int nb_jobs)
Definition: vf_waveform.c:1639
data
const char data[16]
Definition: mxf.c:148
mb_area_start
static const int mb_area_start[5]
Definition: dvenc.c:130
dv_encode_video_segment
static int dv_encode_video_segment(AVCodecContext *avctx, void *arg)
Definition: dvenc.c:875
FFCodec
Definition: codec_internal.h:127
ff_pixblockdsp_init
av_cold void ff_pixblockdsp_init(PixblockDSPContext *c, AVCodecContext *avctx)
Definition: pixblockdsp.c:81
max
#define max(a, b)
Definition: cuda_runtime.h:33
DV_VLC_MAP_RUN_SIZE
#define DV_VLC_MAP_RUN_SIZE
Definition: dv_tablegen.h:35
DVEncContext::frame
const AVFrame * frame
Definition: dvenc.c:54
ff_dv_print_profiles
void ff_dv_print_profiles(void *logctx, int loglevel)
Print all allowed DV profiles into logctx at specified logging level.
DV_HEADER525
@ DV_HEADER525
Definition: dv.h:39
EncBlockInfo::next
uint8_t next[64]
Definition: dvenc.c:193
av_chroma_location_name
const char * av_chroma_location_name(enum AVChromaLocation location)
Definition: pixdesc.c:3333
dv_weight_88
static const int dv_weight_88[64]
Definition: dvenc.c:266
AV_FRAME_FLAG_TOP_FIELD_FIRST
#define AV_FRAME_FLAG_TOP_FIELD_FIRST
A flag to mark frames where the top field is displayed first if the content is interlaced.
Definition: frame.h:631
DVPackType
DVPackType
Definition: dv.h:38
FDCTDSPContext
Definition: fdctdsp.h:26
DVSectionType
DVSectionType
Definition: dv.h:30
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:131
dv100_qlevel_inc
static const int dv100_qlevel_inc
Definition: dvenc.c:347
DVEncContext::quant_deadzone
int quant_deadzone
Definition: dvenc.c:64
EncBlockInfo::bit_size
int bit_size[4]
Definition: dvenc.c:187
PixblockDSPContext::get_pixels
void(* get_pixels)(int16_t *av_restrict block, const uint8_t *pixels, ptrdiff_t stride)
Definition: pixblockdsp.h:29
put_bits_left
static int put_bits_left(PutBitContext *s)
Definition: put_bits.h:125
ff_me_cmp_init
av_cold void ff_me_cmp_init(MECmpContext *c, AVCodecContext *avctx)
Definition: me_cmp.c:1008
DV_VIDEO_CONTROL
@ DV_VIDEO_CONTROL
Definition: dv.h:47
dv_init_enc_block
static av_always_inline int dv_init_enc_block(EncBlockInfo *bi, const uint8_t *data, int linesize, DVEncContext *s, int chroma)
Definition: dvenc.c:539
FF_CODEC_ENCODE_CB
#define FF_CODEC_ENCODE_CB(func)
Definition: codec_internal.h:315
MECmpContext::ildct_cmp
me_cmp_func ildct_cmp[6]
Definition: me_cmp.h:77
put_bytes_left
static int put_bytes_left(const PutBitContext *s, int round_up)
Definition: put_bits.h:135
dvvideo_encode_class
static const AVClass dvvideo_encode_class
Definition: dvenc.c:1231
AV_CODEC_FLAG_INTERLACED_DCT
#define AV_CODEC_FLAG_INTERLACED_DCT
Use interlaced DCT.
Definition: avcodec.h:318
dv_work_pool_size
static int dv_work_pool_size(const AVDVProfile *d)
Definition: dv_internal.h:37
ff_thread_once
static int ff_thread_once(char *control, void(*routine)(void))
Definition: thread.h:184
pkt
AVPacket * pkt
Definition: movenc.c:59
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
dv_weight_bits
static const int dv_weight_bits
Definition: dvenc.c:265
av_cold
#define av_cold
Definition: attributes.h:90
ff_fdctdsp_init
av_cold void ff_fdctdsp_init(FDCTDSPContext *c, AVCodecContext *avctx)
Definition: fdctdsp.c:26
DVEncContext::avctx
AVCodecContext * avctx
Definition: dvenc.c:55
dv100_starting_qno
static const int dv100_starting_qno
Definition: dvenc.c:344
DV_SECT_SUBCODE
@ DV_SECT_SUBCODE
Definition: dv.h:32
emms_c
#define emms_c()
Definition: internal.h:51
s
#define s(width, name)
Definition: cbs_vp9.c:256
EncBlockInfo::sign
uint8_t sign[64]
Definition: dvenc.c:194
DVEncContext::buf
uint8_t * buf
Definition: dvenc.c:56
dv_guess_dct_mode
static av_always_inline int dv_guess_dct_mode(DVEncContext *s, const uint8_t *data, ptrdiff_t linesize)
Definition: dvenc.c:250
DVEncContext::fdct
void(* fdct[2])(int16_t *block)
Definition: dvenc.c:59
dv100_min_bias
static const int dv100_min_bias
Definition: dvenc.c:342
av_q2d
static double av_q2d(AVRational a)
Convert an AVRational to a double.
Definition: rational.h:104
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts_bsf.c:365
AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE
#define AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE
This encoder can reorder user opaque values from input AVFrames and return them with corresponding ou...
Definition: codec.h:159
LOCAL_ALIGNED_16
#define LOCAL_ALIGNED_16(t, v,...)
Definition: mem_internal.h:129
dv_calculate_mb_xy
static void dv_calculate_mb_xy(const AVDVProfile *sys, const uint8_t *buf, const DVwork_chunk *work_chunk, int m, int *mb_x, int *mb_y)
Definition: dv_internal.h:47
dv_revise_cnos
static void dv_revise_cnos(uint8_t *dif, EncBlockInfo *blk, const AVDVProfile *profile)
Definition: dvenc.c:857
AV_PIX_FMT_YUV420P
@ AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:66
blk
#define blk(i)
Definition: sha.c:186
dv_guess_qnos_hd
static void dv_guess_qnos_hd(EncBlockInfo *blks, int *qnos)
Definition: dvenc.c:641
PutBitContext
Definition: put_bits.h:50
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition: codec_internal.h:272
LOCAL_ALIGNED_8
#define LOCAL_ALIGNED_8(t, v,...)
Definition: mem_internal.h:123
arg
const char * arg
Definition: jacosubdec.c:67
DVEncContext::ildct_cmp
me_cmp_func ildct_cmp
Definition: dvenc.c:61
FFABS
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:64
if
if(ret)
Definition: filter_design.txt:179
PixblockDSPContext
Definition: pixblockdsp.h:28
AV_CODEC_CAP_FRAME_THREADS
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
Definition: codec.h:110
MECmpContext
Definition: me_cmp.h:55
OFFSET
#define OFFSET(x)
Definition: dvenc.c:1225
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
ff_dv_quant_shifts
const uint8_t ff_dv_quant_shifts[22][4]
Definition: dvdata.c:45
EncBlockInfo::dct_mode
int dct_mode
Definition: dvenc.c:191
AV_ONCE_INIT
#define AV_ONCE_INIT
Definition: thread.h:182
DV100_QLEVEL_CNO
#define DV100_QLEVEL_CNO(qlevel)
Definition: dvenc.c:295
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
NULL
#define NULL
Definition: coverity.c:32
bits_left
#define bits_left
Definition: bitstream.h:113
run
uint8_t run
Definition: svq3.c:203
fs
#define fs(width, name, subs,...)
Definition: cbs_vp9.c:258
bias
static int bias(int x, int c)
Definition: vqcdec.c:113
DV_SECT_VIDEO
@ DV_SECT_VIDEO
Definition: dv.h:35
AVCHROMA_LOC_TOPLEFT
@ AVCHROMA_LOC_TOPLEFT
ITU-R 601, SMPTE 274M 296M S314M(DV 4:1:1), mpeg2 4:2:2.
Definition: pixfmt.h:692
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:237
mathops.h
dv_write_pack
static int dv_write_pack(enum DVPackType pack_id, DVEncContext *c, uint8_t *buf)
Definition: dvenc.c:1025
AVCodecContext::ildct_cmp
int ildct_cmp
interlaced DCT comparison function
Definition: avcodec.h:841
dv_write_dif_id
static int dv_write_dif_id(enum DVSectionType t, uint8_t chan_num, uint8_t seq_num, uint8_t dif_num, uint8_t *buf)
Definition: dvenc.c:1109
DVEncContext::work_chunks
DVwork_chunk work_chunks[4 *12 *27]
Definition: dvenc.c:62
dv_encode_ac
static av_always_inline PutBitContext * dv_encode_ac(EncBlockInfo *bi, PutBitContext *pb_pool, PutBitContext *pb_end)
Definition: dvenc.c:204
dv100_chroma_bias
static const int dv100_chroma_bias
Definition: dvenc.c:343
AVOnce
#define AVOnce
Definition: thread.h:181
c
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
dv100_qstep_bits
static const int dv100_qstep_bits
Definition: dvenc.c:353
weight
static int weight(int i, int blen, int offset)
Definition: diracdec.c:1562
DV_HEADER625
@ DV_HEADER625
Definition: dv.h:40
AVCodecContext::time_base
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented.
Definition: avcodec.h:557
dv_set_class_number_hd
static void dv_set_class_number_hd(DVEncContext *s, int16_t *blk, EncBlockInfo *bi, const uint8_t *zigzag_scan, const int *weight, int bias)
Definition: dvenc.c:482
dv.h
AV_CODEC_CAP_DR1
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:52
AVPacket::size
int size
Definition: packet.h:375
codec_internal.h
dvvideo_encode_init
static av_cold int dvvideo_encode_init(AVCodecContext *avctx)
Definition: dvenc.c:68
DVEncContext::get_pixels
void(* get_pixels)(int16_t *block, const uint8_t *pixels, ptrdiff_t linesize)
Definition: dvenc.c:58
size
int size
Definition: twinvq_data.h:10344
DVEncContext::sys
const AVDVProfile * sys
Definition: dvenc.c:53
dv100_quantize
static av_always_inline int dv100_quantize(int level, int qsinv)
Definition: dvenc.c:590
ff_dv_zigzag248_direct
const uint8_t ff_dv_zigzag248_direct[64]
Definition: dvdata.c:33
EncBlockInfo::partial_bit_buffer
uint32_t partial_bit_buffer
Definition: dvenc.c:196
dvvideo_encode_frame
static int dvvideo_encode_frame(AVCodecContext *c, AVPacket *pkt, const AVFrame *frame, int *got_packet)
Definition: dvenc.c:1197
FF_COMPLIANCE_NORMAL
#define FF_COMPLIANCE_NORMAL
Definition: defs.h:60
a
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
Definition: undefined.txt:41
AV_CODEC_CAP_SLICE_THREADS
#define AV_CODEC_CAP_SLICE_THREADS
Codec supports slice-based (or partition-based) multithreading.
Definition: codec.h:114
attributes.h
vs_total_ac_bits_hd
static const int vs_total_ac_bits_hd
Definition: dvenc.c:128
vs_total_ac_bits
static const int vs_total_ac_bits
Definition: dvenc.c:129
dv100_actual_quantize
static int dv100_actual_quantize(EncBlockInfo *b, int qlevel)
Definition: dvenc.c:603
DV_PROFILE_IS_HD
#define DV_PROFILE_IS_HD(p)
Definition: dv.h:53
mb
#define mb
Definition: vf_colormatrix.c:101
VE
#define VE
Definition: dvenc.c:1224
dv_options
static const AVOption dv_options[]
Definition: dvenc.c:1226
av_assert2
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
Definition: avassert.h:64
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
dv_vlc_map
static struct dv_vlc_pair dv_vlc_map[DV_VLC_MAP_RUN_SIZE][DV_VLC_MAP_LEV_SIZE]
Definition: dv_tablegen.h:49
internal.h
dv_write_ssyb_id
static int dv_write_ssyb_id(uint8_t syb_num, uint8_t fr, uint8_t *buf)
Definition: dvenc.c:1125
weights
static const int weights[]
Definition: hevc_pel.c:32
a2
#define a2
Definition: regdef.h:48
DV_SECT_HEADER
@ DV_SECT_HEADER
Definition: dv.h:31
EncBlockInfo::area_q
int area_q[4]
Definition: dvenc.c:186
xf
#define xf(width, name, var, range_min, range_max, subs,...)
Definition: cbs_av1.c:664
av_always_inline
#define av_always_inline
Definition: attributes.h:49
AV_CODEC_ID_DVVIDEO
@ AV_CODEC_ID_DVVIDEO
Definition: codec_id.h:76
fdctdsp.h
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:194
AVCodecContext::chroma_sample_location
enum AVChromaLocation chroma_sample_location
This defines the location of chroma samples.
Definition: avcodec.h:1040
dv100_qlevels
static const uint8_t dv100_qlevels[DV100_NUM_QLEVELS]
Definition: dvenc.c:307
ff_dvvideo_encoder
const FFCodec ff_dvvideo_encoder
Definition: dvenc.c:1238
DV100_NUM_QLEVELS
#define DV100_NUM_QLEVELS
Definition: dvenc.c:297
profile
int profile
Definition: mxfenc.c:2111
AVCodecContext::height
int height
Definition: avcodec.h:615
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:652
avcodec.h
ff_zigzag_direct
const uint8_t ff_zigzag_direct[64]
Definition: mathtables.c:98
EncBlockInfo::cur_ac
int cur_ac
Definition: dvenc.c:189
ret
ret
Definition: filter_design.txt:187
me_cmp_func
int(* me_cmp_func)(struct MpegEncContext *c, const uint8_t *blk1, const uint8_t *blk2, ptrdiff_t stride, int h)
Definition: me_cmp.h:50
AVClass::class_name
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:71
frame
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
Definition: filter_design.txt:264
EncBlockInfo::min_qlevel
int min_qlevel
Definition: dvenc.c:201
AVCodecContext::strict_std_compliance
int strict_std_compliance
strictly follow the standard (MPEG-4, ...).
Definition: avcodec.h:1365
me_cmp.h
dv_internal.h
AVCodecContext
main external API structure.
Definition: avcodec.h:435
ff_dv_quant_offset
const uint8_t ff_dv_quant_offset[4]
Definition: dvdata.c:70
put_bits_ptr
static uint8_t * put_bits_ptr(PutBitContext *s)
Return the pointer to the byte where the bitstream writer will put the next bit.
Definition: put_bits.h:377
ff_get_encode_buffer
int ff_get_encode_buffer(AVCodecContext *avctx, AVPacket *avpkt, int64_t size, int flags)
Get a buffer for a packet.
Definition: encode.c:79
DV_SECT_VAUX
@ DV_SECT_VAUX
Definition: dv.h:33
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:65
EncBlockInfo
Definition: dvenc.c:185
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:225
DV100_QLEVEL_QNO
#define DV100_QLEVEL_QNO(qlevel)
Definition: dvenc.c:294
AVDVProfile
Definition: dv_profile.h:38
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
AV_PIX_FMT_YUV422P
@ AV_PIX_FMT_YUV422P
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
Definition: pixfmt.h:70
FDCTDSPContext::fdct
void(* fdct)(int16_t *block)
Definition: fdctdsp.h:27
flush_put_bits
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
Definition: put_bits.h:143
ff_set_cmp
int ff_set_cmp(MECmpContext *c, me_cmp_func *cmp, int type)
Definition: me_cmp.c:476
EncBlockInfo::save
int16_t save[64]
Definition: dvenc.c:200
AVPacket
This structure stores compressed data.
Definition: packet.h:351
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:462
dv_vlc_pair::size
uint32_t size
Definition: dv_tablegen.h:42
AV_PIX_FMT_YUV411P
@ AV_PIX_FMT_YUV411P
planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples)
Definition: pixfmt.h:73
d
d
Definition: ffmpeg_filter.c:354
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:615
DV100_MAKE_QLEVEL
#define DV100_MAKE_QLEVEL(qno, cno)
Definition: dvenc.c:293
DV_VLC_MAP_LEV_SIZE
#define DV_VLC_MAP_LEV_SIZE
Definition: dv_tablegen.h:36
dv_rl2vlc_size
static av_always_inline int dv_rl2vlc_size(int run, int l)
Definition: dvenc.c:179
block
The exact code depends on how similar the blocks are and how related they are to the block
Definition: filter_design.txt:207
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
dv_weight_248
static const int dv_weight_248[64]
Definition: dvenc.c:276
av_dv_codec_profile2
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:315
int
int
Definition: ffmpeg_filter.c:354
put_bits.h
EncBlockInfo::cno
int cno
Definition: dvenc.c:190
ff_dv_init_dynamic_tables
int ff_dv_init_dynamic_tables(DVwork_chunk *work_chunks, const AVDVProfile *d)
Definition: dv.c:169
pixblockdsp.h
av_get_pix_fmt_name
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:2856