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