FFmpeg  2.1.1
dv.c
Go to the documentation of this file.
1 /*
2  * DV decoder
3  * Copyright (c) 2002 Fabrice Bellard
4  * Copyright (c) 2004 Roman Shaposhnik
5  *
6  * DV encoder
7  * Copyright (c) 2003 Roman Shaposhnik
8  *
9  * 50 Mbps (DVCPRO50) support
10  * Copyright (c) 2006 Daniel Maas <dmaas@maasdigital.com>
11  *
12  * 100 Mbps (DVCPRO HD) support
13  * Initial code by Daniel Maas <dmaas@maasdigital.com> (funded by BBC R&D)
14  * Final code by Roman Shaposhnik
15  *
16  * Many thanks to Dan Dennedy <dan@dennedy.org> for providing wealth
17  * of DV technical info.
18  *
19  * This file is part of FFmpeg.
20  *
21  * FFmpeg is free software; you can redistribute it and/or
22  * modify it under the terms of the GNU Lesser General Public
23  * License as published by the Free Software Foundation; either
24  * version 2.1 of the License, or (at your option) any later version.
25  *
26  * FFmpeg is distributed in the hope that it will be useful,
27  * but WITHOUT ANY WARRANTY; without even the implied warranty of
28  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
29  * Lesser General Public License for more details.
30  *
31  * You should have received a copy of the GNU Lesser General Public
32  * License along with FFmpeg; if not, write to the Free Software
33  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
34  */
35 
36 /**
37  * @file
38  * DV codec.
39  */
40 
41 #include "libavutil/internal.h"
42 #include "libavutil/pixdesc.h"
43 #include "avcodec.h"
44 #include "get_bits.h"
45 #include "internal.h"
46 #include "put_bits.h"
47 #include "simple_idct.h"
48 #include "dvdata.h"
49 #include "dv_tablegen.h"
50 
51 /* XXX: also include quantization */
53 
54 static inline void dv_calc_mb_coordinates(const DVprofile *d, int chan, int seq, int slot,
55  uint16_t *tbl)
56 {
57  static const uint8_t off[] = { 2, 6, 8, 0, 4 };
58  static const uint8_t shuf1[] = { 36, 18, 54, 0, 72 };
59  static const uint8_t shuf2[] = { 24, 12, 36, 0, 48 };
60  static const uint8_t shuf3[] = { 18, 9, 27, 0, 36 };
61 
62  static const uint8_t l_start[] = {0, 4, 9, 13, 18, 22, 27, 31, 36, 40};
63  static const uint8_t l_start_shuffled[] = { 9, 4, 13, 0, 18 };
64 
65  static const uint8_t serpent1[] = {0, 1, 2, 2, 1, 0,
66  0, 1, 2, 2, 1, 0,
67  0, 1, 2, 2, 1, 0,
68  0, 1, 2, 2, 1, 0,
69  0, 1, 2};
70  static const uint8_t serpent2[] = {0, 1, 2, 3, 4, 5, 5, 4, 3, 2, 1, 0,
71  0, 1, 2, 3, 4, 5, 5, 4, 3, 2, 1, 0,
72  0, 1, 2, 3, 4, 5};
73 
74  static const uint8_t remap[][2] = {{ 0, 0}, { 0, 0}, { 0, 0}, { 0, 0}, /* dummy */
75  { 0, 0}, { 0, 1}, { 0, 2}, { 0, 3}, {10, 0},
76  {10, 1}, {10, 2}, {10, 3}, {20, 0}, {20, 1},
77  {20, 2}, {20, 3}, {30, 0}, {30, 1}, {30, 2},
78  {30, 3}, {40, 0}, {40, 1}, {40, 2}, {40, 3},
79  {50, 0}, {50, 1}, {50, 2}, {50, 3}, {60, 0},
80  {60, 1}, {60, 2}, {60, 3}, {70, 0}, {70, 1},
81  {70, 2}, {70, 3}, { 0,64}, { 0,65}, { 0,66},
82  {10,64}, {10,65}, {10,66}, {20,64}, {20,65},
83  {20,66}, {30,64}, {30,65}, {30,66}, {40,64},
84  {40,65}, {40,66}, {50,64}, {50,65}, {50,66},
85  {60,64}, {60,65}, {60,66}, {70,64}, {70,65},
86  {70,66}, { 0,67}, {20,67}, {40,67}, {60,67}};
87 
88  int i, k, m;
89  int x, y, blk;
90 
91  for (m=0; m<5; m++) {
92  switch (d->width) {
93  case 1440:
94  blk = (chan*11+seq)*27+slot;
95 
96  if (chan == 0 && seq == 11) {
97  x = m*27+slot;
98  if (x<90) {
99  y = 0;
100  } else {
101  x = (x - 90)*2;
102  y = 67;
103  }
104  } else {
105  i = (4*chan + blk + off[m])%11;
106  k = (blk/11)%27;
107 
108  x = shuf1[m] + (chan&1)*9 + k%9;
109  y = (i*3+k/9)*2 + (chan>>1) + 1;
110  }
111  tbl[m] = (x<<1)|(y<<9);
112  break;
113  case 1280:
114  blk = (chan*10+seq)*27+slot;
115 
116  i = (4*chan + (seq/5) + 2*blk + off[m])%10;
117  k = (blk/5)%27;
118 
119  x = shuf1[m]+(chan&1)*9 + k%9;
120  y = (i*3+k/9)*2 + (chan>>1) + 4;
121 
122  if (x >= 80) {
123  x = remap[y][0]+((x-80)<<(y>59));
124  y = remap[y][1];
125  }
126  tbl[m] = (x<<1)|(y<<9);
127  break;
128  case 960:
129  blk = (chan*10+seq)*27+slot;
130 
131  i = (4*chan + (seq/5) + 2*blk + off[m])%10;
132  k = (blk/5)%27 + (i&1)*3;
133 
134  x = shuf2[m] + k%6 + 6*(chan&1);
135  y = l_start[i] + k/6 + 45*(chan>>1);
136  tbl[m] = (x<<1)|(y<<9);
137  break;
138  case 720:
139  switch (d->pix_fmt) {
140  case AV_PIX_FMT_YUV422P:
141  x = shuf3[m] + slot/3;
142  y = serpent1[slot] +
143  ((((seq + off[m]) % d->difseg_size)<<1) + chan)*3;
144  tbl[m] = (x<<1)|(y<<8);
145  break;
146  case AV_PIX_FMT_YUV420P:
147  x = shuf3[m] + slot/3;
148  y = serpent1[slot] +
149  ((seq + off[m]) % d->difseg_size)*3;
150  tbl[m] = (x<<1)|(y<<9);
151  break;
152  case AV_PIX_FMT_YUV411P:
153  i = (seq + off[m]) % d->difseg_size;
154  k = slot + ((m==1||m==2)?3:0);
155 
156  x = l_start_shuffled[m] + k/6;
157  y = serpent2[k] + i*6;
158  if (x>21)
159  y = y*2 - i*6;
160  tbl[m] = (x<<2)|(y<<8);
161  break;
162  }
163  default:
164  break;
165  }
166  }
167 }
168 
169 /* quantization quanta by QNO for DV100 */
170 static const uint8_t dv100_qstep[16] = {
171  1, /* QNO = 0 and 1 both have no quantization */
172  1,
173  2, 3, 4, 5, 6, 7, 8, 16, 18, 20, 22, 24, 28, 52
174 };
175 
176 static const uint8_t dv_quant_areas[4] = { 6, 21, 43, 64 };
177 
179 {
180  int j,i,c,s,p;
181  uint32_t *factor1, *factor2;
182  const int *iweight1, *iweight2;
183 
184  if (!d->work_chunks[dv_work_pool_size(d)-1].buf_offset) {
185  p = i = 0;
186  for (c=0; c<d->n_difchan; c++) {
187  for (s=0; s<d->difseg_size; s++) {
188  p += 6;
189  for (j=0; j<27; j++) {
190  p += !(j%3);
191  if (!(DV_PROFILE_IS_1080i50(d) && c != 0 && s == 11) &&
192  !(DV_PROFILE_IS_720p50(d) && s > 9)) {
193  dv_calc_mb_coordinates(d, c, s, j, &d->work_chunks[i].mb_coordinates[0]);
194  d->work_chunks[i++].buf_offset = p;
195  }
196  p += 5;
197  }
198  }
199  }
200  }
201 
202  if (!d->idct_factor[DV_PROFILE_IS_HD(d)?8191:5631]) {
203  factor1 = &d->idct_factor[0];
204  factor2 = &d->idct_factor[DV_PROFILE_IS_HD(d)?4096:2816];
205  if (d->height == 720) {
206  iweight1 = &ff_dv_iweight_720_y[0];
207  iweight2 = &ff_dv_iweight_720_c[0];
208  } else {
209  iweight1 = &ff_dv_iweight_1080_y[0];
210  iweight2 = &ff_dv_iweight_1080_c[0];
211  }
212  if (DV_PROFILE_IS_HD(d)) {
213  for (c = 0; c < 4; c++) {
214  for (s = 0; s < 16; s++) {
215  for (i = 0; i < 64; i++) {
216  *factor1++ = (dv100_qstep[s] << (c + 9)) * iweight1[i];
217  *factor2++ = (dv100_qstep[s] << (c + 9)) * iweight2[i];
218  }
219  }
220  }
221  } else {
222  iweight1 = &ff_dv_iweight_88[0];
223  for (j = 0; j < 2; j++, iweight1 = &ff_dv_iweight_248[0]) {
224  for (s = 0; s < 22; s++) {
225  for (i = c = 0; c < 4; c++) {
226  for (; i < dv_quant_areas[c]; i++) {
227  *factor1 = iweight1[i] << (ff_dv_quant_shifts[s][c] + 1);
228  *factor2++ = (*factor1++) << 1;
229  }
230  }
231  }
232  }
233  }
234  }
235 
236  return 0;
237 }
238 
240 {
241  DVVideoContext *s = avctx->priv_data;
242  DSPContext dsp;
243  static int done = 0;
244  int i, j;
245 
246  if (!done) {
247  VLC dv_vlc;
248  uint16_t new_dv_vlc_bits[NB_DV_VLC*2];
249  uint8_t new_dv_vlc_len[NB_DV_VLC*2];
250  uint8_t new_dv_vlc_run[NB_DV_VLC*2];
251  int16_t new_dv_vlc_level[NB_DV_VLC*2];
252 
253  done = 1;
254 
255  /* it's faster to include sign bit in a generic VLC parsing scheme */
256  for (i = 0, j = 0; i < NB_DV_VLC; i++, j++) {
257  new_dv_vlc_bits[j] = dv_vlc_bits[i];
258  new_dv_vlc_len[j] = dv_vlc_len[i];
259  new_dv_vlc_run[j] = dv_vlc_run[i];
260  new_dv_vlc_level[j] = dv_vlc_level[i];
261 
262  if (dv_vlc_level[i]) {
263  new_dv_vlc_bits[j] <<= 1;
264  new_dv_vlc_len[j]++;
265 
266  j++;
267  new_dv_vlc_bits[j] = (dv_vlc_bits[i] << 1) | 1;
268  new_dv_vlc_len[j] = dv_vlc_len[i] + 1;
269  new_dv_vlc_run[j] = dv_vlc_run[i];
270  new_dv_vlc_level[j] = -dv_vlc_level[i];
271  }
272  }
273 
274  /* NOTE: as a trick, we use the fact the no codes are unused
275  to accelerate the parsing of partial codes */
276  init_vlc(&dv_vlc, TEX_VLC_BITS, j,
277  new_dv_vlc_len, 1, 1, new_dv_vlc_bits, 2, 2, 0);
278  av_assert1(dv_vlc.table_size == 1184);
279 
280  for (i = 0; i < dv_vlc.table_size; i++){
281  int code = dv_vlc.table[i][0];
282  int len = dv_vlc.table[i][1];
283  int level, run;
284 
285  if (len < 0){ //more bits needed
286  run = 0;
287  level = code;
288  } else {
289  run = new_dv_vlc_run [code] + 1;
290  level = new_dv_vlc_level[code];
291  }
292  ff_dv_rl_vlc[i].len = len;
293  ff_dv_rl_vlc[i].level = level;
294  ff_dv_rl_vlc[i].run = run;
295  }
296  ff_free_vlc(&dv_vlc);
297  }
298 
299  /* Generic DSP setup */
300  memset(&dsp,0, sizeof(dsp));
301  ff_dsputil_init(&dsp, avctx);
302  ff_set_cmp(&dsp, dsp.ildct_cmp, avctx->ildct_cmp);
303  s->get_pixels = dsp.get_pixels;
304  s->ildct_cmp = dsp.ildct_cmp[5];
305 
306  /* 88DCT setup */
307  s->fdct[0] = dsp.fdct;
308  s->idct_put[0] = dsp.idct_put;
309  for (i = 0; i < 64; i++)
310  s->dv_zigzag[0][i] = dsp.idct_permutation[ff_zigzag_direct[i]];
311 
312  /* 248DCT setup */
313  s->fdct[1] = dsp.fdct248;
314  s->idct_put[1] = ff_simple_idct248_put; // FIXME: need to add it to DSP
315  if (avctx->lowres){
316  for (i = 0; i < 64; i++){
317  int j = ff_zigzag248_direct[i];
318  s->dv_zigzag[1][i] = dsp.idct_permutation[(j & 7) + (j & 8) * 4 + (j & 48) / 2];
319  }
320  }else
321  memcpy(s->dv_zigzag[1], ff_zigzag248_direct, 64);
322 
324  avctx->coded_frame = &s->picture;
325  s->avctx = avctx;
327 
328  return 0;
329 }
330 
332 {
333  if (!avpriv_dv_codec_profile(avctx)) {
334  av_log(avctx, AV_LOG_ERROR, "Found no DV profile for %ix%i %s video. "
335  "Valid DV profiles are:\n",
336  avctx->width, avctx->height, av_get_pix_fmt_name(avctx->pix_fmt));
338  return AVERROR(EINVAL);
339  }
340  if (avctx->height > 576) {
341  av_log(avctx, AV_LOG_ERROR, "DVCPRO HD encoding is not supported.\n");
342  return AVERROR_PATCHWELCOME;
343  }
344 
346 
347  return ff_dvvideo_init(avctx);
348 }
349 
350 /* bit budget for AC only in 5 MBs */
351 static const int vs_total_ac_bits = (100 * 4 + 68*2) * 5;
352 static const int mb_area_start[5] = { 1, 6, 21, 43, 64 };
353 
354 #if CONFIG_SMALL
355 /* Converts run and level (where level != 0) pair into VLC, returning bit size */
356 static av_always_inline int dv_rl2vlc(int run, int level, int sign, uint32_t* vlc)
357 {
358  int size;
359  if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {
360  *vlc = dv_vlc_map[run][level].vlc | sign;
361  size = dv_vlc_map[run][level].size;
362  }
363  else {
364  if (level < DV_VLC_MAP_LEV_SIZE) {
365  *vlc = dv_vlc_map[0][level].vlc | sign;
366  size = dv_vlc_map[0][level].size;
367  } else {
368  *vlc = 0xfe00 | (level << 1) | sign;
369  size = 16;
370  }
371  if (run) {
372  *vlc |= ((run < 16) ? dv_vlc_map[run-1][0].vlc :
373  (0x1f80 | (run - 1))) << size;
374  size += (run < 16) ? dv_vlc_map[run-1][0].size : 13;
375  }
376  }
377 
378  return size;
379 }
380 
381 static av_always_inline int dv_rl2vlc_size(int run, int level)
382 {
383  int size;
384 
385  if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {
386  size = dv_vlc_map[run][level].size;
387  }
388  else {
389  size = (level < DV_VLC_MAP_LEV_SIZE) ? dv_vlc_map[0][level].size : 16;
390  if (run) {
391  size += (run < 16) ? dv_vlc_map[run-1][0].size : 13;
392  }
393  }
394  return size;
395 }
396 #else
397 static av_always_inline int dv_rl2vlc(int run, int l, int sign, uint32_t* vlc)
398 {
399  *vlc = dv_vlc_map[run][l].vlc | sign;
400  return dv_vlc_map[run][l].size;
401 }
402 
403 static av_always_inline int dv_rl2vlc_size(int run, int l)
404 {
405  return dv_vlc_map[run][l].size;
406 }
407 #endif
408 
409 typedef struct EncBlockInfo {
410  int area_q[4];
411  int bit_size[4];
412  int prev[5];
413  int cur_ac;
414  int cno;
415  int dct_mode;
416  int16_t mb[64];
418  uint8_t sign[64];
420  uint32_t partial_bit_buffer; /* we can't use uint16_t here */
421 } EncBlockInfo;
422 
424  PutBitContext* pb_pool,
425  PutBitContext* pb_end)
426 {
427  int prev, bits_left;
428  PutBitContext* pb = pb_pool;
429  int size = bi->partial_bit_count;
430  uint32_t vlc = bi->partial_bit_buffer;
431 
433  for (;;){
434  /* Find suitable storage space */
435  for (; size > (bits_left = put_bits_left(pb)); pb++) {
436  if (bits_left) {
437  size -= bits_left;
438  put_bits(pb, bits_left, vlc >> size);
439  vlc = vlc & ((1 << size) - 1);
440  }
441  if (pb + 1 >= pb_end) {
442  bi->partial_bit_count = size;
443  bi->partial_bit_buffer = vlc;
444  return pb;
445  }
446  }
447 
448  /* Store VLC */
449  put_bits(pb, size, vlc);
450 
451  if (bi->cur_ac >= 64)
452  break;
453 
454  /* Construct the next VLC */
455  prev = bi->cur_ac;
456  bi->cur_ac = bi->next[prev];
457  if (bi->cur_ac < 64){
458  size = dv_rl2vlc(bi->cur_ac - prev - 1, bi->mb[bi->cur_ac], bi->sign[bi->cur_ac], &vlc);
459  } else {
460  size = 4; vlc = 6; /* End Of Block stamp */
461  }
462  }
463  return pb;
464 }
465 
468  int ps = s->ildct_cmp(NULL, data, NULL, linesize, 8) - 400;
469  if (ps > 0) {
470  int is = s->ildct_cmp(NULL, data , NULL, linesize<<1, 4) +
471  s->ildct_cmp(NULL, data + linesize, NULL, linesize<<1, 4);
472  return ps > is;
473  }
474  }
475 
476  return 0;
477 }
478 
479 static const int dv_weight_bits = 18;
480 static const int dv_weight_88[64] = {
481  131072, 257107, 257107, 242189, 252167, 242189, 235923, 237536,
482  237536, 235923, 229376, 231390, 223754, 231390, 229376, 222935,
483  224969, 217965, 217965, 224969, 222935, 200636, 218652, 211916,
484  212325, 211916, 218652, 200636, 188995, 196781, 205965, 206433,
485  206433, 205965, 196781, 188995, 185364, 185364, 200636, 200704,
486  200636, 185364, 185364, 174609, 180568, 195068, 195068, 180568,
487  174609, 170091, 175557, 189591, 175557, 170091, 165371, 170627,
488  170627, 165371, 160727, 153560, 160727, 144651, 144651, 136258,
489 };
490 static const int dv_weight_248[64] = {
491  131072, 242189, 257107, 237536, 229376, 200636, 242189, 223754,
492  224969, 196781, 262144, 242189, 229376, 200636, 257107, 237536,
493  211916, 185364, 235923, 217965, 229376, 211916, 206433, 180568,
494  242189, 223754, 224969, 196781, 211916, 185364, 235923, 217965,
495  200704, 175557, 222935, 205965, 200636, 185364, 195068, 170627,
496  229376, 211916, 206433, 180568, 200704, 175557, 222935, 205965,
497  175557, 153560, 188995, 174609, 165371, 144651, 200636, 185364,
498  195068, 170627, 175557, 153560, 188995, 174609, 165371, 144651,
499 };
500 
501 static av_always_inline int dv_init_enc_block(EncBlockInfo* bi, uint8_t *data, int linesize, DVVideoContext *s, int bias)
502 {
503  const int *weight;
504  const uint8_t* zigzag_scan;
505  LOCAL_ALIGNED_16(int16_t, blk, [64]);
506  int i, area;
507  /* We offer two different methods for class number assignment: the
508  method suggested in SMPTE 314M Table 22, and an improved
509  method. The SMPTE method is very conservative; it assigns class
510  3 (i.e. severe quantization) to any block where the largest AC
511  component is greater than 36. FFmpeg's DV encoder tracks AC bit
512  consumption precisely, so there is no need to bias most blocks
513  towards strongly lossy compression. Instead, we assign class 2
514  to most blocks, and use class 3 only when strictly necessary
515  (for blocks whose largest AC component exceeds 255). */
516 
517 #if 0 /* SMPTE spec method */
518  static const int classes[] = {12, 24, 36, 0xffff};
519 #else /* improved FFmpeg method */
520  static const int classes[] = {-1, -1, 255, 0xffff};
521 #endif
522  int max = classes[0];
523  int prev = 0;
524 
525  av_assert2((((int)blk) & 15) == 0);
526 
527  bi->area_q[0] = bi->area_q[1] = bi->area_q[2] = bi->area_q[3] = 0;
528  bi->partial_bit_count = 0;
529  bi->partial_bit_buffer = 0;
530  bi->cur_ac = 0;
531  if (data) {
532  bi->dct_mode = dv_guess_dct_mode(s, data, linesize);
533  s->get_pixels(blk, data, linesize);
534  s->fdct[bi->dct_mode](blk);
535  } else {
536  /* We rely on the fact that encoding all zeros leads to an immediate EOB,
537  which is precisely what the spec calls for in the "dummy" blocks. */
538  memset(blk, 0, 64*sizeof(*blk));
539  bi->dct_mode = 0;
540  }
541  bi->mb[0] = blk[0];
542 
543  zigzag_scan = bi->dct_mode ? ff_zigzag248_direct : ff_zigzag_direct;
544  weight = bi->dct_mode ? dv_weight_248 : dv_weight_88;
545 
546  for (area = 0; area < 4; area++) {
547  bi->prev[area] = prev;
548  bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
549  for (i = mb_area_start[area]; i < mb_area_start[area+1]; i++) {
550  int level = blk[zigzag_scan[i]];
551 
552  if (level + 15 > 30U) {
553  bi->sign[i] = (level >> 31) & 1;
554  /* weight it and shift down into range, adding for rounding */
555  /* the extra division by a factor of 2^4 reverses the 8x expansion of the DCT
556  AND the 2x doubling of the weights */
557  level = (FFABS(level) * weight[i] + (1 << (dv_weight_bits+3))) >> (dv_weight_bits+4);
558  bi->mb[i] = level;
559  if (level > max)
560  max = level;
561  bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, level);
562  bi->next[prev]= i;
563  prev = i;
564  }
565  }
566  }
567  bi->next[prev]= i;
568  for (bi->cno = 0; max > classes[bi->cno]; bi->cno++);
569 
570  bi->cno += bias;
571 
572  if (bi->cno >= 3) {
573  bi->cno = 3;
574  prev = 0;
575  i = bi->next[prev];
576  for (area = 0; area < 4; area++) {
577  bi->prev[area] = prev;
578  bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
579  for (; i < mb_area_start[area+1]; i = bi->next[i]) {
580  bi->mb[i] >>= 1;
581 
582  if (bi->mb[i]) {
583  bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, bi->mb[i]);
584  bi->next[prev]= i;
585  prev = i;
586  }
587  }
588  }
589  bi->next[prev]= i;
590  }
591 
592  return bi->bit_size[0] + bi->bit_size[1] + bi->bit_size[2] + bi->bit_size[3];
593 }
594 
595 static inline void dv_guess_qnos(EncBlockInfo* blks, int* qnos)
596 {
597  int size[5];
598  int i, j, k, a, prev, a2;
599  EncBlockInfo* b;
600 
601  size[0] = size[1] = size[2] = size[3] = size[4] = 1 << 24;
602  do {
603  b = blks;
604  for (i = 0; i < 5; i++) {
605  if (!qnos[i])
606  continue;
607 
608  qnos[i]--;
609  size[i] = 0;
610  for (j = 0; j < 6; j++, b++) {
611  for (a = 0; a < 4; a++) {
612  if (b->area_q[a] != ff_dv_quant_shifts[qnos[i] + ff_dv_quant_offset[b->cno]][a]) {
613  b->bit_size[a] = 1; // 4 areas 4 bits for EOB :)
614  b->area_q[a]++;
615  prev = b->prev[a];
616  av_assert2(b->next[prev] >= mb_area_start[a+1] || b->mb[prev]);
617  for (k = b->next[prev] ; k < mb_area_start[a+1]; k = b->next[k]) {
618  b->mb[k] >>= 1;
619  if (b->mb[k]) {
620  b->bit_size[a] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
621  prev = k;
622  } else {
623  if (b->next[k] >= mb_area_start[a+1] && b->next[k]<64){
624  for (a2 = a + 1; b->next[k] >= mb_area_start[a2+1]; a2++)
625  b->prev[a2] = prev;
626  av_assert2(a2 < 4);
627  av_assert2(b->mb[b->next[k]]);
628  b->bit_size[a2] += dv_rl2vlc_size(b->next[k] - prev - 1, b->mb[b->next[k]])
629  -dv_rl2vlc_size(b->next[k] - k - 1, b->mb[b->next[k]]);
630  av_assert2(b->prev[a2] == k && (a2 + 1 >= 4 || b->prev[a2+1] != k));
631  b->prev[a2] = prev;
632  }
633  b->next[prev] = b->next[k];
634  }
635  }
636  b->prev[a+1]= prev;
637  }
638  size[i] += b->bit_size[a];
639  }
640  }
641  if (vs_total_ac_bits >= size[0] + size[1] + size[2] + size[3] + size[4])
642  return;
643  }
644  } while (qnos[0]|qnos[1]|qnos[2]|qnos[3]|qnos[4]);
645 
646 
647  for (a = 2; a == 2 || vs_total_ac_bits < size[0]; a += a){
648  b = blks;
649  size[0] = 5 * 6 * 4; //EOB
650  for (j = 0; j < 6 *5; j++, b++) {
651  prev = b->prev[0];
652  for (k = b->next[prev]; k < 64; k = b->next[k]) {
653  if (b->mb[k] < a && b->mb[k] > -a){
654  b->next[prev] = b->next[k];
655  }else{
656  size[0] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
657  prev = k;
658  }
659  }
660  }
661  }
662 }
663 
664 static int dv_encode_video_segment(AVCodecContext *avctx, void *arg)
665 {
666  DVVideoContext *s = avctx->priv_data;
667  DVwork_chunk *work_chunk = arg;
668  int mb_index, i, j;
669  int mb_x, mb_y, c_offset, linesize, y_stride;
670  uint8_t* y_ptr;
671  uint8_t* dif;
672  LOCAL_ALIGNED_8(uint8_t, scratch, [128]);
673  EncBlockInfo enc_blks[5*DV_MAX_BPM];
674  PutBitContext pbs[5*DV_MAX_BPM];
675  PutBitContext* pb;
676  EncBlockInfo* enc_blk;
677  int vs_bit_size = 0;
678  int qnos[5] = {15, 15, 15, 15, 15}; /* No quantization */
679  int* qnosp = &qnos[0];
680 
681  dif = &s->buf[work_chunk->buf_offset*80];
682  enc_blk = &enc_blks[0];
683  for (mb_index = 0; mb_index < 5; mb_index++) {
684  dv_calculate_mb_xy(s, work_chunk, mb_index, &mb_x, &mb_y);
685 
686  /* initializing luminance blocks */
687  if ((s->sys->pix_fmt == AV_PIX_FMT_YUV420P) ||
688  (s->sys->pix_fmt == AV_PIX_FMT_YUV411P && mb_x >= (704 / 8)) ||
689  (s->sys->height >= 720 && mb_y != 134)) {
690  y_stride = s->picture.linesize[0] << 3;
691  } else {
692  y_stride = 16;
693  }
694  y_ptr = s->picture.data[0] + ((mb_y * s->picture.linesize[0] + mb_x) << 3);
695  linesize = s->picture.linesize[0];
696 
697  if (s->sys->video_stype == 4) { /* SD 422 */
698  vs_bit_size +=
699  dv_init_enc_block(enc_blk+0, y_ptr , linesize, s, 0) +
700  dv_init_enc_block(enc_blk+1, NULL , linesize, s, 0) +
701  dv_init_enc_block(enc_blk+2, y_ptr + 8 , linesize, s, 0) +
702  dv_init_enc_block(enc_blk+3, NULL , linesize, s, 0);
703  } else {
704  vs_bit_size +=
705  dv_init_enc_block(enc_blk+0, y_ptr , linesize, s, 0) +
706  dv_init_enc_block(enc_blk+1, y_ptr + 8 , linesize, s, 0) +
707  dv_init_enc_block(enc_blk+2, y_ptr + y_stride, linesize, s, 0) +
708  dv_init_enc_block(enc_blk+3, y_ptr + 8 + y_stride, linesize, s, 0);
709  }
710  enc_blk += 4;
711 
712  /* initializing chrominance blocks */
713  c_offset = (((mb_y >> (s->sys->pix_fmt == AV_PIX_FMT_YUV420P)) * s->picture.linesize[1] +
714  (mb_x >> ((s->sys->pix_fmt == AV_PIX_FMT_YUV411P) ? 2 : 1))) << 3);
715  for (j = 2; j; j--) {
716  uint8_t *c_ptr = s->picture.data[j] + c_offset;
717  linesize = s->picture.linesize[j];
718  y_stride = (mb_y == 134) ? 8 : (s->picture.linesize[j] << 3);
719  if (s->sys->pix_fmt == AV_PIX_FMT_YUV411P && mb_x >= (704 / 8)) {
720  uint8_t* d;
721  uint8_t* b = scratch;
722  for (i = 0; i < 8; i++) {
723  d = c_ptr + (linesize << 3);
724  b[0] = c_ptr[0]; b[1] = c_ptr[1]; b[2] = c_ptr[2]; b[3] = c_ptr[3];
725  b[4] = d[0]; b[5] = d[1]; b[6] = d[2]; b[7] = d[3];
726  c_ptr += linesize;
727  b += 16;
728  }
729  c_ptr = scratch;
730  linesize = 16;
731  }
732 
733  vs_bit_size += dv_init_enc_block( enc_blk++, c_ptr , linesize, s, 1);
734  if (s->sys->bpm == 8) {
735  vs_bit_size += dv_init_enc_block(enc_blk++, c_ptr + y_stride, linesize, s, 1);
736  }
737  }
738  }
739 
740  if (vs_total_ac_bits < vs_bit_size)
741  dv_guess_qnos(&enc_blks[0], qnosp);
742 
743  /* DIF encoding process */
744  for (j=0; j<5*s->sys->bpm;) {
745  int start_mb = j;
746 
747  dif[3] = *qnosp++;
748  dif += 4;
749 
750  /* First pass over individual cells only */
751  for (i=0; i<s->sys->bpm; i++, j++) {
752  int sz = s->sys->block_sizes[i]>>3;
753 
754  init_put_bits(&pbs[j], dif, sz);
755  put_sbits(&pbs[j], 9, ((enc_blks[j].mb[0] >> 3) - 1024 + 2) >> 2);
756  put_bits(&pbs[j], 1, enc_blks[j].dct_mode);
757  put_bits(&pbs[j], 2, enc_blks[j].cno);
758 
759  dv_encode_ac(&enc_blks[j], &pbs[j], &pbs[j+1]);
760  dif += sz;
761  }
762 
763  /* Second pass over each MB space */
764  pb = &pbs[start_mb];
765  for (i=0; i<s->sys->bpm; i++) {
766  if (enc_blks[start_mb+i].partial_bit_count)
767  pb = dv_encode_ac(&enc_blks[start_mb+i], pb, &pbs[start_mb+s->sys->bpm]);
768  }
769  }
770 
771  /* Third and final pass over the whole video segment space */
772  pb = &pbs[0];
773  for (j=0; j<5*s->sys->bpm; j++) {
774  if (enc_blks[j].partial_bit_count)
775  pb = dv_encode_ac(&enc_blks[j], pb, &pbs[s->sys->bpm*5]);
776  if (enc_blks[j].partial_bit_count)
777  av_log(avctx, AV_LOG_ERROR, "ac bitstream overflow\n");
778  }
779 
780  for (j=0; j<5*s->sys->bpm; j++) {
781  int pos;
782  int size = pbs[j].size_in_bits >> 3;
783  flush_put_bits(&pbs[j]);
784  pos = put_bits_count(&pbs[j]) >> 3;
785  if (pos > size) {
786  av_log(avctx, AV_LOG_ERROR, "bitstream written beyond buffer size\n");
787  return -1;
788  }
789  memset(pbs[j].buf + pos, 0xff, size - pos);
790  }
791 
792  return 0;
793 }
794 
795 static inline int dv_write_pack(enum dv_pack_type pack_id, DVVideoContext *c,
796  uint8_t* buf)
797 {
798  /*
799  * Here's what SMPTE314M says about these two:
800  * (page 6) APTn, AP1n, AP2n, AP3n: These data shall be identical
801  * as track application IDs (APTn = 001, AP1n =
802  * 001, AP2n = 001, AP3n = 001), if the source signal
803  * comes from a digital VCR. If the signal source is
804  * unknown, all bits for these data shall be set to 1.
805  * (page 12) STYPE: STYPE defines a signal type of video signal
806  * 00000b = 4:1:1 compression
807  * 00100b = 4:2:2 compression
808  * XXXXXX = Reserved
809  * Now, I've got two problems with these statements:
810  * 1. it looks like APT == 111b should be a safe bet, but it isn't.
811  * It seems that for PAL as defined in IEC 61834 we have to set
812  * APT to 000 and for SMPTE314M to 001.
813  * 2. It is not at all clear what STYPE is used for 4:2:0 PAL
814  * compression scheme (if any).
815  */
816  int apt = (c->sys->pix_fmt == AV_PIX_FMT_YUV420P ? 0 : 1);
817  int fs = c->picture.top_field_first ? 0x00 : 0x40;
818 
819  uint8_t aspect = 0;
820  if ((int)(av_q2d(c->avctx->sample_aspect_ratio) * c->avctx->width / c->avctx->height * 10) >= 17) /* 16:9 */
821  aspect = 0x02;
822 
823  buf[0] = (uint8_t)pack_id;
824  switch (pack_id) {
825  case dv_header525: /* I can't imagine why these two weren't defined as real */
826  case dv_header625: /* packs in SMPTE314M -- they definitely look like ones */
827  buf[1] = 0xf8 | /* reserved -- always 1 */
828  (apt & 0x07); /* APT: Track application ID */
829  buf[2] = (0 << 7) | /* TF1: audio data is 0 - valid; 1 - invalid */
830  (0x0f << 3) | /* reserved -- always 1 */
831  (apt & 0x07); /* AP1: Audio application ID */
832  buf[3] = (0 << 7) | /* TF2: video data is 0 - valid; 1 - invalid */
833  (0x0f << 3) | /* reserved -- always 1 */
834  (apt & 0x07); /* AP2: Video application ID */
835  buf[4] = (0 << 7) | /* TF3: subcode(SSYB) is 0 - valid; 1 - invalid */
836  (0x0f << 3) | /* reserved -- always 1 */
837  (apt & 0x07); /* AP3: Subcode application ID */
838  break;
839  case dv_video_source:
840  buf[1] = 0xff; /* reserved -- always 1 */
841  buf[2] = (1 << 7) | /* B/W: 0 - b/w, 1 - color */
842  (1 << 6) | /* following CLF is valid - 0, invalid - 1 */
843  (3 << 4) | /* CLF: color frames ID (see ITU-R BT.470-4) */
844  0xf; /* reserved -- always 1 */
845  buf[3] = (3 << 6) | /* reserved -- always 1 */
846  (c->sys->dsf << 5) | /* system: 60fields/50fields */
847  c->sys->video_stype; /* signal type video compression */
848  buf[4] = 0xff; /* VISC: 0xff -- no information */
849  break;
850  case dv_video_control:
851  buf[1] = (0 << 6) | /* Copy generation management (CGMS) 0 -- free */
852  0x3f; /* reserved -- always 1 */
853  buf[2] = 0xc8 | /* reserved -- always b11001xxx */
854  aspect;
855  buf[3] = (1 << 7) | /* frame/field flag 1 -- frame, 0 -- field */
856  fs | /* first/second field flag 0 -- field 2, 1 -- field 1 */
857  (1 << 5) | /* frame change flag 0 -- same picture as before, 1 -- different */
858  (1 << 4) | /* 1 - interlaced, 0 - noninterlaced */
859  0xc; /* reserved -- always b1100 */
860  buf[4] = 0xff; /* reserved -- always 1 */
861  break;
862  default:
863  buf[1] = buf[2] = buf[3] = buf[4] = 0xff;
864  }
865  return 5;
866 }
867 
868 #if CONFIG_DVVIDEO_ENCODER
869 static inline int dv_write_dif_id(enum dv_section_type t, uint8_t chan_num,
870  uint8_t seq_num, uint8_t dif_num,
871  uint8_t* buf)
872 {
873  buf[0] = (uint8_t)t; /* Section type */
874  buf[1] = (seq_num << 4) | /* DIF seq number 0-9 for 525/60; 0-11 for 625/50 */
875  (chan_num << 3) | /* FSC: for 50Mb/s 0 - first channel; 1 - second */
876  7; /* reserved -- always 1 */
877  buf[2] = dif_num; /* DIF block number Video: 0-134, Audio: 0-8 */
878  return 3;
879 }
880 
881 
882 static inline int dv_write_ssyb_id(uint8_t syb_num, uint8_t fr, uint8_t* buf)
883 {
884  if (syb_num == 0 || syb_num == 6) {
885  buf[0] = (fr << 7) | /* FR ID 1 - first half of each channel; 0 - second */
886  (0 << 4) | /* AP3 (Subcode application ID) */
887  0x0f; /* reserved -- always 1 */
888  }
889  else if (syb_num == 11) {
890  buf[0] = (fr << 7) | /* FR ID 1 - first half of each channel; 0 - second */
891  0x7f; /* reserved -- always 1 */
892  }
893  else {
894  buf[0] = (fr << 7) | /* FR ID 1 - first half of each channel; 0 - second */
895  (0 << 4) | /* APT (Track application ID) */
896  0x0f; /* reserved -- always 1 */
897  }
898  buf[1] = 0xf0 | /* reserved -- always 1 */
899  (syb_num & 0x0f); /* SSYB number 0 - 11 */
900  buf[2] = 0xff; /* reserved -- always 1 */
901  return 3;
902 }
903 
904 static void dv_format_frame(DVVideoContext* c, uint8_t* buf)
905 {
906  int chan, i, j, k;
907 
908  for (chan = 0; chan < c->sys->n_difchan; chan++) {
909  for (i = 0; i < c->sys->difseg_size; i++) {
910  memset(buf, 0xff, 80 * 6); /* first 6 DIF blocks are for control data */
911 
912  /* DV header: 1DIF */
913  buf += dv_write_dif_id(dv_sect_header, chan, i, 0, buf);
914  buf += dv_write_pack((c->sys->dsf ? dv_header625 : dv_header525), c, buf);
915  buf += 72; /* unused bytes */
916 
917  /* DV subcode: 2DIFs */
918  for (j = 0; j < 2; j++) {
919  buf += dv_write_dif_id(dv_sect_subcode, chan, i, j, buf);
920  for (k = 0; k < 6; k++)
921  buf += dv_write_ssyb_id(k, (i < c->sys->difseg_size/2), buf) + 5;
922  buf += 29; /* unused bytes */
923  }
924 
925  /* DV VAUX: 3DIFS */
926  for (j = 0; j < 3; j++) {
927  buf += dv_write_dif_id(dv_sect_vaux, chan, i, j, buf);
928  buf += dv_write_pack(dv_video_source, c, buf);
929  buf += dv_write_pack(dv_video_control, c, buf);
930  buf += 7*5;
931  buf += dv_write_pack(dv_video_source, c, buf);
932  buf += dv_write_pack(dv_video_control, c, buf);
933  buf += 4*5 + 2; /* unused bytes */
934  }
935 
936  /* DV Audio/Video: 135 Video DIFs + 9 Audio DIFs */
937  for (j = 0; j < 135; j++) {
938  if (j%15 == 0) {
939  memset(buf, 0xff, 80);
940  buf += dv_write_dif_id(dv_sect_audio, chan, i, j/15, buf);
941  buf += 77; /* audio control & shuffled PCM audio */
942  }
943  buf += dv_write_dif_id(dv_sect_video, chan, i, j, buf);
944  buf += 77; /* 1 video macroblock: 1 bytes control
945  4 * 14 bytes Y 8x8 data
946  10 bytes Cr 8x8 data
947  10 bytes Cb 8x8 data */
948  }
949  }
950  }
951 }
952 
953 
954 static int dvvideo_encode_frame(AVCodecContext *c, AVPacket *pkt,
955  const AVFrame *frame, int *got_packet)
956 {
957  DVVideoContext *s = c->priv_data;
958  int ret;
959 
961  if (!s->sys || ff_dv_init_dynamic_tables(s->sys))
962  return -1;
963  if ((ret = ff_alloc_packet2(c, pkt, s->sys->frame_size)) < 0)
964  return ret;
965 
966  c->pix_fmt = s->sys->pix_fmt;
967  s->picture = *frame;
968  s->picture.key_frame = 1;
970 
971  s->buf = pkt->data;
973  dv_work_pool_size(s->sys), sizeof(DVwork_chunk));
974 
975  emms_c();
976 
977  dv_format_frame(s, pkt->data);
978 
979  pkt->flags |= AV_PKT_FLAG_KEY;
980  *got_packet = 1;
981 
982  return 0;
983 }
984 
985 AVCodec ff_dvvideo_encoder = {
986  .name = "dvvideo",
987  .long_name = NULL_IF_CONFIG_SMALL("DV (Digital Video)"),
988  .type = AVMEDIA_TYPE_VIDEO,
989  .id = AV_CODEC_ID_DVVIDEO,
990  .priv_data_size = sizeof(DVVideoContext),
992  .encode2 = dvvideo_encode_frame,
993  .capabilities = CODEC_CAP_SLICE_THREADS,
994  .pix_fmts = (const enum AVPixelFormat[]) {
996  },
997 };
998 #endif // CONFIG_DVVIDEO_ENCODER
int ff_alloc_packet2(AVCodecContext *avctx, AVPacket *avpkt, int64_t size)
Check AVPacket size and/or allocate data.
Definition: utils.c:1500
int table_size
Definition: get_bits.h:66
av_cold void ff_dsputil_init(DSPContext *c, AVCodecContext *avctx)
Definition: dsputil.c:2678
const char * s
Definition: avisynth_c.h:668
#define AVERROR_PATCHWELCOME
int size
void ff_dv_print_profiles(void *logctx, int loglevel)
Print all allowed DV profiles into logctx at specified logging level.
Definition: dv_profile.c:351
This structure describes decoded (raw) audio or video data.
Definition: frame.h:96
RL_VLC_ELEM ff_dv_rl_vlc[1184]
Definition: dv.c:52
#define av_always_inline
Definition: attributes.h:41
const int ff_dv_iweight_720_y[64]
Definition: dvdata.c:102
static void put_sbits(PutBitContext *pb, int n, int32_t value)
Definition: put_bits.h:180
void(* get_pixels)(int16_t *block, const uint8_t *pixels, int line_size)
Definition: dsputil.h:126
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
Definition: j2kenc.c:160
int ff_dv_init_dynamic_tables(const DVprofile *d)
Definition: dv.c:178
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
const uint8_t ff_zigzag248_direct[64]
Definition: dsputil.c:61
planar YUV 4:2:2, 16bpp, (1 Cr &amp; Cb sample per 2x1 Y samples)
Definition: avcodec.h:4538
static const uint8_t dv_vlc_run[NB_DV_VLC]
Definition: dv_vlc_data.h:149
const char * b
Definition: vf_curves.c:105
static av_always_inline int dv_rl2vlc(int run, int l, int sign, uint32_t *vlc)
Definition: dv.c:397
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:1860
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown) That is the width of a pixel divided by the height of the pixel...
Definition: avcodec.h:1517
void av_log(void *avcl, int level, const char *fmt,...) av_printf_format(3
Send the specified message to the log if the level is less than or equal to the current av_log_level...
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1342
static int dv_write_pack(enum dv_pack_type pack_id, DVVideoContext *c, uint8_t *buf)
Definition: dv.c:795
me_cmp_func ildct_cmp
Definition: dvdata.h:46
static void dv_calculate_mb_xy(DVVideoContext *s, DVwork_chunk *work_chunk, int m, int *mb_x, int *mb_y)
Definition: dvdata.h:113
static av_always_inline int dv_guess_dct_mode(DVVideoContext *s, uint8_t *data, int linesize)
Definition: dv.c:466
int ildct_cmp
interlaced DCT comparison function
Definition: avcodec.h:1542
dv_section_type
Definition: dvdata.h:49
uint8_t run
Definition: svq3.c:145
const uint8_t ff_dv_quant_offset[4]
Definition: dvdata.c:56
Pixel format.
Definition: avcodec.h:4533
#define blk(i)
Definition: sha.c:185
AVCodec.
Definition: avcodec.h:2922
#define av_cold
Definition: avcodec.h:653
uint8_t * buf
Definition: dvdata.h:39
#define DV_PROFILE_IS_720p50(p)
Definition: dvdata.h:84
if((e=av_dict_get(options,"", NULL, AV_DICT_IGNORE_SUFFIX)))
Definition: avfilter.c:965
static const int mb_area_start[5]
Definition: dv.c:352
static int dv_encode_video_segment(AVCodecContext *avctx, void *arg)
Definition: dv.c:664
AVCodecContext * avctx
Definition: dvdata.h:38
void(* idct_put)(uint8_t *dest, int line_size, int16_t *block)
block -&gt; idct -&gt; clip to unsigned 8 bit -&gt; dest.
Definition: dsputil.h:226
uint8_t
static void dv_guess_qnos(EncBlockInfo *blks, int *qnos)
Definition: dv.c:595
#define mb
void(* idct_put[2])(uint8_t *dest, int line_size, int16_t *block)
Definition: dvdata.h:45
static av_always_inline int dv_rl2vlc_size(int run, int l)
Definition: dv.c:403
#define emms_c()
Definition: internal.h:49
const char * name
Name of the codec implementation.
Definition: avcodec.h:2929
void ff_simple_idct248_put(uint8_t *dest, int line_size, int16_t *block)
Definition: simple_idct.c:92
enum AVPixelFormat pix_fmt
Definition: dv_profile.h:56
const char data[16]
Definition: mxf.c:68
static double av_q2d(AVRational a)
Convert rational to double.
Definition: rational.h:69
#define NB_DV_VLC
Definition: dv_vlc_data.h:32
void ff_set_cmp(DSPContext *c, me_cmp_func *cmp, int type)
Definition: dsputil.c:1872
static const int dv_weight_88[64]
Definition: dv.c:480
bitstream reader API header.
uint8_t idct_permutation[64]
idct input permutation.
Definition: dsputil.h:246
me_cmp_func ildct_cmp[6]
Definition: dsputil.h:167
int lowres
low resolution decoding, 1-&gt; 1/2 size, 2-&gt;1/4 size
Definition: avcodec.h:2580
const uint8_t * block_sizes
Definition: dv_profile.h:58
enum AVChromaLocation chroma_sample_location
This defines the location of chroma samples.
Definition: avcodec.h:1855
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: avcodec.h:1113
static AVFrame * frame
Definition: demuxing.c:51
#define LOCAL_ALIGNED_8(t, v,...)
Definition: internal.h:109
static int dv_work_pool_size(const DVprofile *d)
Definition: dvdata.h:103
#define U(x)
Definition: vp56_arith.h:37
void(* fdct248)(int16_t *block)
Definition: dsputil.h:216
int size_in_bits
Definition: put_bits.h:45
#define DV_PROFILE_IS_1080i50(p)
Definition: dvdata.h:83
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: avcodec.h:4147
uint8_t partial_bit_count
Definition: dv.c:419
static const int vs_total_ac_bits
Definition: dv.c:351
static int put_bits_left(PutBitContext *s)
Definition: put_bits.h:81
uint16_t mb_coordinates[5]
Definition: dv_profile.h:34
unsigned m
Definition: audioconvert.c:186
int height
Definition: dv_profile.h:51
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:151
#define DV_PROFILE_IS_HD(p)
Definition: dvdata.h:82
const char * arg
Definition: jacosubdec.c:69
static const int dv_weight_bits
Definition: dv.c:479
int flags
CODEC_FLAG_*.
Definition: avcodec.h:1234
uint32_t partial_bit_buffer
Definition: dv.c:420
planar YUV 4:1:1, 12bpp, (1 Cr &amp; Cb sample per 4x1 Y samples)
Definition: avcodec.h:4541
int cno
Definition: dv.c:414
int n_difchan
Definition: dv_profile.h:48
Libavcodec external API header.
AVPixelFormat
Pixel format.
Definition: pixfmt.h:66
int dct_mode
Definition: dv.c:415
int8_t len
Definition: get_bits.h:72
int flags
A combination of AV_PKT_FLAG values.
Definition: avcodec.h:1069
Definition: get_bits.h:63
int off
Definition: dsputil_bfin.c:29
static int put_bits_count(PutBitContext *s)
Definition: put_bits.h:73
int difseg_size
Definition: dv_profile.h:47
const DVprofile * sys
Definition: dvdata.h:36
common internal API header
const DVprofile * avpriv_dv_codec_profile(AVCodecContext *codec)
Definition: dv_profile.c:329
AVFrame picture
Definition: dvdata.h:37
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:167
float y
int cur_ac
Definition: dv.c:413
int width
Definition: dv_profile.h:52
uint32_t vlc
Definition: dv_tablegen.h:40
#define DV_VLC_MAP_RUN_SIZE
Definition: dv_tablegen.h:34
ret
Definition: avfilter.c:961
int width
picture width / height.
Definition: avcodec.h:1314
dv_pack_type
Definition: dvdata.h:57
uint8_t sign[64]
Definition: dv.c:418
#define a2
Definition: regdef.h:48
#define CODEC_FLAG_INTERLACED_DCT
Use interlaced DCT.
Definition: avcodec.h:711
int frame_size
Definition: dv_profile.h:46
static const uint8_t dv_vlc_len[NB_DV_VLC]
Definition: dv_vlc_data.h:94
static void dv_vlc_map_tableinit(void)
Definition: dv_tablegen.h:50
static const int dv_weight_248[64]
Definition: dv.c:490
int prev[5]
Definition: dv.c:412
void(* fdct[2])(int16_t *block)
Definition: dvdata.h:44
planar YUV 4:2:0, 12bpp, (1 Cr &amp; Cb sample per 2x2 Y samples)
Definition: avcodec.h:4534
static const int remap[16]
Definition: msvideo1enc.c:64
static const uint8_t zigzag_scan[16+1]
Definition: h264data.h:55
int bit_size[4]
Definition: dv.c:411
static const uint8_t dv100_qstep[16]
Definition: dv.c:170
main external API structure.
Definition: avcodec.h:1146
#define DV_VLC_MAP_LEV_SIZE
Definition: dv_tablegen.h:35
const int ff_dv_iweight_1080_y[64]
The &quot;inverse&quot; DV100 weights are actually just the spec weights (zig-zagged).
Definition: dvdata.c:82
#define init_vlc(vlc, nb_bits, nb_codes,bits, bits_wrap, bits_size,codes, codes_wrap, codes_size,flags)
Definition: get_bits.h:452
int16_t mb[64]
Definition: dv.c:416
const int ff_dv_iweight_248[64]
Definition: dvdata.c:68
void * buf
Definition: avisynth_c.h:594
uint8_t dv_zigzag[2][64]
Definition: dvdata.h:41
void(* get_pixels)(int16_t *block, const uint8_t *pixels, int line_size)
Definition: dvdata.h:43
static const uint8_t dv_vlc_level[NB_DV_VLC]
Definition: dv_vlc_data.h:204
void avcodec_get_frame_defaults(AVFrame *frame)
Set the fields of the given AVFrame to default values.
Definition: utils.c:1046
#define TEX_VLC_BITS
Definition: dvdata.h:96
AVFrame * coded_frame
the picture in the bitstream
Definition: avcodec.h:2588
uint8_t * data
Definition: avcodec.h:1063
av_cold int ff_dvvideo_init(AVCodecContext *avctx)
Definition: dv.c:239
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:124
#define DV_MAX_BPM
maximum number of blocks per macroblock in any DV format
Definition: dvdata.h:94
uint32_t size
Definition: dv_tablegen.h:41
static int weight(int i, int blen, int offset)
Definition: diracdec.c:1247
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:53
#define FFABS(a)
Definition: avcodec.h:920
void * priv_data
Definition: avcodec.h:1182
static const uint8_t dv_quant_areas[4]
Definition: dv.c:176
uint8_t level
Definition: svq3.c:146
uint8_t run
Definition: get_bits.h:73
uint32_t * idct_factor
Definition: dv_profile.h:55
const int ff_dv_iweight_88[64]
Definition: dvdata.c:58
const int ff_dv_iweight_1080_c[64]
Definition: dvdata.c:92
const uint8_t ff_dv_quant_shifts[22][4]
Definition: dvdata.c:31
static float t
Definition: muxing.c:123
#define CODEC_CAP_SLICE_THREADS
Codec supports slice-based (or partition-based) multithreading.
Definition: avcodec.h:815
common internal api header.
const uint8_t ff_zigzag_direct[64]
Definition: mathtables.c:115
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
Definition: put_bits.h:89
static double c[64]
static av_always_inline int dv_init_enc_block(EncBlockInfo *bi, uint8_t *data, int linesize, DVVideoContext *s, int bias)
Definition: dv.c:501
static void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)
Initialize the PutBitContext s.
Definition: put_bits.h:54
uint16_t buf_offset
Definition: dv_profile.h:33
static av_cold int dvvideo_init_encoder(AVCodecContext *avctx)
Definition: dv.c:331
int(* execute)(struct AVCodecContext *c, int(*func)(struct AVCodecContext *c2, void *arg), void *arg2, int *ret, int count, int size)
The codec may call this to execute several independent things.
Definition: avcodec.h:2636
int top_field_first
If the content is interlaced, is top field displayed first.
Definition: frame.h:298
simple idct header.
static void dv_calc_mb_coordinates(const DVprofile *d, int chan, int seq, int slot, uint16_t *tbl)
Definition: dv.c:54
int len
Constants for DV codec.
void(* fdct)(int16_t *block)
Definition: dsputil.h:215
int area_q[4]
Definition: dv.c:410
VLC_TYPE(* table)[2]
code, bits
Definition: get_bits.h:65
static const uint16_t dv_vlc_bits[NB_DV_VLC]
Definition: dv_vlc_data.h:39
int key_frame
1 -&gt; keyframe, 0-&gt; not
Definition: frame.h:162
#define AVERROR(e)
int16_t level
Definition: get_bits.h:71
const int ff_dv_iweight_720_c[64]
Definition: dvdata.c:112
int video_stype
Definition: dv_profile.h:45
#define LOCAL_ALIGNED_16(t, v,...)
Definition: internal.h:115
static AVPacket pkt
Definition: demuxing.c:52
static struct dv_vlc_pair dv_vlc_map[DV_VLC_MAP_RUN_SIZE][DV_VLC_MAP_LEV_SIZE]
Definition: dv_tablegen.h:48
DVwork_chunk * work_chunks
Definition: dv_profile.h:54
This structure stores compressed data.
Definition: avcodec.h:1040
void ff_free_vlc(VLC *vlc)
Definition: bitstream.c:353
uint8_t next[64]
Definition: dv.c:417
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:107
DSPContext.
Definition: dsputil.h:124
static av_always_inline PutBitContext * dv_encode_ac(EncBlockInfo *bi, PutBitContext *pb_pool, PutBitContext *pb_end)
Definition: dv.c:423
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
Definition: avassert.h:63
bitstream writer API