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