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 Libav.
20  *
21  * Libav 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  * Libav 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 Libav; if not, write to the Free Software
33  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
34  */
35 
41 #include "libavutil/pixdesc.h"
42 #include "avcodec.h"
43 #include "dsputil.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  assert(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  ff_dsputil_init(&dsp, avctx);
301  ff_set_cmp(&dsp, dsp.ildct_cmp, avctx->ildct_cmp);
302  s->get_pixels = dsp.get_pixels;
303  s->ildct_cmp = dsp.ildct_cmp[5];
304 
305  /* 88DCT setup */
306  s->fdct[0] = dsp.fdct;
307  s->idct_put[0] = dsp.idct_put;
308  for (i = 0; i < 64; i++)
309  s->dv_zigzag[0][i] = dsp.idct_permutation[ff_zigzag_direct[i]];
310 
311  /* 248DCT setup */
312  s->fdct[1] = dsp.fdct248;
313  s->idct_put[1] = ff_simple_idct248_put; // FIXME: need to add it to DSP
314  memcpy(s->dv_zigzag[1], ff_zigzag248_direct, 64);
315 
316  avctx->coded_frame = &s->picture;
317  s->avctx = avctx;
319 
320  return 0;
321 }
322 
324 {
325  if (!avpriv_dv_codec_profile(avctx)) {
326  av_log(avctx, AV_LOG_ERROR, "Found no DV profile for %ix%i %s video. "
327  "Valid DV profiles are:\n",
328  avctx->width, avctx->height, av_get_pix_fmt_name(avctx->pix_fmt));
330  return AVERROR(EINVAL);
331  }
332 
334 
335  return ff_dvvideo_init(avctx);
336 }
337 
338 /* bit budget for AC only in 5 MBs */
339 static const int vs_total_ac_bits = (100 * 4 + 68*2) * 5;
340 static const int mb_area_start[5] = { 1, 6, 21, 43, 64 };
341 
342 #if CONFIG_SMALL
343 /* Converts run and level (where level != 0) pair into VLC, returning bit size */
344 static av_always_inline int dv_rl2vlc(int run, int level, int sign, uint32_t* vlc)
345 {
346  int size;
347  if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {
348  *vlc = dv_vlc_map[run][level].vlc | sign;
349  size = dv_vlc_map[run][level].size;
350  }
351  else {
352  if (level < DV_VLC_MAP_LEV_SIZE) {
353  *vlc = dv_vlc_map[0][level].vlc | sign;
354  size = dv_vlc_map[0][level].size;
355  } else {
356  *vlc = 0xfe00 | (level << 1) | sign;
357  size = 16;
358  }
359  if (run) {
360  *vlc |= ((run < 16) ? dv_vlc_map[run-1][0].vlc :
361  (0x1f80 | (run - 1))) << size;
362  size += (run < 16) ? dv_vlc_map[run-1][0].size : 13;
363  }
364  }
365 
366  return size;
367 }
368 
369 static av_always_inline int dv_rl2vlc_size(int run, int level)
370 {
371  int size;
372 
373  if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {
374  size = dv_vlc_map[run][level].size;
375  }
376  else {
377  size = (level < DV_VLC_MAP_LEV_SIZE) ? dv_vlc_map[0][level].size : 16;
378  if (run) {
379  size += (run < 16) ? dv_vlc_map[run-1][0].size : 13;
380  }
381  }
382  return size;
383 }
384 #else
385 static av_always_inline int dv_rl2vlc(int run, int l, int sign, uint32_t* vlc)
386 {
387  *vlc = dv_vlc_map[run][l].vlc | sign;
388  return dv_vlc_map[run][l].size;
389 }
390 
391 static av_always_inline int dv_rl2vlc_size(int run, int l)
392 {
393  return dv_vlc_map[run][l].size;
394 }
395 #endif
396 
397 typedef struct EncBlockInfo {
398  int area_q[4];
399  int bit_size[4];
400  int prev[5];
401  int cur_ac;
402  int cno;
403  int dct_mode;
404  DCTELEM mb[64];
406  uint8_t sign[64];
408  uint32_t partial_bit_buffer; /* we can't use uint16_t here */
409 } EncBlockInfo;
410 
412  PutBitContext* pb_pool,
413  PutBitContext* pb_end)
414 {
415  int prev, bits_left;
416  PutBitContext* pb = pb_pool;
417  int size = bi->partial_bit_count;
418  uint32_t vlc = bi->partial_bit_buffer;
419 
421  for (;;){
422  /* Find suitable storage space */
423  for (; size > (bits_left = put_bits_left(pb)); pb++) {
424  if (bits_left) {
425  size -= bits_left;
426  put_bits(pb, bits_left, vlc >> size);
427  vlc = vlc & ((1 << size) - 1);
428  }
429  if (pb + 1 >= pb_end) {
430  bi->partial_bit_count = size;
431  bi->partial_bit_buffer = vlc;
432  return pb;
433  }
434  }
435 
436  /* Store VLC */
437  put_bits(pb, size, vlc);
438 
439  if (bi->cur_ac >= 64)
440  break;
441 
442  /* Construct the next VLC */
443  prev = bi->cur_ac;
444  bi->cur_ac = bi->next[prev];
445  if (bi->cur_ac < 64){
446  size = dv_rl2vlc(bi->cur_ac - prev - 1, bi->mb[bi->cur_ac], bi->sign[bi->cur_ac], &vlc);
447  } else {
448  size = 4; vlc = 6; /* End Of Block stamp */
449  }
450  }
451  return pb;
452 }
453 
456  int ps = s->ildct_cmp(NULL, data, NULL, linesize, 8) - 400;
457  if (ps > 0) {
458  int is = s->ildct_cmp(NULL, data , NULL, linesize<<1, 4) +
459  s->ildct_cmp(NULL, data + linesize, NULL, linesize<<1, 4);
460  return ps > is;
461  }
462  }
463 
464  return 0;
465 }
466 
467 static const int dv_weight_bits = 18;
468 static const int dv_weight_88[64] = {
469  131072, 257107, 257107, 242189, 252167, 242189, 235923, 237536,
470  237536, 235923, 229376, 231390, 223754, 231390, 229376, 222935,
471  224969, 217965, 217965, 224969, 222935, 200636, 218652, 211916,
472  212325, 211916, 218652, 200636, 188995, 196781, 205965, 206433,
473  206433, 205965, 196781, 188995, 185364, 185364, 200636, 200704,
474  200636, 185364, 185364, 174609, 180568, 195068, 195068, 180568,
475  174609, 170091, 175557, 189591, 175557, 170091, 165371, 170627,
476  170627, 165371, 160727, 153560, 160727, 144651, 144651, 136258,
477 };
478 static const int dv_weight_248[64] = {
479  131072, 242189, 257107, 237536, 229376, 200636, 242189, 223754,
480  224969, 196781, 262144, 242189, 229376, 200636, 257107, 237536,
481  211916, 185364, 235923, 217965, 229376, 211916, 206433, 180568,
482  242189, 223754, 224969, 196781, 211916, 185364, 235923, 217965,
483  200704, 175557, 222935, 205965, 200636, 185364, 195068, 170627,
484  229376, 211916, 206433, 180568, 200704, 175557, 222935, 205965,
485  175557, 153560, 188995, 174609, 165371, 144651, 200636, 185364,
486  195068, 170627, 175557, 153560, 188995, 174609, 165371, 144651,
487 };
488 
489 static av_always_inline int dv_init_enc_block(EncBlockInfo* bi, uint8_t *data, int linesize, DVVideoContext *s, int bias)
490 {
491  const int *weight;
492  const uint8_t* zigzag_scan;
493  LOCAL_ALIGNED_16(DCTELEM, blk, [64]);
494  int i, area;
495  /* We offer two different methods for class number assignment: the
496  method suggested in SMPTE 314M Table 22, and an improved
497  method. The SMPTE method is very conservative; it assigns class
498  3 (i.e. severe quantization) to any block where the largest AC
499  component is greater than 36. Libav's DV encoder tracks AC bit
500  consumption precisely, so there is no need to bias most blocks
501  towards strongly lossy compression. Instead, we assign class 2
502  to most blocks, and use class 3 only when strictly necessary
503  (for blocks whose largest AC component exceeds 255). */
504 
505 #if 0 /* SMPTE spec method */
506  static const int classes[] = {12, 24, 36, 0xffff};
507 #else /* improved Libav method */
508  static const int classes[] = {-1, -1, 255, 0xffff};
509 #endif
510  int max = classes[0];
511  int prev = 0;
512 
513  assert((((int)blk) & 15) == 0);
514 
515  bi->area_q[0] = bi->area_q[1] = bi->area_q[2] = bi->area_q[3] = 0;
516  bi->partial_bit_count = 0;
517  bi->partial_bit_buffer = 0;
518  bi->cur_ac = 0;
519  if (data) {
520  bi->dct_mode = dv_guess_dct_mode(s, data, linesize);
521  s->get_pixels(blk, data, linesize);
522  s->fdct[bi->dct_mode](blk);
523  } else {
524  /* We rely on the fact that encoding all zeros leads to an immediate EOB,
525  which is precisely what the spec calls for in the "dummy" blocks. */
526  memset(blk, 0, 64*sizeof(*blk));
527  bi->dct_mode = 0;
528  }
529  bi->mb[0] = blk[0];
530 
531  zigzag_scan = bi->dct_mode ? ff_zigzag248_direct : ff_zigzag_direct;
532  weight = bi->dct_mode ? dv_weight_248 : dv_weight_88;
533 
534  for (area = 0; area < 4; area++) {
535  bi->prev[area] = prev;
536  bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
537  for (i = mb_area_start[area]; i < mb_area_start[area+1]; i++) {
538  int level = blk[zigzag_scan[i]];
539 
540  if (level + 15 > 30U) {
541  bi->sign[i] = (level >> 31) & 1;
542  /* weight it and and shift down into range, adding for rounding */
543  /* the extra division by a factor of 2^4 reverses the 8x expansion of the DCT
544  AND the 2x doubling of the weights */
545  level = (FFABS(level) * weight[i] + (1 << (dv_weight_bits+3))) >> (dv_weight_bits+4);
546  bi->mb[i] = level;
547  if (level > max)
548  max = level;
549  bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, level);
550  bi->next[prev]= i;
551  prev = i;
552  }
553  }
554  }
555  bi->next[prev]= i;
556  for (bi->cno = 0; max > classes[bi->cno]; bi->cno++);
557 
558  bi->cno += bias;
559 
560  if (bi->cno >= 3) {
561  bi->cno = 3;
562  prev = 0;
563  i = bi->next[prev];
564  for (area = 0; area < 4; area++) {
565  bi->prev[area] = prev;
566  bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
567  for (; i < mb_area_start[area+1]; i = bi->next[i]) {
568  bi->mb[i] >>= 1;
569 
570  if (bi->mb[i]) {
571  bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, bi->mb[i]);
572  bi->next[prev]= i;
573  prev = i;
574  }
575  }
576  }
577  bi->next[prev]= i;
578  }
579 
580  return bi->bit_size[0] + bi->bit_size[1] + bi->bit_size[2] + bi->bit_size[3];
581 }
582 
583 static inline void dv_guess_qnos(EncBlockInfo* blks, int* qnos)
584 {
585  int size[5];
586  int i, j, k, a, prev, a2;
587  EncBlockInfo* b;
588 
589  size[0] = size[1] = size[2] = size[3] = size[4] = 1 << 24;
590  do {
591  b = blks;
592  for (i = 0; i < 5; i++) {
593  if (!qnos[i])
594  continue;
595 
596  qnos[i]--;
597  size[i] = 0;
598  for (j = 0; j < 6; j++, b++) {
599  for (a = 0; a < 4; a++) {
600  if (b->area_q[a] != ff_dv_quant_shifts[qnos[i] + ff_dv_quant_offset[b->cno]][a]) {
601  b->bit_size[a] = 1; // 4 areas 4 bits for EOB :)
602  b->area_q[a]++;
603  prev = b->prev[a];
604  assert(b->next[prev] >= mb_area_start[a+1] || b->mb[prev]);
605  for (k = b->next[prev] ; k < mb_area_start[a+1]; k = b->next[k]) {
606  b->mb[k] >>= 1;
607  if (b->mb[k]) {
608  b->bit_size[a] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
609  prev = k;
610  } else {
611  if (b->next[k] >= mb_area_start[a+1] && b->next[k]<64){
612  for (a2 = a + 1; b->next[k] >= mb_area_start[a2+1]; a2++)
613  b->prev[a2] = prev;
614  assert(a2 < 4);
615  assert(b->mb[b->next[k]]);
616  b->bit_size[a2] += dv_rl2vlc_size(b->next[k] - prev - 1, b->mb[b->next[k]])
617  -dv_rl2vlc_size(b->next[k] - k - 1, b->mb[b->next[k]]);
618  assert(b->prev[a2] == k && (a2 + 1 >= 4 || b->prev[a2+1] != k));
619  b->prev[a2] = prev;
620  }
621  b->next[prev] = b->next[k];
622  }
623  }
624  b->prev[a+1]= prev;
625  }
626  size[i] += b->bit_size[a];
627  }
628  }
629  if (vs_total_ac_bits >= size[0] + size[1] + size[2] + size[3] + size[4])
630  return;
631  }
632  } while (qnos[0]|qnos[1]|qnos[2]|qnos[3]|qnos[4]);
633 
634 
635  for (a = 2; a == 2 || vs_total_ac_bits < size[0]; a += a){
636  b = blks;
637  size[0] = 5 * 6 * 4; //EOB
638  for (j = 0; j < 6 *5; j++, b++) {
639  prev = b->prev[0];
640  for (k = b->next[prev]; k < 64; k = b->next[k]) {
641  if (b->mb[k] < a && b->mb[k] > -a){
642  b->next[prev] = b->next[k];
643  }else{
644  size[0] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
645  prev = k;
646  }
647  }
648  }
649  }
650 }
651 
652 static int dv_encode_video_segment(AVCodecContext *avctx, void *arg)
653 {
654  DVVideoContext *s = avctx->priv_data;
655  DVwork_chunk *work_chunk = arg;
656  int mb_index, i, j;
657  int mb_x, mb_y, c_offset, linesize, y_stride;
658  uint8_t* y_ptr;
659  uint8_t* dif;
660  LOCAL_ALIGNED_8(uint8_t, scratch, [128]);
661  EncBlockInfo enc_blks[5*DV_MAX_BPM];
662  PutBitContext pbs[5*DV_MAX_BPM];
663  PutBitContext* pb;
664  EncBlockInfo* enc_blk;
665  int vs_bit_size = 0;
666  int qnos[5] = {15, 15, 15, 15, 15}; /* No quantization */
667  int* qnosp = &qnos[0];
668 
669  dif = &s->buf[work_chunk->buf_offset*80];
670  enc_blk = &enc_blks[0];
671  for (mb_index = 0; mb_index < 5; mb_index++) {
672  dv_calculate_mb_xy(s, work_chunk, mb_index, &mb_x, &mb_y);
673 
674  /* initializing luminance blocks */
675  if ((s->sys->pix_fmt == AV_PIX_FMT_YUV420P) ||
676  (s->sys->pix_fmt == AV_PIX_FMT_YUV411P && mb_x >= (704 / 8)) ||
677  (s->sys->height >= 720 && mb_y != 134)) {
678  y_stride = s->picture.linesize[0] << 3;
679  } else {
680  y_stride = 16;
681  }
682  y_ptr = s->picture.data[0] + ((mb_y * s->picture.linesize[0] + mb_x) << 3);
683  linesize = s->picture.linesize[0];
684 
685  if (s->sys->video_stype == 4) { /* SD 422 */
686  vs_bit_size +=
687  dv_init_enc_block(enc_blk+0, y_ptr , linesize, s, 0) +
688  dv_init_enc_block(enc_blk+1, NULL , linesize, s, 0) +
689  dv_init_enc_block(enc_blk+2, y_ptr + 8 , linesize, s, 0) +
690  dv_init_enc_block(enc_blk+3, NULL , linesize, s, 0);
691  } else {
692  vs_bit_size +=
693  dv_init_enc_block(enc_blk+0, y_ptr , linesize, s, 0) +
694  dv_init_enc_block(enc_blk+1, y_ptr + 8 , linesize, s, 0) +
695  dv_init_enc_block(enc_blk+2, y_ptr + y_stride, linesize, s, 0) +
696  dv_init_enc_block(enc_blk+3, y_ptr + 8 + y_stride, linesize, s, 0);
697  }
698  enc_blk += 4;
699 
700  /* initializing chrominance blocks */
701  c_offset = (((mb_y >> (s->sys->pix_fmt == AV_PIX_FMT_YUV420P)) * s->picture.linesize[1] +
702  (mb_x >> ((s->sys->pix_fmt == AV_PIX_FMT_YUV411P) ? 2 : 1))) << 3);
703  for (j = 2; j; j--) {
704  uint8_t *c_ptr = s->picture.data[j] + c_offset;
705  linesize = s->picture.linesize[j];
706  y_stride = (mb_y == 134) ? 8 : (s->picture.linesize[j] << 3);
707  if (s->sys->pix_fmt == AV_PIX_FMT_YUV411P && mb_x >= (704 / 8)) {
708  uint8_t* d;
709  uint8_t* b = scratch;
710  for (i = 0; i < 8; i++) {
711  d = c_ptr + (linesize << 3);
712  b[0] = c_ptr[0]; b[1] = c_ptr[1]; b[2] = c_ptr[2]; b[3] = c_ptr[3];
713  b[4] = d[0]; b[5] = d[1]; b[6] = d[2]; b[7] = d[3];
714  c_ptr += linesize;
715  b += 16;
716  }
717  c_ptr = scratch;
718  linesize = 16;
719  }
720 
721  vs_bit_size += dv_init_enc_block( enc_blk++, c_ptr , linesize, s, 1);
722  if (s->sys->bpm == 8) {
723  vs_bit_size += dv_init_enc_block(enc_blk++, c_ptr + y_stride, linesize, s, 1);
724  }
725  }
726  }
727 
728  if (vs_total_ac_bits < vs_bit_size)
729  dv_guess_qnos(&enc_blks[0], qnosp);
730 
731  /* DIF encoding process */
732  for (j=0; j<5*s->sys->bpm;) {
733  int start_mb = j;
734 
735  dif[3] = *qnosp++;
736  dif += 4;
737 
738  /* First pass over individual cells only */
739  for (i=0; i<s->sys->bpm; i++, j++) {
740  int sz = s->sys->block_sizes[i]>>3;
741 
742  init_put_bits(&pbs[j], dif, sz);
743  put_sbits(&pbs[j], 9, ((enc_blks[j].mb[0] >> 3) - 1024 + 2) >> 2);
744  put_bits(&pbs[j], 1, enc_blks[j].dct_mode);
745  put_bits(&pbs[j], 2, enc_blks[j].cno);
746 
747  dv_encode_ac(&enc_blks[j], &pbs[j], &pbs[j+1]);
748  dif += sz;
749  }
750 
751  /* Second pass over each MB space */
752  pb = &pbs[start_mb];
753  for (i=0; i<s->sys->bpm; i++) {
754  if (enc_blks[start_mb+i].partial_bit_count)
755  pb = dv_encode_ac(&enc_blks[start_mb+i], pb, &pbs[start_mb+s->sys->bpm]);
756  }
757  }
758 
759  /* Third and final pass over the whole video segment space */
760  pb = &pbs[0];
761  for (j=0; j<5*s->sys->bpm; j++) {
762  if (enc_blks[j].partial_bit_count)
763  pb = dv_encode_ac(&enc_blks[j], pb, &pbs[s->sys->bpm*5]);
764  if (enc_blks[j].partial_bit_count)
765  av_log(avctx, AV_LOG_ERROR, "ac bitstream overflow\n");
766  }
767 
768  for (j=0; j<5*s->sys->bpm; j++) {
769  int pos;
770  int size = pbs[j].size_in_bits >> 3;
771  flush_put_bits(&pbs[j]);
772  pos = put_bits_count(&pbs[j]) >> 3;
773  if (pos > size) {
774  av_log(avctx, AV_LOG_ERROR, "bitstream written beyond buffer size\n");
775  return -1;
776  }
777  memset(pbs[j].buf + pos, 0xff, size - pos);
778  }
779 
780  return 0;
781 }
782 
783 static inline int dv_write_pack(enum dv_pack_type pack_id, DVVideoContext *c,
784  uint8_t* buf)
785 {
786  /*
787  * Here's what SMPTE314M says about these two:
788  * (page 6) APTn, AP1n, AP2n, AP3n: These data shall be identical
789  * as track application IDs (APTn = 001, AP1n =
790  * 001, AP2n = 001, AP3n = 001), if the source signal
791  * comes from a digital VCR. If the signal source is
792  * unknown, all bits for these data shall be set to 1.
793  * (page 12) STYPE: STYPE defines a signal type of video signal
794  * 00000b = 4:1:1 compression
795  * 00100b = 4:2:2 compression
796  * XXXXXX = Reserved
797  * Now, I've got two problems with these statements:
798  * 1. it looks like APT == 111b should be a safe bet, but it isn't.
799  * It seems that for PAL as defined in IEC 61834 we have to set
800  * APT to 000 and for SMPTE314M to 001.
801  * 2. It is not at all clear what STYPE is used for 4:2:0 PAL
802  * compression scheme (if any).
803  */
804  int apt = (c->sys->pix_fmt == AV_PIX_FMT_YUV420P ? 0 : 1);
805 
806  uint8_t aspect = 0;
807  if ((int)(av_q2d(c->avctx->sample_aspect_ratio) * c->avctx->width / c->avctx->height * 10) >= 17) /* 16:9 */
808  aspect = 0x02;
809 
810  buf[0] = (uint8_t)pack_id;
811  switch (pack_id) {
812  case dv_header525: /* I can't imagine why these two weren't defined as real */
813  case dv_header625: /* packs in SMPTE314M -- they definitely look like ones */
814  buf[1] = 0xf8 | /* reserved -- always 1 */
815  (apt & 0x07); /* APT: Track application ID */
816  buf[2] = (0 << 7) | /* TF1: audio data is 0 - valid; 1 - invalid */
817  (0x0f << 3) | /* reserved -- always 1 */
818  (apt & 0x07); /* AP1: Audio application ID */
819  buf[3] = (0 << 7) | /* TF2: video data is 0 - valid; 1 - invalid */
820  (0x0f << 3) | /* reserved -- always 1 */
821  (apt & 0x07); /* AP2: Video application ID */
822  buf[4] = (0 << 7) | /* TF3: subcode(SSYB) is 0 - valid; 1 - invalid */
823  (0x0f << 3) | /* reserved -- always 1 */
824  (apt & 0x07); /* AP3: Subcode application ID */
825  break;
826  case dv_video_source:
827  buf[1] = 0xff; /* reserved -- always 1 */
828  buf[2] = (1 << 7) | /* B/W: 0 - b/w, 1 - color */
829  (1 << 6) | /* following CLF is valid - 0, invalid - 1 */
830  (3 << 4) | /* CLF: color frames ID (see ITU-R BT.470-4) */
831  0xf; /* reserved -- always 1 */
832  buf[3] = (3 << 6) | /* reserved -- always 1 */
833  (c->sys->dsf << 5) | /* system: 60fields/50fields */
834  c->sys->video_stype; /* signal type video compression */
835  buf[4] = 0xff; /* VISC: 0xff -- no information */
836  break;
837  case dv_video_control:
838  buf[1] = (0 << 6) | /* Copy generation management (CGMS) 0 -- free */
839  0x3f; /* reserved -- always 1 */
840  buf[2] = 0xc8 | /* reserved -- always b11001xxx */
841  aspect;
842  buf[3] = (1 << 7) | /* frame/field flag 1 -- frame, 0 -- field */
843  (1 << 6) | /* first/second field flag 0 -- field 2, 1 -- field 1 */
844  (1 << 5) | /* frame change flag 0 -- same picture as before, 1 -- different */
845  (1 << 4) | /* 1 - interlaced, 0 - noninterlaced */
846  0xc; /* reserved -- always b1100 */
847  buf[4] = 0xff; /* reserved -- always 1 */
848  break;
849  default:
850  buf[1] = buf[2] = buf[3] = buf[4] = 0xff;
851  }
852  return 5;
853 }
854 
855 #if CONFIG_DVVIDEO_ENCODER
856 static inline int dv_write_dif_id(enum dv_section_type t, uint8_t chan_num,
857  uint8_t seq_num, uint8_t dif_num,
858  uint8_t* buf)
859 {
860  buf[0] = (uint8_t)t; /* Section type */
861  buf[1] = (seq_num << 4) | /* DIF seq number 0-9 for 525/60; 0-11 for 625/50 */
862  (chan_num << 3) | /* FSC: for 50Mb/s 0 - first channel; 1 - second */
863  7; /* reserved -- always 1 */
864  buf[2] = dif_num; /* DIF block number Video: 0-134, Audio: 0-8 */
865  return 3;
866 }
867 
868 
869 static inline int dv_write_ssyb_id(uint8_t syb_num, uint8_t fr, uint8_t* buf)
870 {
871  if (syb_num == 0 || syb_num == 6) {
872  buf[0] = (fr << 7) | /* FR ID 1 - first half of each channel; 0 - second */
873  (0 << 4) | /* AP3 (Subcode application ID) */
874  0x0f; /* reserved -- always 1 */
875  }
876  else if (syb_num == 11) {
877  buf[0] = (fr << 7) | /* FR ID 1 - first half of each channel; 0 - second */
878  0x7f; /* reserved -- always 1 */
879  }
880  else {
881  buf[0] = (fr << 7) | /* FR ID 1 - first half of each channel; 0 - second */
882  (0 << 4) | /* APT (Track application ID) */
883  0x0f; /* reserved -- always 1 */
884  }
885  buf[1] = 0xf0 | /* reserved -- always 1 */
886  (syb_num & 0x0f); /* SSYB number 0 - 11 */
887  buf[2] = 0xff; /* reserved -- always 1 */
888  return 3;
889 }
890 
891 static void dv_format_frame(DVVideoContext* c, uint8_t* buf)
892 {
893  int chan, i, j, k;
894 
895  for (chan = 0; chan < c->sys->n_difchan; chan++) {
896  for (i = 0; i < c->sys->difseg_size; i++) {
897  memset(buf, 0xff, 80 * 6); /* first 6 DIF blocks are for control data */
898 
899  /* DV header: 1DIF */
900  buf += dv_write_dif_id(dv_sect_header, chan, i, 0, buf);
901  buf += dv_write_pack((c->sys->dsf ? dv_header625 : dv_header525), c, buf);
902  buf += 72; /* unused bytes */
903 
904  /* DV subcode: 2DIFs */
905  for (j = 0; j < 2; j++) {
906  buf += dv_write_dif_id(dv_sect_subcode, chan, i, j, buf);
907  for (k = 0; k < 6; k++)
908  buf += dv_write_ssyb_id(k, (i < c->sys->difseg_size/2), buf) + 5;
909  buf += 29; /* unused bytes */
910  }
911 
912  /* DV VAUX: 3DIFS */
913  for (j = 0; j < 3; j++) {
914  buf += dv_write_dif_id(dv_sect_vaux, chan, i, j, buf);
915  buf += dv_write_pack(dv_video_source, c, buf);
916  buf += dv_write_pack(dv_video_control, c, buf);
917  buf += 7*5;
918  buf += dv_write_pack(dv_video_source, c, buf);
919  buf += dv_write_pack(dv_video_control, c, buf);
920  buf += 4*5 + 2; /* unused bytes */
921  }
922 
923  /* DV Audio/Video: 135 Video DIFs + 9 Audio DIFs */
924  for (j = 0; j < 135; j++) {
925  if (j%15 == 0) {
926  memset(buf, 0xff, 80);
927  buf += dv_write_dif_id(dv_sect_audio, chan, i, j/15, buf);
928  buf += 77; /* audio control & shuffled PCM audio */
929  }
930  buf += dv_write_dif_id(dv_sect_video, chan, i, j, buf);
931  buf += 77; /* 1 video macroblock: 1 bytes control
932  4 * 14 bytes Y 8x8 data
933  10 bytes Cr 8x8 data
934  10 bytes Cb 8x8 data */
935  }
936  }
937  }
938 }
939 
940 
941 static int dvvideo_encode_frame(AVCodecContext *c, AVPacket *pkt,
942  const AVFrame *frame, int *got_packet)
943 {
944  DVVideoContext *s = c->priv_data;
945  int ret;
946 
948  if (!s->sys || ff_dv_init_dynamic_tables(s->sys))
949  return -1;
950  if ((ret = ff_alloc_packet(pkt, s->sys->frame_size)) < 0) {
951  av_log(c, AV_LOG_ERROR, "Error getting output packet.\n");
952  return ret;
953  }
954 
955  c->pix_fmt = s->sys->pix_fmt;
956  s->picture = *frame;
957  s->picture.key_frame = 1;
959 
960  s->buf = pkt->data;
962  dv_work_pool_size(s->sys), sizeof(DVwork_chunk));
963 
964  emms_c();
965 
966  dv_format_frame(s, pkt->data);
967 
968  pkt->flags |= AV_PKT_FLAG_KEY;
969  *got_packet = 1;
970 
971  return 0;
972 }
973 
974 AVCodec ff_dvvideo_encoder = {
975  .name = "dvvideo",
976  .type = AVMEDIA_TYPE_VIDEO,
977  .id = AV_CODEC_ID_DVVIDEO,
978  .priv_data_size = sizeof(DVVideoContext),
980  .encode2 = dvvideo_encode_frame,
981  .capabilities = CODEC_CAP_SLICE_THREADS,
982  .pix_fmts = (const enum AVPixelFormat[]) {
984  },
985  .long_name = NULL_IF_CONFIG_SMALL("DV (Digital Video)"),
986 };
987 #endif // CONFIG_DVVIDEO_ENCODER
#define LOCAL_ALIGNED_8(t, v,...)
Definition: dsputil.h:596
int table_size
Definition: get_bits.h:66
av_cold void ff_dsputil_init(DSPContext *c, AVCodecContext *avctx)
Definition: dsputil.c:2656
const uint8_t ff_zigzag_direct[64]
Definition: dsputil.c:59
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:323
This structure describes decoded (raw) audio or video data.
Definition: avcodec.h:989
RL_VLC_ELEM ff_dv_rl_vlc[1184]
Definition: dv.c:52
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:174
int ff_dv_init_dynamic_tables(const DVprofile *d)
Definition: dv.c:178
AVFrame * coded_frame
the picture in the bitstream
Definition: avcodec.h:2725
const uint8_t ff_zigzag248_direct[64]
Definition: dsputil.c:72
static const uint8_t dv_vlc_run[NB_DV_VLC]
Definition: dv_vlc_data.h:149
struct DVVideoContext DVVideoContext
static av_always_inline int dv_rl2vlc(int run, int l, int sign, uint32_t *vlc)
Definition: dv.c:385
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:1724
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1533
static int dv_write_pack(enum dv_pack_type pack_id, DVVideoContext *c, uint8_t *buf)
Definition: dv.c:783
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:117
static av_always_inline int dv_guess_dct_mode(DVVideoContext *s, uint8_t *data, int linesize)
Definition: dv.c:454
int ildct_cmp
interlaced DCT comparison function
Definition: avcodec.h:1749
dv_section_type
Definition: dvdata.h:49
uint8_t run
Definition: svq3.c:124
const uint8_t ff_dv_quant_offset[4]
Definition: dvdata.c:56
#define blk(i)
Definition: sha.c:171
AVCodec.
Definition: avcodec.h:2960
static const uint8_t zigzag_scan[16]
Definition: h264data.h:55
uint8_t * buf
Definition: dvdata.h:39
#define DV_PROFILE_IS_720p50(p)
Definition: dvdata.h:84
static const int mb_area_start[5]
Definition: dv.c:340
static int dv_encode_video_segment(AVCodecContext *avctx, void *arg)
Definition: dv.c:652
AVCodecContext * avctx
Definition: dvdata.h:38
uint8_t
static void dv_guess_qnos(EncBlockInfo *blks, int *qnos)
Definition: dv.c:583
void(* get_pixels)(DCTELEM *block, const uint8_t *pixels, int line_size)
Definition: dsputil.h:201
#define b
Definition: input.c:52
static av_always_inline int dv_rl2vlc_size(int run, int l)
Definition: dv.c:391
void(* get_pixels)(DCTELEM *block, const uint8_t *pixels, int line_size)
Definition: dvdata.h:43
#define emms_c()
Definition: internal.h:145
enum AVPixelFormat pix_fmt
Definition: dv_profile.h:52
const char data[16]
Definition: mxf.c:66
static double av_q2d(AVRational a)
Convert rational to double.
Definition: rational.h:69
uint8_t * data
Definition: avcodec.h:915
#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:1741
static const int dv_weight_88[64]
Definition: dv.c:468
bitstream reader API header.
uint8_t idct_permutation[64]
idct input permutation.
Definition: dsputil.h:425
me_cmp_func ildct_cmp[6]
Definition: dsputil.h:243
#define LOCAL_ALIGNED_16(t, v,...)
Definition: dsputil.h:602
const uint8_t * block_sizes
Definition: dv_profile.h:54
enum AVChromaLocation chroma_sample_location
This defines the location of chroma samples.
Definition: avcodec.h:2086
static float t
static int init(AVCodecParserContext *s)
Definition: h264_parser.c:335
static int dv_work_pool_size(const DVprofile *d)
Definition: dvdata.h:107
int size_in_bits
Definition: put_bits.h:43
#define DV_PROFILE_IS_1080i50(p)
Definition: dvdata.h:83
uint8_t partial_bit_count
Definition: dv.c:407
static const int vs_total_ac_bits
Definition: dv.c:339
static int put_bits_left(PutBitContext *s)
Definition: put_bits.h:78
uint16_t mb_coordinates[5]
Definition: dv_profile.h:30
void(* idct_put[2])(uint8_t *dest, int line_size, DCTELEM *block)
Definition: dvdata.h:45
int height
Definition: dv_profile.h:47
void(* idct_put)(uint8_t *dest, int line_size, DCTELEM *block)
block -> idct -> clip to unsigned 8 bit -> dest.
Definition: dsputil.h:405
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:88
#define DV_PROFILE_IS_HD(p)
Definition: dvdata.h:82
static const int dv_weight_bits
Definition: dv.c:467
int flags
CODEC_FLAG_*.
Definition: avcodec.h:1434
uint32_t partial_bit_buffer
Definition: dv.c:408
void av_log(void *avcl, int level, const char *fmt,...)
Definition: log.c:146
int cno
Definition: dv.c:402
const char * name
Name of the codec implementation.
Definition: avcodec.h:2967
static void put_bits(PutBitContext *s, int n, unsigned int value)
Write up to 31 bits into a bitstream.
Definition: put_bits.h:136
int n_difchan
Definition: dv_profile.h:44
void ff_simple_idct248_put(uint8_t *dest, int line_size, DCTELEM *block)
Definition: simple_idct.c:89
int dct_mode
Definition: dv.c:403
int8_t len
Definition: get_bits.h:71
int flags
A combination of AV_PKT_FLAG values.
Definition: avcodec.h:921
Definition: get_bits.h:63
int off
Definition: dsputil_bfin.c:28
static int put_bits_count(PutBitContext *s)
Definition: put_bits.h:70
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
Definition: pixfmt.h:69
int difseg_size
Definition: dv_profile.h:43
const DVprofile * sys
Definition: dvdata.h:36
const DVprofile * avpriv_dv_codec_profile(AVCodecContext *codec)
Definition: dv_profile.c:310
AVFrame picture
Definition: dvdata.h:37
enum AVPictureType pict_type
Picture type of the frame, see ?_TYPE below.
Definition: avcodec.h:1065
struct EncBlockInfo EncBlockInfo
int cur_ac
Definition: dv.c:401
int width
Definition: dv_profile.h:48
uint32_t vlc
Definition: dv_tablegen.h:40
#define DV_VLC_MAP_RUN_SIZE
Definition: dv_tablegen.h:34
void(* fdct248)(DCTELEM *block)
Definition: dsputil.h:395
int width
picture width / height.
Definition: avcodec.h:1508
dv_pack_type
Definition: dvdata.h:57
uint8_t sign[64]
Definition: dv.c:406
#define a2
Definition: regdef.h:48
int ff_alloc_packet(AVPacket *avpkt, int size)
Check AVPacket size and/or allocate data.
Definition: utils.c:878
int frame_size
Definition: dv_profile.h:42
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:478
int prev[5]
Definition: dv.c:400
NULL
Definition: eval.c:52
external API header
int linesize[AV_NUM_DATA_POINTERS]
Size, in bytes, of the data for each picture/channel plane.
Definition: avcodec.h:1008
int bit_size[4]
Definition: dv.c:399
static const uint8_t dv100_qstep[16]
Definition: dv.c:170
main external API structure.
Definition: avcodec.h:1339
void(* fdct[2])(DCTELEM *block)
Definition: dvdata.h:44
#define DV_VLC_MAP_LEV_SIZE
Definition: dv_tablegen.h:35
const int ff_dv_iweight_1080_y[64]
The "inverse" 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:418
const int ff_dv_iweight_248[64]
Definition: dvdata.c:68
uint8_t dv_zigzag[2][64]
Definition: dvdata.h:41
static const uint8_t dv_vlc_level[NB_DV_VLC]
Definition: dv_vlc_data.h:204
#define TEX_VLC_BITS
Definition: dvdata.h:100
av_cold int ff_dvvideo_init(AVCodecContext *avctx)
Definition: dv.c:239
#define DV_MAX_BPM
maximum number of blocks per macroblock in any DV format
Definition: dvdata.h:98
uint32_t size
Definition: dv_tablegen.h:41
short DCTELEM
Definition: dsputil.h:39
DCTELEM mb[64]
Definition: dv.c:404
static const uint8_t dv_quant_areas[4]
Definition: dv.c:176
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: avcodec.h:997
uint8_t level
Definition: svq3.c:125
Definition: vf_drawbox.c:36
uint8_t run
Definition: get_bits.h:72
uint32_t * idct_factor
Definition: dv_profile.h:51
const int ff_dv_iweight_88[64]
Definition: dvdata.c:58
const int ff_dv_iweight_1080_c[64]
Definition: dvdata.c:92
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:65
const uint8_t ff_dv_quant_shifts[22][4]
Definition: dvdata.c:31
common internal api header.
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
Definition: put_bits.h:86
void(* fdct)(DCTELEM *block)
Definition: dsputil.h:394
static av_always_inline int dv_init_enc_block(EncBlockInfo *bi, uint8_t *data, int linesize, DVVideoContext *s, int bias)
Definition: dv.c:489
planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples)
Definition: pixfmt.h:72
static void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)
Initialize the PutBitContext s.
Definition: put_bits.h:52
DSP utils.
uint16_t buf_offset
Definition: dv_profile.h:29
static av_cold int dvvideo_init_encoder(AVCodecContext *avctx)
Definition: dv.c:323
void * priv_data
Definition: avcodec.h:1382
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:2773
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.
int area_q[4]
Definition: dv.c:398
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 -> keyframe, 0-> not
Definition: avcodec.h:1058
int16_t level
Definition: get_bits.h:70
const int ff_dv_iweight_720_c[64]
Definition: dvdata.c:112
int video_stype
Definition: dv_profile.h:41
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:1377
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:50
AVPixelFormat
Pixel format.
Definition: pixfmt.h:63
This structure stores compressed data.
Definition: avcodec.h:898
void ff_free_vlc(VLC *vlc)
Definition: bitstream.c:322
uint8_t next[64]
Definition: dv.c:405
DSPContext.
Definition: dsputil.h:194
static av_always_inline PutBitContext * dv_encode_ac(EncBlockInfo *bi, PutBitContext *pb_pool, PutBitContext *pb_end)
Definition: dv.c:411
bitstream writer API