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 "put_bits.h"
46 #include "simple_idct.h"
47 #include "dvdata.h"
48 #include "dv_tablegen.h"
49 
50 //#undef NDEBUG
51 //#include <assert.h>
52 
53 typedef struct DVVideoContext {
54  const DVprofile *sys;
57  uint8_t *buf;
58 
59  uint8_t dv_zigzag[2][64];
60 
61  void (*get_pixels)(DCTELEM *block, const uint8_t *pixels, int line_size);
63  void (*idct_put[2])(uint8_t *dest, int line_size, DCTELEM *block);
66 
67 #define TEX_VLC_BITS 9
68 
69 /* XXX: also include quantization */
70 static RL_VLC_ELEM dv_rl_vlc[1184];
71 
72 static inline int dv_work_pool_size(const DVprofile *d)
73 {
74  int size = d->n_difchan*d->difseg_size*27;
75  if (DV_PROFILE_IS_1080i50(d))
76  size -= 3*27;
77  if (DV_PROFILE_IS_720p50(d))
78  size -= 4*27;
79  return size;
80 }
81 
82 static inline void dv_calc_mb_coordinates(const DVprofile *d, int chan, int seq, int slot,
83  uint16_t *tbl)
84 {
85  static const uint8_t off[] = { 2, 6, 8, 0, 4 };
86  static const uint8_t shuf1[] = { 36, 18, 54, 0, 72 };
87  static const uint8_t shuf2[] = { 24, 12, 36, 0, 48 };
88  static const uint8_t shuf3[] = { 18, 9, 27, 0, 36 };
89 
90  static const uint8_t l_start[] = {0, 4, 9, 13, 18, 22, 27, 31, 36, 40};
91  static const uint8_t l_start_shuffled[] = { 9, 4, 13, 0, 18 };
92 
93  static const uint8_t serpent1[] = {0, 1, 2, 2, 1, 0,
94  0, 1, 2, 2, 1, 0,
95  0, 1, 2, 2, 1, 0,
96  0, 1, 2, 2, 1, 0,
97  0, 1, 2};
98  static const uint8_t serpent2[] = {0, 1, 2, 3, 4, 5, 5, 4, 3, 2, 1, 0,
99  0, 1, 2, 3, 4, 5, 5, 4, 3, 2, 1, 0,
100  0, 1, 2, 3, 4, 5};
101 
102  static const uint8_t remap[][2] = {{ 0, 0}, { 0, 0}, { 0, 0}, { 0, 0}, /* dummy */
103  { 0, 0}, { 0, 1}, { 0, 2}, { 0, 3}, {10, 0},
104  {10, 1}, {10, 2}, {10, 3}, {20, 0}, {20, 1},
105  {20, 2}, {20, 3}, {30, 0}, {30, 1}, {30, 2},
106  {30, 3}, {40, 0}, {40, 1}, {40, 2}, {40, 3},
107  {50, 0}, {50, 1}, {50, 2}, {50, 3}, {60, 0},
108  {60, 1}, {60, 2}, {60, 3}, {70, 0}, {70, 1},
109  {70, 2}, {70, 3}, { 0,64}, { 0,65}, { 0,66},
110  {10,64}, {10,65}, {10,66}, {20,64}, {20,65},
111  {20,66}, {30,64}, {30,65}, {30,66}, {40,64},
112  {40,65}, {40,66}, {50,64}, {50,65}, {50,66},
113  {60,64}, {60,65}, {60,66}, {70,64}, {70,65},
114  {70,66}, { 0,67}, {20,67}, {40,67}, {60,67}};
115 
116  int i, k, m;
117  int x, y, blk;
118 
119  for (m=0; m<5; m++) {
120  switch (d->width) {
121  case 1440:
122  blk = (chan*11+seq)*27+slot;
123 
124  if (chan == 0 && seq == 11) {
125  x = m*27+slot;
126  if (x<90) {
127  y = 0;
128  } else {
129  x = (x - 90)*2;
130  y = 67;
131  }
132  } else {
133  i = (4*chan + blk + off[m])%11;
134  k = (blk/11)%27;
135 
136  x = shuf1[m] + (chan&1)*9 + k%9;
137  y = (i*3+k/9)*2 + (chan>>1) + 1;
138  }
139  tbl[m] = (x<<1)|(y<<9);
140  break;
141  case 1280:
142  blk = (chan*10+seq)*27+slot;
143 
144  i = (4*chan + (seq/5) + 2*blk + off[m])%10;
145  k = (blk/5)%27;
146 
147  x = shuf1[m]+(chan&1)*9 + k%9;
148  y = (i*3+k/9)*2 + (chan>>1) + 4;
149 
150  if (x >= 80) {
151  x = remap[y][0]+((x-80)<<(y>59));
152  y = remap[y][1];
153  }
154  tbl[m] = (x<<1)|(y<<9);
155  break;
156  case 960:
157  blk = (chan*10+seq)*27+slot;
158 
159  i = (4*chan + (seq/5) + 2*blk + off[m])%10;
160  k = (blk/5)%27 + (i&1)*3;
161 
162  x = shuf2[m] + k%6 + 6*(chan&1);
163  y = l_start[i] + k/6 + 45*(chan>>1);
164  tbl[m] = (x<<1)|(y<<9);
165  break;
166  case 720:
167  switch (d->pix_fmt) {
168  case PIX_FMT_YUV422P:
169  x = shuf3[m] + slot/3;
170  y = serpent1[slot] +
171  ((((seq + off[m]) % d->difseg_size)<<1) + chan)*3;
172  tbl[m] = (x<<1)|(y<<8);
173  break;
174  case PIX_FMT_YUV420P:
175  x = shuf3[m] + slot/3;
176  y = serpent1[slot] +
177  ((seq + off[m]) % d->difseg_size)*3;
178  tbl[m] = (x<<1)|(y<<9);
179  break;
180  case PIX_FMT_YUV411P:
181  i = (seq + off[m]) % d->difseg_size;
182  k = slot + ((m==1||m==2)?3:0);
183 
184  x = l_start_shuffled[m] + k/6;
185  y = serpent2[k] + i*6;
186  if (x>21)
187  y = y*2 - i*6;
188  tbl[m] = (x<<2)|(y<<8);
189  break;
190  }
191  default:
192  break;
193  }
194  }
195 }
196 
197 static int dv_init_dynamic_tables(const DVprofile *d)
198 {
199  int j,i,c,s,p;
200  uint32_t *factor1, *factor2;
201  const int *iweight1, *iweight2;
202 
203  if (!d->work_chunks[dv_work_pool_size(d)-1].buf_offset) {
204  p = i = 0;
205  for (c=0; c<d->n_difchan; c++) {
206  for (s=0; s<d->difseg_size; s++) {
207  p += 6;
208  for (j=0; j<27; j++) {
209  p += !(j%3);
210  if (!(DV_PROFILE_IS_1080i50(d) && c != 0 && s == 11) &&
211  !(DV_PROFILE_IS_720p50(d) && s > 9)) {
212  dv_calc_mb_coordinates(d, c, s, j, &d->work_chunks[i].mb_coordinates[0]);
213  d->work_chunks[i++].buf_offset = p;
214  }
215  p += 5;
216  }
217  }
218  }
219  }
220 
221  if (!d->idct_factor[DV_PROFILE_IS_HD(d)?8191:5631]) {
222  factor1 = &d->idct_factor[0];
223  factor2 = &d->idct_factor[DV_PROFILE_IS_HD(d)?4096:2816];
224  if (d->height == 720) {
225  iweight1 = &dv_iweight_720_y[0];
226  iweight2 = &dv_iweight_720_c[0];
227  } else {
228  iweight1 = &dv_iweight_1080_y[0];
229  iweight2 = &dv_iweight_1080_c[0];
230  }
231  if (DV_PROFILE_IS_HD(d)) {
232  for (c = 0; c < 4; c++) {
233  for (s = 0; s < 16; s++) {
234  for (i = 0; i < 64; i++) {
235  *factor1++ = (dv100_qstep[s] << (c + 9)) * iweight1[i];
236  *factor2++ = (dv100_qstep[s] << (c + 9)) * iweight2[i];
237  }
238  }
239  }
240  } else {
241  iweight1 = &dv_iweight_88[0];
242  for (j = 0; j < 2; j++, iweight1 = &dv_iweight_248[0]) {
243  for (s = 0; s < 22; s++) {
244  for (i = c = 0; c < 4; c++) {
245  for (; i < dv_quant_areas[c]; i++) {
246  *factor1 = iweight1[i] << (dv_quant_shifts[s][c] + 1);
247  *factor2++ = (*factor1++) << 1;
248  }
249  }
250  }
251  }
252  }
253  }
254 
255  return 0;
256 }
257 
259 {
260  DVVideoContext *s = avctx->priv_data;
261  DSPContext dsp;
262  static int done = 0;
263  int i, j;
264 
265  if (!done) {
266  VLC dv_vlc;
267  uint16_t new_dv_vlc_bits[NB_DV_VLC*2];
268  uint8_t new_dv_vlc_len[NB_DV_VLC*2];
269  uint8_t new_dv_vlc_run[NB_DV_VLC*2];
270  int16_t new_dv_vlc_level[NB_DV_VLC*2];
271 
272  done = 1;
273 
274  /* it's faster to include sign bit in a generic VLC parsing scheme */
275  for (i = 0, j = 0; i < NB_DV_VLC; i++, j++) {
276  new_dv_vlc_bits[j] = dv_vlc_bits[i];
277  new_dv_vlc_len[j] = dv_vlc_len[i];
278  new_dv_vlc_run[j] = dv_vlc_run[i];
279  new_dv_vlc_level[j] = dv_vlc_level[i];
280 
281  if (dv_vlc_level[i]) {
282  new_dv_vlc_bits[j] <<= 1;
283  new_dv_vlc_len[j]++;
284 
285  j++;
286  new_dv_vlc_bits[j] = (dv_vlc_bits[i] << 1) | 1;
287  new_dv_vlc_len[j] = dv_vlc_len[i] + 1;
288  new_dv_vlc_run[j] = dv_vlc_run[i];
289  new_dv_vlc_level[j] = -dv_vlc_level[i];
290  }
291  }
292 
293  /* NOTE: as a trick, we use the fact the no codes are unused
294  to accelerate the parsing of partial codes */
295  init_vlc(&dv_vlc, TEX_VLC_BITS, j,
296  new_dv_vlc_len, 1, 1, new_dv_vlc_bits, 2, 2, 0);
297  assert(dv_vlc.table_size == 1184);
298 
299  for (i = 0; i < dv_vlc.table_size; i++){
300  int code = dv_vlc.table[i][0];
301  int len = dv_vlc.table[i][1];
302  int level, run;
303 
304  if (len < 0){ //more bits needed
305  run = 0;
306  level = code;
307  } else {
308  run = new_dv_vlc_run [code] + 1;
309  level = new_dv_vlc_level[code];
310  }
311  dv_rl_vlc[i].len = len;
312  dv_rl_vlc[i].level = level;
313  dv_rl_vlc[i].run = run;
314  }
315  ff_free_vlc(&dv_vlc);
316 
318  }
319 
320  /* Generic DSP setup */
321  dsputil_init(&dsp, avctx);
322  ff_set_cmp(&dsp, dsp.ildct_cmp, avctx->ildct_cmp);
323  s->get_pixels = dsp.get_pixels;
324  s->ildct_cmp = dsp.ildct_cmp[5];
325 
326  /* 88DCT setup */
327  s->fdct[0] = dsp.fdct;
328  s->idct_put[0] = dsp.idct_put;
329  for (i = 0; i < 64; i++)
330  s->dv_zigzag[0][i] = dsp.idct_permutation[ff_zigzag_direct[i]];
331 
332  /* 248DCT setup */
333  s->fdct[1] = dsp.fdct248;
334  s->idct_put[1] = ff_simple_idct248_put; // FIXME: need to add it to DSP
335  if (avctx->lowres){
336  for (i = 0; i < 64; i++){
337  int j = ff_zigzag248_direct[i];
338  s->dv_zigzag[1][i] = dsp.idct_permutation[(j & 7) + (j & 8) * 4 + (j & 48) / 2];
339  }
340  }else
341  memcpy(s->dv_zigzag[1], ff_zigzag248_direct, 64);
342 
343  avctx->coded_frame = &s->picture;
344  s->avctx = avctx;
346 
347  return 0;
348 }
349 
351 {
352  if (!avpriv_dv_codec_profile(avctx)) {
353  av_log(avctx, AV_LOG_ERROR, "Found no DV profile for %ix%i %s video\n",
354  avctx->width, avctx->height, av_get_pix_fmt_name(avctx->pix_fmt));
355  return -1;
356  }
357 
358  return dvvideo_init(avctx);
359 }
360 
361 typedef struct BlockInfo {
362  const uint32_t *factor_table;
363  const uint8_t *scan_table;
364  uint8_t pos; /* position in block */
365  void (*idct_put)(uint8_t *dest, int line_size, DCTELEM *block);
369 } BlockInfo;
370 
371 /* bit budget for AC only in 5 MBs */
372 static const int vs_total_ac_bits = (100 * 4 + 68*2) * 5;
373 static const int mb_area_start[5] = { 1, 6, 21, 43, 64 };
374 
375 /* decode AC coefficients */
377 {
378  int last_index = gb->size_in_bits;
379  const uint8_t *scan_table = mb->scan_table;
380  const uint32_t *factor_table = mb->factor_table;
381  int pos = mb->pos;
382  int partial_bit_count = mb->partial_bit_count;
383  int level, run, vlc_len, index;
384 
385  OPEN_READER(re, gb);
386  UPDATE_CACHE(re, gb);
387 
388  /* if we must parse a partial VLC, we do it here */
389  if (partial_bit_count > 0) {
390  re_cache = re_cache >> partial_bit_count | mb->partial_bit_buffer;
391  re_index -= partial_bit_count;
392  mb->partial_bit_count = 0;
393  }
394 
395  /* get the AC coefficients until last_index is reached */
396  for (;;) {
397  av_dlog(NULL, "%2d: bits=%04x index=%d\n", pos, SHOW_UBITS(re, gb, 16),
398  re_index);
399  /* our own optimized GET_RL_VLC */
400  index = NEG_USR32(re_cache, TEX_VLC_BITS);
401  vlc_len = dv_rl_vlc[index].len;
402  if (vlc_len < 0) {
403  index = NEG_USR32((unsigned)re_cache << TEX_VLC_BITS, -vlc_len) + dv_rl_vlc[index].level;
404  vlc_len = TEX_VLC_BITS - vlc_len;
405  }
406  level = dv_rl_vlc[index].level;
407  run = dv_rl_vlc[index].run;
408 
409  /* gotta check if we're still within gb boundaries */
410  if (re_index + vlc_len > last_index) {
411  /* should be < 16 bits otherwise a codeword could have been parsed */
412  mb->partial_bit_count = last_index - re_index;
413  mb->partial_bit_buffer = re_cache & ~(-1u >> mb->partial_bit_count);
414  re_index = last_index;
415  break;
416  }
417  re_index += vlc_len;
418 
419  av_dlog(NULL, "run=%d level=%d\n", run, level);
420  pos += run;
421  if (pos >= 64)
422  break;
423 
424  level = (level * factor_table[pos] + (1 << (dv_iweight_bits - 1))) >> dv_iweight_bits;
425  block[scan_table[pos]] = level;
426 
427  UPDATE_CACHE(re, gb);
428  }
429  CLOSE_READER(re, gb);
430  mb->pos = pos;
431 }
432 
433 static inline void bit_copy(PutBitContext *pb, GetBitContext *gb)
434 {
435  int bits_left = get_bits_left(gb);
436  while (bits_left >= MIN_CACHE_BITS) {
438  bits_left -= MIN_CACHE_BITS;
439  }
440  if (bits_left > 0) {
441  put_bits(pb, bits_left, get_bits(gb, bits_left));
442  }
443 }
444 
445 static inline void dv_calculate_mb_xy(DVVideoContext *s, DVwork_chunk *work_chunk, int m, int *mb_x, int *mb_y)
446 {
447  *mb_x = work_chunk->mb_coordinates[m] & 0xff;
448  *mb_y = work_chunk->mb_coordinates[m] >> 8;
449 
450  /* We work with 720p frames split in half. The odd half-frame (chan==2,3) is displaced :-( */
451  if (s->sys->height == 720 && !(s->buf[1]&0x0C)) {
452  *mb_y -= (*mb_y>17)?18:-72; /* shifting the Y coordinate down by 72/2 macro blocks */
453  }
454 }
455 
456 /* mb_x and mb_y are in units of 8 pixels */
457 static int dv_decode_video_segment(AVCodecContext *avctx, void *arg)
458 {
459  DVVideoContext *s = avctx->priv_data;
460  DVwork_chunk *work_chunk = arg;
461  int quant, dc, dct_mode, class1, j;
462  int mb_index, mb_x, mb_y, last_index;
463  int y_stride, linesize;
464  DCTELEM *block, *block1;
465  int c_offset;
466  uint8_t *y_ptr;
467  const uint8_t *buf_ptr;
468  PutBitContext pb, vs_pb;
469  GetBitContext gb;
470  BlockInfo mb_data[5 * DV_MAX_BPM], *mb, *mb1;
471  LOCAL_ALIGNED_16(DCTELEM, sblock, [5*DV_MAX_BPM], [64]);
472  LOCAL_ALIGNED_16(uint8_t, mb_bit_buffer, [ 80 + FF_INPUT_BUFFER_PADDING_SIZE]); /* allow some slack */
473  LOCAL_ALIGNED_16(uint8_t, vs_bit_buffer, [5*80 + FF_INPUT_BUFFER_PADDING_SIZE]); /* allow some slack */
474  const int log2_blocksize = 3-s->avctx->lowres;
475  int is_field_mode[5];
476 
477  assert((((int)mb_bit_buffer) & 7) == 0);
478  assert((((int)vs_bit_buffer) & 7) == 0);
479 
480  memset(sblock, 0, 5*DV_MAX_BPM*sizeof(*sblock));
481 
482  /* pass 1: read DC and AC coefficients in blocks */
483  buf_ptr = &s->buf[work_chunk->buf_offset*80];
484  block1 = &sblock[0][0];
485  mb1 = mb_data;
486  init_put_bits(&vs_pb, vs_bit_buffer, 5 * 80);
487  for (mb_index = 0; mb_index < 5; mb_index++, mb1 += s->sys->bpm, block1 += s->sys->bpm * 64) {
488  /* skip header */
489  quant = buf_ptr[3] & 0x0f;
490  buf_ptr += 4;
491  init_put_bits(&pb, mb_bit_buffer, 80);
492  mb = mb1;
493  block = block1;
494  is_field_mode[mb_index] = 0;
495  for (j = 0; j < s->sys->bpm; j++) {
496  last_index = s->sys->block_sizes[j];
497  init_get_bits(&gb, buf_ptr, last_index);
498 
499  /* get the DC */
500  dc = get_sbits(&gb, 9);
501  dct_mode = get_bits1(&gb);
502  class1 = get_bits(&gb, 2);
503  if (DV_PROFILE_IS_HD(s->sys)) {
504  mb->idct_put = s->idct_put[0];
505  mb->scan_table = s->dv_zigzag[0];
506  mb->factor_table = &s->sys->idct_factor[(j >= 4)*4*16*64 + class1*16*64 + quant*64];
507  is_field_mode[mb_index] |= !j && dct_mode;
508  } else {
509  mb->idct_put = s->idct_put[dct_mode && log2_blocksize == 3];
510  mb->scan_table = s->dv_zigzag[dct_mode];
511  mb->factor_table = &s->sys->idct_factor[(class1 == 3)*2*22*64 + dct_mode*22*64 +
512  (quant + dv_quant_offset[class1])*64];
513  }
514  dc = dc << 2;
515  /* convert to unsigned because 128 is not added in the
516  standard IDCT */
517  dc += 1024;
518  block[0] = dc;
519  buf_ptr += last_index >> 3;
520  mb->pos = 0;
521  mb->partial_bit_count = 0;
522 
523  av_dlog(avctx, "MB block: %d, %d ", mb_index, j);
524  dv_decode_ac(&gb, mb, block);
525 
526  /* write the remaining bits in a new buffer only if the
527  block is finished */
528  if (mb->pos >= 64)
529  bit_copy(&pb, &gb);
530 
531  block += 64;
532  mb++;
533  }
534 
535  /* pass 2: we can do it just after */
536  av_dlog(avctx, "***pass 2 size=%d MB#=%d\n", put_bits_count(&pb), mb_index);
537  block = block1;
538  mb = mb1;
539  init_get_bits(&gb, mb_bit_buffer, put_bits_count(&pb));
540  put_bits32(&pb, 0); // padding must be zeroed
541  flush_put_bits(&pb);
542  for (j = 0; j < s->sys->bpm; j++, block += 64, mb++) {
543  if (mb->pos < 64 && get_bits_left(&gb) > 0) {
544  dv_decode_ac(&gb, mb, block);
545  /* if still not finished, no need to parse other blocks */
546  if (mb->pos < 64)
547  break;
548  }
549  }
550  /* all blocks are finished, so the extra bytes can be used at
551  the video segment level */
552  if (j >= s->sys->bpm)
553  bit_copy(&vs_pb, &gb);
554  }
555 
556  /* we need a pass over the whole video segment */
557  av_dlog(avctx, "***pass 3 size=%d\n", put_bits_count(&vs_pb));
558  block = &sblock[0][0];
559  mb = mb_data;
560  init_get_bits(&gb, vs_bit_buffer, put_bits_count(&vs_pb));
561  put_bits32(&vs_pb, 0); // padding must be zeroed
562  flush_put_bits(&vs_pb);
563  for (mb_index = 0; mb_index < 5; mb_index++) {
564  for (j = 0; j < s->sys->bpm; j++) {
565  if (mb->pos < 64) {
566  av_dlog(avctx, "start %d:%d\n", mb_index, j);
567  dv_decode_ac(&gb, mb, block);
568  }
569  if (mb->pos >= 64 && mb->pos < 127)
570  av_log(avctx, AV_LOG_ERROR, "AC EOB marker is absent pos=%d\n", mb->pos);
571  block += 64;
572  mb++;
573  }
574  }
575 
576  /* compute idct and place blocks */
577  block = &sblock[0][0];
578  mb = mb_data;
579  for (mb_index = 0; mb_index < 5; mb_index++) {
580  dv_calculate_mb_xy(s, work_chunk, mb_index, &mb_x, &mb_y);
581 
582  /* idct_put'ting luminance */
583  if ((s->sys->pix_fmt == PIX_FMT_YUV420P) ||
584  (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8)) ||
585  (s->sys->height >= 720 && mb_y != 134)) {
586  y_stride = (s->picture.linesize[0] << ((!is_field_mode[mb_index]) * log2_blocksize));
587  } else {
588  y_stride = (2 << log2_blocksize);
589  }
590  y_ptr = s->picture.data[0] + ((mb_y * s->picture.linesize[0] + mb_x) << log2_blocksize);
591  linesize = s->picture.linesize[0] << is_field_mode[mb_index];
592  mb[0] .idct_put(y_ptr , linesize, block + 0*64);
593  if (s->sys->video_stype == 4) { /* SD 422 */
594  mb[2].idct_put(y_ptr + (1 << log2_blocksize) , linesize, block + 2*64);
595  } else {
596  mb[1].idct_put(y_ptr + (1 << log2_blocksize) , linesize, block + 1*64);
597  mb[2].idct_put(y_ptr + y_stride, linesize, block + 2*64);
598  mb[3].idct_put(y_ptr + (1 << log2_blocksize) + y_stride, linesize, block + 3*64);
599  }
600  mb += 4;
601  block += 4*64;
602 
603  /* idct_put'ting chrominance */
604  c_offset = (((mb_y >> (s->sys->pix_fmt == PIX_FMT_YUV420P)) * s->picture.linesize[1] +
605  (mb_x >> ((s->sys->pix_fmt == PIX_FMT_YUV411P) ? 2 : 1))) << log2_blocksize);
606  for (j = 2; j; j--) {
607  uint8_t *c_ptr = s->picture.data[j] + c_offset;
608  if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8)) {
609  uint64_t aligned_pixels[64/8];
610  uint8_t *pixels = (uint8_t*)aligned_pixels;
611  uint8_t *c_ptr1, *ptr1;
612  int x, y;
613  mb->idct_put(pixels, 8, block);
614  for (y = 0; y < (1 << log2_blocksize); y++, c_ptr += s->picture.linesize[j], pixels += 8) {
615  ptr1 = pixels + (1 << (log2_blocksize - 1));
616  c_ptr1 = c_ptr + (s->picture.linesize[j] << log2_blocksize);
617  for (x = 0; x < (1 << (log2_blocksize - 1)); x++) {
618  c_ptr[x] = pixels[x];
619  c_ptr1[x] = ptr1[x];
620  }
621  }
622  block += 64; mb++;
623  } else {
624  y_stride = (mb_y == 134) ? (1 << log2_blocksize) :
625  s->picture.linesize[j] << ((!is_field_mode[mb_index]) * log2_blocksize);
626  linesize = s->picture.linesize[j] << is_field_mode[mb_index];
627  (mb++)-> idct_put(c_ptr , linesize, block); block += 64;
628  if (s->sys->bpm == 8) {
629  (mb++)->idct_put(c_ptr + y_stride, linesize, block); block += 64;
630  }
631  }
632  }
633  }
634  return 0;
635 }
636 
637 #if CONFIG_SMALL
638 /* Converts run and level (where level != 0) pair into VLC, returning bit size */
639 static av_always_inline int dv_rl2vlc(int run, int level, int sign, uint32_t* vlc)
640 {
641  int size;
642  if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {
643  *vlc = dv_vlc_map[run][level].vlc | sign;
644  size = dv_vlc_map[run][level].size;
645  }
646  else {
647  if (level < DV_VLC_MAP_LEV_SIZE) {
648  *vlc = dv_vlc_map[0][level].vlc | sign;
649  size = dv_vlc_map[0][level].size;
650  } else {
651  *vlc = 0xfe00 | (level << 1) | sign;
652  size = 16;
653  }
654  if (run) {
655  *vlc |= ((run < 16) ? dv_vlc_map[run-1][0].vlc :
656  (0x1f80 | (run - 1))) << size;
657  size += (run < 16) ? dv_vlc_map[run-1][0].size : 13;
658  }
659  }
660 
661  return size;
662 }
663 
664 static av_always_inline int dv_rl2vlc_size(int run, int level)
665 {
666  int size;
667 
668  if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {
669  size = dv_vlc_map[run][level].size;
670  }
671  else {
672  size = (level < DV_VLC_MAP_LEV_SIZE) ? dv_vlc_map[0][level].size : 16;
673  if (run) {
674  size += (run < 16) ? dv_vlc_map[run-1][0].size : 13;
675  }
676  }
677  return size;
678 }
679 #else
680 static av_always_inline int dv_rl2vlc(int run, int l, int sign, uint32_t* vlc)
681 {
682  *vlc = dv_vlc_map[run][l].vlc | sign;
683  return dv_vlc_map[run][l].size;
684 }
685 
686 static av_always_inline int dv_rl2vlc_size(int run, int l)
687 {
688  return dv_vlc_map[run][l].size;
689 }
690 #endif
691 
692 typedef struct EncBlockInfo {
693  int area_q[4];
694  int bit_size[4];
695  int prev[5];
696  int cur_ac;
697  int cno;
698  int dct_mode;
699  DCTELEM mb[64];
700  uint8_t next[64];
701  uint8_t sign[64];
703  uint32_t partial_bit_buffer; /* we can't use uint16_t here */
704 } EncBlockInfo;
705 
707  PutBitContext* pb_pool,
708  PutBitContext* pb_end)
709 {
710  int prev, bits_left;
711  PutBitContext* pb = pb_pool;
712  int size = bi->partial_bit_count;
713  uint32_t vlc = bi->partial_bit_buffer;
714 
716  for (;;){
717  /* Find suitable storage space */
718  for (; size > (bits_left = put_bits_left(pb)); pb++) {
719  if (bits_left) {
720  size -= bits_left;
721  put_bits(pb, bits_left, vlc >> size);
722  vlc = vlc & ((1 << size) - 1);
723  }
724  if (pb + 1 >= pb_end) {
725  bi->partial_bit_count = size;
726  bi->partial_bit_buffer = vlc;
727  return pb;
728  }
729  }
730 
731  /* Store VLC */
732  put_bits(pb, size, vlc);
733 
734  if (bi->cur_ac >= 64)
735  break;
736 
737  /* Construct the next VLC */
738  prev = bi->cur_ac;
739  bi->cur_ac = bi->next[prev];
740  if (bi->cur_ac < 64){
741  size = dv_rl2vlc(bi->cur_ac - prev - 1, bi->mb[bi->cur_ac], bi->sign[bi->cur_ac], &vlc);
742  } else {
743  size = 4; vlc = 6; /* End Of Block stamp */
744  }
745  }
746  return pb;
747 }
748 
749 static av_always_inline int dv_guess_dct_mode(DVVideoContext *s, uint8_t *data, int linesize) {
751  int ps = s->ildct_cmp(NULL, data, NULL, linesize, 8) - 400;
752  if (ps > 0) {
753  int is = s->ildct_cmp(NULL, data , NULL, linesize<<1, 4) +
754  s->ildct_cmp(NULL, data + linesize, NULL, linesize<<1, 4);
755  return ps > is;
756  }
757  }
758 
759  return 0;
760 }
761 
762 static av_always_inline int dv_init_enc_block(EncBlockInfo* bi, uint8_t *data, int linesize, DVVideoContext *s, int bias)
763 {
764  const int *weight;
765  const uint8_t* zigzag_scan;
766  LOCAL_ALIGNED_16(DCTELEM, blk, [64]);
767  int i, area;
768  /* We offer two different methods for class number assignment: the
769  method suggested in SMPTE 314M Table 22, and an improved
770  method. The SMPTE method is very conservative; it assigns class
771  3 (i.e. severe quantization) to any block where the largest AC
772  component is greater than 36. Libav's DV encoder tracks AC bit
773  consumption precisely, so there is no need to bias most blocks
774  towards strongly lossy compression. Instead, we assign class 2
775  to most blocks, and use class 3 only when strictly necessary
776  (for blocks whose largest AC component exceeds 255). */
777 
778 #if 0 /* SMPTE spec method */
779  static const int classes[] = {12, 24, 36, 0xffff};
780 #else /* improved Libav method */
781  static const int classes[] = {-1, -1, 255, 0xffff};
782 #endif
783  int max = classes[0];
784  int prev = 0;
785 
786  assert((((int)blk) & 15) == 0);
787 
788  bi->area_q[0] = bi->area_q[1] = bi->area_q[2] = bi->area_q[3] = 0;
789  bi->partial_bit_count = 0;
790  bi->partial_bit_buffer = 0;
791  bi->cur_ac = 0;
792  if (data) {
793  bi->dct_mode = dv_guess_dct_mode(s, data, linesize);
794  s->get_pixels(blk, data, linesize);
795  s->fdct[bi->dct_mode](blk);
796  } else {
797  /* We rely on the fact that encoding all zeros leads to an immediate EOB,
798  which is precisely what the spec calls for in the "dummy" blocks. */
799  memset(blk, 0, 64*sizeof(*blk));
800  bi->dct_mode = 0;
801  }
802  bi->mb[0] = blk[0];
803 
804  zigzag_scan = bi->dct_mode ? ff_zigzag248_direct : ff_zigzag_direct;
805  weight = bi->dct_mode ? dv_weight_248 : dv_weight_88;
806 
807  for (area = 0; area < 4; area++) {
808  bi->prev[area] = prev;
809  bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
810  for (i = mb_area_start[area]; i < mb_area_start[area+1]; i++) {
811  int level = blk[zigzag_scan[i]];
812 
813  if (level + 15 > 30U) {
814  bi->sign[i] = (level >> 31) & 1;
815  /* weight it and and shift down into range, adding for rounding */
816  /* the extra division by a factor of 2^4 reverses the 8x expansion of the DCT
817  AND the 2x doubling of the weights */
818  level = (FFABS(level) * weight[i] + (1 << (dv_weight_bits+3))) >> (dv_weight_bits+4);
819  bi->mb[i] = level;
820  if (level > max)
821  max = level;
822  bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, level);
823  bi->next[prev]= i;
824  prev = i;
825  }
826  }
827  }
828  bi->next[prev]= i;
829  for (bi->cno = 0; max > classes[bi->cno]; bi->cno++);
830 
831  bi->cno += bias;
832 
833  if (bi->cno >= 3) {
834  bi->cno = 3;
835  prev = 0;
836  i = bi->next[prev];
837  for (area = 0; area < 4; area++) {
838  bi->prev[area] = prev;
839  bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
840  for (; i < mb_area_start[area+1]; i = bi->next[i]) {
841  bi->mb[i] >>= 1;
842 
843  if (bi->mb[i]) {
844  bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, bi->mb[i]);
845  bi->next[prev]= i;
846  prev = i;
847  }
848  }
849  }
850  bi->next[prev]= i;
851  }
852 
853  return bi->bit_size[0] + bi->bit_size[1] + bi->bit_size[2] + bi->bit_size[3];
854 }
855 
856 static inline void dv_guess_qnos(EncBlockInfo* blks, int* qnos)
857 {
858  int size[5];
859  int i, j, k, a, prev, a2;
860  EncBlockInfo* b;
861 
862  size[0] = size[1] = size[2] = size[3] = size[4] = 1 << 24;
863  do {
864  b = blks;
865  for (i = 0; i < 5; i++) {
866  if (!qnos[i])
867  continue;
868 
869  qnos[i]--;
870  size[i] = 0;
871  for (j = 0; j < 6; j++, b++) {
872  for (a = 0; a < 4; a++) {
873  if (b->area_q[a] != dv_quant_shifts[qnos[i] + dv_quant_offset[b->cno]][a]) {
874  b->bit_size[a] = 1; // 4 areas 4 bits for EOB :)
875  b->area_q[a]++;
876  prev = b->prev[a];
877  assert(b->next[prev] >= mb_area_start[a+1] || b->mb[prev]);
878  for (k = b->next[prev] ; k < mb_area_start[a+1]; k = b->next[k]) {
879  b->mb[k] >>= 1;
880  if (b->mb[k]) {
881  b->bit_size[a] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
882  prev = k;
883  } else {
884  if (b->next[k] >= mb_area_start[a+1] && b->next[k]<64){
885  for (a2 = a + 1; b->next[k] >= mb_area_start[a2+1]; a2++)
886  b->prev[a2] = prev;
887  assert(a2 < 4);
888  assert(b->mb[b->next[k]]);
889  b->bit_size[a2] += dv_rl2vlc_size(b->next[k] - prev - 1, b->mb[b->next[k]])
890  -dv_rl2vlc_size(b->next[k] - k - 1, b->mb[b->next[k]]);
891  assert(b->prev[a2] == k && (a2 + 1 >= 4 || b->prev[a2+1] != k));
892  b->prev[a2] = prev;
893  }
894  b->next[prev] = b->next[k];
895  }
896  }
897  b->prev[a+1]= prev;
898  }
899  size[i] += b->bit_size[a];
900  }
901  }
902  if (vs_total_ac_bits >= size[0] + size[1] + size[2] + size[3] + size[4])
903  return;
904  }
905  } while (qnos[0]|qnos[1]|qnos[2]|qnos[3]|qnos[4]);
906 
907 
908  for (a = 2; a == 2 || vs_total_ac_bits < size[0]; a += a){
909  b = blks;
910  size[0] = 5 * 6 * 4; //EOB
911  for (j = 0; j < 6 *5; j++, b++) {
912  prev = b->prev[0];
913  for (k = b->next[prev]; k < 64; k = b->next[k]) {
914  if (b->mb[k] < a && b->mb[k] > -a){
915  b->next[prev] = b->next[k];
916  }else{
917  size[0] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
918  prev = k;
919  }
920  }
921  }
922  }
923 }
924 
925 static int dv_encode_video_segment(AVCodecContext *avctx, void *arg)
926 {
927  DVVideoContext *s = avctx->priv_data;
928  DVwork_chunk *work_chunk = arg;
929  int mb_index, i, j;
930  int mb_x, mb_y, c_offset, linesize, y_stride;
931  uint8_t* y_ptr;
932  uint8_t* dif;
933  LOCAL_ALIGNED_8(uint8_t, scratch, [64]);
934  EncBlockInfo enc_blks[5*DV_MAX_BPM];
935  PutBitContext pbs[5*DV_MAX_BPM];
936  PutBitContext* pb;
937  EncBlockInfo* enc_blk;
938  int vs_bit_size = 0;
939  int qnos[5] = {15, 15, 15, 15, 15}; /* No quantization */
940  int* qnosp = &qnos[0];
941 
942  dif = &s->buf[work_chunk->buf_offset*80];
943  enc_blk = &enc_blks[0];
944  for (mb_index = 0; mb_index < 5; mb_index++) {
945  dv_calculate_mb_xy(s, work_chunk, mb_index, &mb_x, &mb_y);
946 
947  /* initializing luminance blocks */
948  if ((s->sys->pix_fmt == PIX_FMT_YUV420P) ||
949  (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8)) ||
950  (s->sys->height >= 720 && mb_y != 134)) {
951  y_stride = s->picture.linesize[0] << 3;
952  } else {
953  y_stride = 16;
954  }
955  y_ptr = s->picture.data[0] + ((mb_y * s->picture.linesize[0] + mb_x) << 3);
956  linesize = s->picture.linesize[0];
957 
958  if (s->sys->video_stype == 4) { /* SD 422 */
959  vs_bit_size +=
960  dv_init_enc_block(enc_blk+0, y_ptr , linesize, s, 0) +
961  dv_init_enc_block(enc_blk+1, NULL , linesize, s, 0) +
962  dv_init_enc_block(enc_blk+2, y_ptr + 8 , linesize, s, 0) +
963  dv_init_enc_block(enc_blk+3, NULL , linesize, s, 0);
964  } else {
965  vs_bit_size +=
966  dv_init_enc_block(enc_blk+0, y_ptr , linesize, s, 0) +
967  dv_init_enc_block(enc_blk+1, y_ptr + 8 , linesize, s, 0) +
968  dv_init_enc_block(enc_blk+2, y_ptr + y_stride, linesize, s, 0) +
969  dv_init_enc_block(enc_blk+3, y_ptr + 8 + y_stride, linesize, s, 0);
970  }
971  enc_blk += 4;
972 
973  /* initializing chrominance blocks */
974  c_offset = (((mb_y >> (s->sys->pix_fmt == PIX_FMT_YUV420P)) * s->picture.linesize[1] +
975  (mb_x >> ((s->sys->pix_fmt == PIX_FMT_YUV411P) ? 2 : 1))) << 3);
976  for (j = 2; j; j--) {
977  uint8_t *c_ptr = s->picture.data[j] + c_offset;
978  linesize = s->picture.linesize[j];
979  y_stride = (mb_y == 134) ? 8 : (s->picture.linesize[j] << 3);
980  if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8)) {
981  uint8_t* d;
982  uint8_t* b = scratch;
983  for (i = 0; i < 8; i++) {
984  d = c_ptr + (linesize << 3);
985  b[0] = c_ptr[0]; b[1] = c_ptr[1]; b[2] = c_ptr[2]; b[3] = c_ptr[3];
986  b[4] = d[0]; b[5] = d[1]; b[6] = d[2]; b[7] = d[3];
987  c_ptr += linesize;
988  b += 8;
989  }
990  c_ptr = scratch;
991  linesize = 8;
992  }
993 
994  vs_bit_size += dv_init_enc_block( enc_blk++, c_ptr , linesize, s, 1);
995  if (s->sys->bpm == 8) {
996  vs_bit_size += dv_init_enc_block(enc_blk++, c_ptr + y_stride, linesize, s, 1);
997  }
998  }
999  }
1000 
1001  if (vs_total_ac_bits < vs_bit_size)
1002  dv_guess_qnos(&enc_blks[0], qnosp);
1003 
1004  /* DIF encoding process */
1005  for (j=0; j<5*s->sys->bpm;) {
1006  int start_mb = j;
1007 
1008  dif[3] = *qnosp++;
1009  dif += 4;
1010 
1011  /* First pass over individual cells only */
1012  for (i=0; i<s->sys->bpm; i++, j++) {
1013  int sz = s->sys->block_sizes[i]>>3;
1014 
1015  init_put_bits(&pbs[j], dif, sz);
1016  put_sbits(&pbs[j], 9, ((enc_blks[j].mb[0] >> 3) - 1024 + 2) >> 2);
1017  put_bits(&pbs[j], 1, enc_blks[j].dct_mode);
1018  put_bits(&pbs[j], 2, enc_blks[j].cno);
1019 
1020  dv_encode_ac(&enc_blks[j], &pbs[j], &pbs[j+1]);
1021  dif += sz;
1022  }
1023 
1024  /* Second pass over each MB space */
1025  pb = &pbs[start_mb];
1026  for (i=0; i<s->sys->bpm; i++) {
1027  if (enc_blks[start_mb+i].partial_bit_count)
1028  pb = dv_encode_ac(&enc_blks[start_mb+i], pb, &pbs[start_mb+s->sys->bpm]);
1029  }
1030  }
1031 
1032  /* Third and final pass over the whole video segment space */
1033  pb = &pbs[0];
1034  for (j=0; j<5*s->sys->bpm; j++) {
1035  if (enc_blks[j].partial_bit_count)
1036  pb = dv_encode_ac(&enc_blks[j], pb, &pbs[s->sys->bpm*5]);
1037  if (enc_blks[j].partial_bit_count)
1038  av_log(avctx, AV_LOG_ERROR, "ac bitstream overflow\n");
1039  }
1040 
1041  for (j=0; j<5*s->sys->bpm; j++) {
1042  int pos;
1043  int size = pbs[j].size_in_bits >> 3;
1044  flush_put_bits(&pbs[j]);
1045  pos = put_bits_count(&pbs[j]) >> 3;
1046  if (pos > size) {
1047  av_log(avctx, AV_LOG_ERROR, "bitstream written beyond buffer size\n");
1048  return -1;
1049  }
1050  memset(pbs[j].buf + pos, 0xff, size - pos);
1051  }
1052 
1053  return 0;
1054 }
1055 
1056 #if CONFIG_DVVIDEO_DECODER
1057 /* NOTE: exactly one frame must be given (120000 bytes for NTSC,
1058  144000 bytes for PAL - or twice those for 50Mbps) */
1059 static int dvvideo_decode_frame(AVCodecContext *avctx,
1060  void *data, int *data_size,
1061  AVPacket *avpkt)
1062 {
1063  const uint8_t *buf = avpkt->data;
1064  int buf_size = avpkt->size;
1065  DVVideoContext *s = avctx->priv_data;
1066  const uint8_t* vsc_pack;
1067  int apt, is16_9;
1068 
1069  s->sys = avpriv_dv_frame_profile(s->sys, buf, buf_size);
1070  if (!s->sys || buf_size < s->sys->frame_size || dv_init_dynamic_tables(s->sys)) {
1071  av_log(avctx, AV_LOG_ERROR, "could not find dv frame profile\n");
1072  return -1; /* NOTE: we only accept several full frames */
1073  }
1074 
1075  if (s->picture.data[0])
1076  avctx->release_buffer(avctx, &s->picture);
1077 
1078  s->picture.reference = 0;
1079  s->picture.key_frame = 1;
1081  avctx->pix_fmt = s->sys->pix_fmt;
1082  avctx->time_base = s->sys->time_base;
1083  avcodec_set_dimensions(avctx, s->sys->width, s->sys->height);
1084  if (avctx->get_buffer(avctx, &s->picture) < 0) {
1085  av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1086  return -1;
1087  }
1088  s->picture.interlaced_frame = 1;
1089  s->picture.top_field_first = 0;
1090 
1091  s->buf = buf;
1092  avctx->execute(avctx, dv_decode_video_segment, s->sys->work_chunks, NULL,
1093  dv_work_pool_size(s->sys), sizeof(DVwork_chunk));
1094 
1095  emms_c();
1096 
1097  /* return image */
1098  *data_size = sizeof(AVFrame);
1099  *(AVFrame*)data = s->picture;
1100 
1101  /* Determine the codec's sample_aspect ratio from the packet */
1102  vsc_pack = buf + 80*5 + 48 + 5;
1103  if ( *vsc_pack == dv_video_control ) {
1104  apt = buf[4] & 0x07;
1105  is16_9 = (vsc_pack && ((vsc_pack[2] & 0x07) == 0x02 || (!apt && (vsc_pack[2] & 0x07) == 0x07)));
1106  avctx->sample_aspect_ratio = s->sys->sar[is16_9];
1107  }
1108 
1109  return s->sys->frame_size;
1110 }
1111 #endif /* CONFIG_DVVIDEO_DECODER */
1112 
1113 
1114 static inline int dv_write_pack(enum dv_pack_type pack_id, DVVideoContext *c,
1115  uint8_t* buf)
1116 {
1117  /*
1118  * Here's what SMPTE314M says about these two:
1119  * (page 6) APTn, AP1n, AP2n, AP3n: These data shall be identical
1120  * as track application IDs (APTn = 001, AP1n =
1121  * 001, AP2n = 001, AP3n = 001), if the source signal
1122  * comes from a digital VCR. If the signal source is
1123  * unknown, all bits for these data shall be set to 1.
1124  * (page 12) STYPE: STYPE defines a signal type of video signal
1125  * 00000b = 4:1:1 compression
1126  * 00100b = 4:2:2 compression
1127  * XXXXXX = Reserved
1128  * Now, I've got two problems with these statements:
1129  * 1. it looks like APT == 111b should be a safe bet, but it isn't.
1130  * It seems that for PAL as defined in IEC 61834 we have to set
1131  * APT to 000 and for SMPTE314M to 001.
1132  * 2. It is not at all clear what STYPE is used for 4:2:0 PAL
1133  * compression scheme (if any).
1134  */
1135  int apt = (c->sys->pix_fmt == PIX_FMT_YUV420P ? 0 : 1);
1136 
1137  uint8_t aspect = 0;
1138  if ((int)(av_q2d(c->avctx->sample_aspect_ratio) * c->avctx->width / c->avctx->height * 10) >= 17) /* 16:9 */
1139  aspect = 0x02;
1140 
1141  buf[0] = (uint8_t)pack_id;
1142  switch (pack_id) {
1143  case dv_header525: /* I can't imagine why these two weren't defined as real */
1144  case dv_header625: /* packs in SMPTE314M -- they definitely look like ones */
1145  buf[1] = 0xf8 | /* reserved -- always 1 */
1146  (apt & 0x07); /* APT: Track application ID */
1147  buf[2] = (0 << 7) | /* TF1: audio data is 0 - valid; 1 - invalid */
1148  (0x0f << 3) | /* reserved -- always 1 */
1149  (apt & 0x07); /* AP1: Audio application ID */
1150  buf[3] = (0 << 7) | /* TF2: video data is 0 - valid; 1 - invalid */
1151  (0x0f << 3) | /* reserved -- always 1 */
1152  (apt & 0x07); /* AP2: Video application ID */
1153  buf[4] = (0 << 7) | /* TF3: subcode(SSYB) is 0 - valid; 1 - invalid */
1154  (0x0f << 3) | /* reserved -- always 1 */
1155  (apt & 0x07); /* AP3: Subcode application ID */
1156  break;
1157  case dv_video_source:
1158  buf[1] = 0xff; /* reserved -- always 1 */
1159  buf[2] = (1 << 7) | /* B/W: 0 - b/w, 1 - color */
1160  (1 << 6) | /* following CLF is valid - 0, invalid - 1 */
1161  (3 << 4) | /* CLF: color frames ID (see ITU-R BT.470-4) */
1162  0xf; /* reserved -- always 1 */
1163  buf[3] = (3 << 6) | /* reserved -- always 1 */
1164  (c->sys->dsf << 5) | /* system: 60fields/50fields */
1165  c->sys->video_stype; /* signal type video compression */
1166  buf[4] = 0xff; /* VISC: 0xff -- no information */
1167  break;
1168  case dv_video_control:
1169  buf[1] = (0 << 6) | /* Copy generation management (CGMS) 0 -- free */
1170  0x3f; /* reserved -- always 1 */
1171  buf[2] = 0xc8 | /* reserved -- always b11001xxx */
1172  aspect;
1173  buf[3] = (1 << 7) | /* frame/field flag 1 -- frame, 0 -- field */
1174  (1 << 6) | /* first/second field flag 0 -- field 2, 1 -- field 1 */
1175  (1 << 5) | /* frame change flag 0 -- same picture as before, 1 -- different */
1176  (1 << 4) | /* 1 - interlaced, 0 - noninterlaced */
1177  0xc; /* reserved -- always b1100 */
1178  buf[4] = 0xff; /* reserved -- always 1 */
1179  break;
1180  default:
1181  buf[1] = buf[2] = buf[3] = buf[4] = 0xff;
1182  }
1183  return 5;
1184 }
1185 
1186 #if CONFIG_DVVIDEO_ENCODER
1187 static void dv_format_frame(DVVideoContext* c, uint8_t* buf)
1188 {
1189  int chan, i, j, k;
1190 
1191  for (chan = 0; chan < c->sys->n_difchan; chan++) {
1192  for (i = 0; i < c->sys->difseg_size; i++) {
1193  memset(buf, 0xff, 80 * 6); /* first 6 DIF blocks are for control data */
1194 
1195  /* DV header: 1DIF */
1196  buf += dv_write_dif_id(dv_sect_header, chan, i, 0, buf);
1197  buf += dv_write_pack((c->sys->dsf ? dv_header625 : dv_header525), c, buf);
1198  buf += 72; /* unused bytes */
1199 
1200  /* DV subcode: 2DIFs */
1201  for (j = 0; j < 2; j++) {
1202  buf += dv_write_dif_id(dv_sect_subcode, chan, i, j, buf);
1203  for (k = 0; k < 6; k++)
1204  buf += dv_write_ssyb_id(k, (i < c->sys->difseg_size/2), buf) + 5;
1205  buf += 29; /* unused bytes */
1206  }
1207 
1208  /* DV VAUX: 3DIFS */
1209  for (j = 0; j < 3; j++) {
1210  buf += dv_write_dif_id(dv_sect_vaux, chan, i, j, buf);
1211  buf += dv_write_pack(dv_video_source, c, buf);
1212  buf += dv_write_pack(dv_video_control, c, buf);
1213  buf += 7*5;
1214  buf += dv_write_pack(dv_video_source, c, buf);
1215  buf += dv_write_pack(dv_video_control, c, buf);
1216  buf += 4*5 + 2; /* unused bytes */
1217  }
1218 
1219  /* DV Audio/Video: 135 Video DIFs + 9 Audio DIFs */
1220  for (j = 0; j < 135; j++) {
1221  if (j%15 == 0) {
1222  memset(buf, 0xff, 80);
1223  buf += dv_write_dif_id(dv_sect_audio, chan, i, j/15, buf);
1224  buf += 77; /* audio control & shuffled PCM audio */
1225  }
1226  buf += dv_write_dif_id(dv_sect_video, chan, i, j, buf);
1227  buf += 77; /* 1 video macroblock: 1 bytes control
1228  4 * 14 bytes Y 8x8 data
1229  10 bytes Cr 8x8 data
1230  10 bytes Cb 8x8 data */
1231  }
1232  }
1233  }
1234 }
1235 
1236 
1237 static int dvvideo_encode_frame(AVCodecContext *c, uint8_t *buf, int buf_size,
1238  void *data)
1239 {
1240  DVVideoContext *s = c->priv_data;
1241 
1242  s->sys = avpriv_dv_codec_profile(c);
1243  if (!s->sys || buf_size < s->sys->frame_size || dv_init_dynamic_tables(s->sys))
1244  return -1;
1245 
1246  c->pix_fmt = s->sys->pix_fmt;
1247  s->picture = *((AVFrame *)data);
1248  s->picture.key_frame = 1;
1250 
1251  s->buf = buf;
1253  dv_work_pool_size(s->sys), sizeof(DVwork_chunk));
1254 
1255  emms_c();
1256 
1257  dv_format_frame(s, buf);
1258 
1259  return s->sys->frame_size;
1260 }
1261 #endif
1262 
1264 {
1265  DVVideoContext *s = c->priv_data;
1266 
1267  if (s->picture.data[0])
1268  c->release_buffer(c, &s->picture);
1269 
1270  return 0;
1271 }
1272 
1273 
1274 #if CONFIG_DVVIDEO_ENCODER
1275 AVCodec ff_dvvideo_encoder = {
1276  .name = "dvvideo",
1277  .type = AVMEDIA_TYPE_VIDEO,
1278  .id = CODEC_ID_DVVIDEO,
1279  .priv_data_size = sizeof(DVVideoContext),
1281  .encode = dvvideo_encode_frame,
1282  .capabilities = CODEC_CAP_SLICE_THREADS,
1284  .long_name = NULL_IF_CONFIG_SMALL("DV (Digital Video)"),
1285 };
1286 #endif // CONFIG_DVVIDEO_ENCODER
1287 
1288 #if CONFIG_DVVIDEO_DECODER
1289 AVCodec ff_dvvideo_decoder = {
1290  .name = "dvvideo",
1291  .type = AVMEDIA_TYPE_VIDEO,
1292  .id = CODEC_ID_DVVIDEO,
1293  .priv_data_size = sizeof(DVVideoContext),
1294  .init = dvvideo_init,
1295  .close = dvvideo_close,
1296  .decode = dvvideo_decode_frame,
1297  .capabilities = CODEC_CAP_DR1 | CODEC_CAP_SLICE_THREADS,
1298  .max_lowres = 3,
1299  .long_name = NULL_IF_CONFIG_SMALL("DV (Digital Video)"),
1300 };
1301 #endif
static const uint8_t dv_vlc_run[409]
Definition: dv_vlc_data.h:149
struct DVVideoContext DVVideoContext
#define LOCAL_ALIGNED_8(t, v,...)
Definition: dsputil.h:692
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
Definition: pixfmt.h:68
int(* get_buffer)(struct AVCodecContext *c, AVFrame *pic)
Called at the beginning of each frame to get a buffer for it.
Definition: avcodec.h:1726
static void av_unused put_bits32(PutBitContext *s, uint32_t value)
Write exactly 32 bits into a bitstream.
Definition: put_bits.h:187
enum PixelFormat pix_fmt
Pixel format, see PIX_FMT_xxx.
Definition: avcodec.h:1426
int table_size
Definition: get_bits.h:66
const uint8_t ff_zigzag_direct[64]
Definition: dsputil.c:61
int size
Audio Video Frame.
Definition: avcodec.h:985
#define CODEC_FLAG_INTERLACED_DCT
Use interlaced DCT.
Definition: avcodec.h:646
static void put_sbits(PutBitContext *pb, int n, int32_t value)
Definition: put_bits.h:177
void(* release_buffer)(struct AVCodecContext *c, AVFrame *pic)
Called to release buffers which were allocated with get_buffer.
Definition: avcodec.h:1737
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:237
AVFrame * coded_frame
the picture in the bitstream
Definition: avcodec.h:2000
const uint8_t ff_zigzag248_direct[64]
Definition: dsputil.c:74
int(* me_cmp_func)(void *s, uint8_t *blk1, uint8_t *blk2, int line_size, int h)
Definition: dsputil.h:191
int size
Definition: avcodec.h:909
static const int dv_iweight_bits
Definition: dvdata.h:127
static av_always_inline int dv_rl2vlc(int run, int l, int sign, uint32_t *vlc)
Definition: dv.c:680
planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples)
Definition: pixfmt.h:71
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:1993
static int dv_write_pack(enum dv_pack_type pack_id, DVVideoContext *c, uint8_t *buf)
Definition: dv.c:1114
me_cmp_func ildct_cmp
Definition: dv.c:64
int dsf
Definition: dvdata.h:45
const DVprofile * avpriv_dv_frame_profile(const DVprofile *sys, const uint8_t *frame, unsigned buf_size)
Definition: dvdata.c:248
AVRational sar[2]
Definition: dvdata.h:54
#define b
Definition: swscale.c:1335
static av_always_inline int dv_guess_dct_mode(DVVideoContext *s, uint8_t *data, int linesize)
Definition: dv.c:749
int ildct_cmp
interlaced DCT comparison function
Definition: avcodec.h:2066
Definition: dv.c:361
static const int dv_iweight_248[64]
Definition: dvdata.h:138
static RL_VLC_ELEM dv_rl_vlc[1184]
Definition: dv.c:70
uint8_t run
Definition: svq3.c:123
static const int dv_iweight_720_y[64]
Definition: dvdata.h:172
#define blk(i)
Definition: sha.c:163
AVCodec.
Definition: avcodec.h:3189
static int get_sbits(GetBitContext *s, int n)
Definition: get_bits.h:223
struct BlockInfo BlockInfo
static const uint8_t zigzag_scan[16]
Definition: h264data.h:53
static const uint8_t dv_quant_offset[4]
Definition: dvdata.h:94
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...
Definition: avcodec.h:1398
uint8_t * buf
Definition: dv.c:57
#define DV_PROFILE_IS_720p50(p)
Definition: dvdata.h:261
static const int mb_area_start[5]
Definition: dv.c:373
static int dv_encode_video_segment(AVCodecContext *avctx, void *arg)
Definition: dv.c:925
static int decode(MimicContext *ctx, int quality, int num_coeffs, int is_iframe)
Definition: mimic.c:228
AVCodecContext * avctx
Definition: dv.c:56
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:64
#define av_cold
Definition: attributes.h:71
static void dv_guess_qnos(EncBlockInfo *blks, int *qnos)
Definition: dv.c:856
int bpm
Definition: dvdata.h:58
void(* get_pixels)(DCTELEM *block, const uint8_t *pixels, int line_size)
Definition: dsputil.h:233
static av_always_inline int dv_rl2vlc_size(int run, int l)
Definition: dv.c:686
void(* get_pixels)(DCTELEM *block, const uint8_t *pixels, int line_size)
Definition: dv.c:61
static const int dv_weight_88[64]
Definition: dvdata.h:107
const char data[16]
Definition: mxf.c:60
static double av_q2d(AVRational a)
Convert rational to double.
Definition: rational.h:69
uint8_t * data
Definition: avcodec.h:908
#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:1808
bitstream reader API header.
uint8_t idct_permutation[64]
idct input permutation.
Definition: dsputil.h:505
me_cmp_func ildct_cmp[6]
Definition: dsputil.h:290
int interlaced_frame
The content of the picture is interlaced.
Definition: avcodec.h:1167
int lowres
low resolution decoding, 1-> 1/2 size, 2->1/4 size
Definition: avcodec.h:2536
#define LOCAL_ALIGNED_16(t, v,...)
Definition: dsputil.h:698
const uint8_t * block_sizes
Definition: dvdata.h:59
enum AVChromaLocation chroma_sample_location
This defines the location of chroma samples.
Definition: avcodec.h:2954
av_cold void dsputil_init(DSPContext *c, AVCodecContext *avctx)
Definition: dsputil.c:2789
void avcodec_set_dimensions(AVCodecContext *s, int width, int height)
Definition: utils.c:133
static int init(AVCodecParserContext *s)
Definition: h264_parser.c:336
static DSPContext dsp
Definition: atrac3.c:135
#define CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: avcodec.h:719
static const uint8_t dv_quant_areas[4]
Definition: dvdata.h:95
static int dv_work_pool_size(const DVprofile *d)
Definition: dv.c:72
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:513
int size_in_bits
Definition: put_bits.h:43
static const uint8_t dv_quant_shifts[22][4]
Definition: dvdata.h:69
#define UPDATE_CACHE(name, gb)
Definition: get_bits.h:160
#define DV_PROFILE_IS_1080i50(p)
Definition: dvdata.h:260
static void bit_copy(PutBitContext *pb, GetBitContext *gb)
Definition: dv.c:433
uint8_t partial_bit_count
Definition: dv.c:702
int shift_offset
Definition: dv.c:368
static const int vs_total_ac_bits
Definition: dv.c:372
static int put_bits_left(PutBitContext *s)
Definition: put_bits.h:78
uint16_t mb_coordinates[5]
Definition: dvdata.h:35
int reference
is this picture used as reference The values for this are the same as the MpegEncContext.picture_structure variable, that is 1->top field, 2->bottom field, 3->frame/both fields.
Definition: avcodec.h:1074
void(* idct_put[2])(uint8_t *dest, int line_size, DCTELEM *block)
Definition: dv.c:63
static const int dv_iweight_1080_y[64]
The "inverse" DV100 weights are actually just the spec weights (zig-zagged).
Definition: dvdata.h:152
int height
Definition: dvdata.h:52
void(* idct_put)(uint8_t *dest, int line_size, DCTELEM *block)
block -> idct -> clip to unsigned 8 bit -> dest.
Definition: dsputil.h:485
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:191
#define DV_PROFILE_IS_HD(p)
Definition: dvdata.h:259
int flags
CODEC_FLAG_*.
Definition: avcodec.h:1355
uint32_t partial_bit_buffer
Definition: dv.c:703
void av_log(void *avcl, int level, const char *fmt,...)
Definition: log.c:140
int cno
Definition: dv.c:697
const char * name
Name of the codec implementation.
Definition: avcodec.h:3196
static void put_bits(PutBitContext *s, int n, unsigned int value)
Write up to 31 bits into a bitstream.
Definition: put_bits.h:136
#define CLOSE_READER(name, gb)
Definition: get_bits.h:140
int n_difchan
Definition: dvdata.h:49
void ff_simple_idct248_put(uint8_t *dest, int line_size, DCTELEM *block)
Definition: simple_idct.c:89
int dct_mode
Definition: dv.c:698
int8_t len
Definition: get_bits.h:71
Definition: get_bits.h:63
int off
Definition: dsputil_bfin.c:28
static int put_bits_count(PutBitContext *s)
Definition: put_bits.h:70
int difseg_size
Definition: dvdata.h:48
static void dv_calculate_mb_xy(DVVideoContext *s, DVwork_chunk *work_chunk, int m, int *mb_x, int *mb_y)
Definition: dv.c:445
static av_always_inline void emms_c(void)
Empty mmx state.
Definition: internal.h:240
static const int dv_iweight_1080_c[64]
Definition: dvdata.h:162
const DVprofile * sys
Definition: dv.c:54
AVRational time_base
Definition: dvdata.h:50
static const uint16_t dv_vlc_bits[409]
Definition: dv_vlc_data.h:39
AVFrame picture
Definition: dv.c:55
static DCTELEM block[64]
Definition: dct-test.c:189
enum AVPictureType pict_type
Picture type of the frame, see ?_TYPE below.
Definition: avcodec.h:1029
struct EncBlockInfo EncBlockInfo
int cur_ac
Definition: dv.c:696
int width
Definition: dvdata.h:53
uint32_t vlc
Definition: dv_tablegen.h:39
#define DV_VLC_MAP_RUN_SIZE
Definition: dv_tablegen.h:33
void(* fdct248)(DCTELEM *block)
Definition: dsputil.h:475
int width
picture width / height.
Definition: avcodec.h:1408
struct AVFrame AVFrame
Audio Video Frame.
#define NEG_USR32(a, s)
Definition: mathops.h:146
static DCTELEM block1[64]
Definition: dct-test.c:190
dv_pack_type
Definition: dvdata.h:244
int size_in_bits
Definition: get_bits.h:55
uint8_t sign[64]
Definition: dv.c:701
const char * av_get_pix_fmt_name(enum PixelFormat pix_fmt)
Return the short name for a pixel format, NULL in case pix_fmt is unknown.
Definition: pixdesc.c:1104
#define a2
Definition: regdef.h:48
uint32_t partial_bit_buffer
Definition: dv.c:367
static const int dv_iweight_88[64]
Definition: dvdata.h:128
static int dvvideo_close(AVCodecContext *c)
Definition: dv.c:1263
#define FFABS(a)
Definition: common.h:50
const DVprofile * avpriv_dv_codec_profile(AVCodecContext *codec)
Definition: dvdata.c:275
const uint8_t * scan_table
Definition: dv.c:363
static const int dv_weight_bits
Definition: dvdata.h:106
int frame_size
Definition: dvdata.h:47
#define TEX_VLC_BITS
Definition: dv.c:67
#define av_dlog(pctx,...)
av_dlog macros Useful to print debug messages that shouldn't get compiled in normally.
Definition: log.h:158
#define SHOW_UBITS(name, gb, num)
Definition: get_bits.h:186
static void dv_vlc_map_tableinit(void)
Definition: dv_tablegen.h:49
int prev[5]
Definition: dv.c:695
static void idct_put(FourXContext *f, int x, int y)
Definition: 4xm.c:481
NULL
Definition: eval.c:50
external API header
const uint32_t * factor_table
Definition: dv.c:362
int linesize[AV_NUM_DATA_POINTERS]
Size, in bytes, of the data for each picture/channel plane.
Definition: avcodec.h:1008
uint8_t pos
Definition: dv.c:364
int bit_size[4]
Definition: dv.c:694
main external API structure.
Definition: avcodec.h:1329
static void(WINAPI *cond_broadcast)(pthread_cond_t *cond)
static void close(AVCodecParserContext *s)
Definition: h264_parser.c:327
static const int dv_weight_248[64]
Definition: dvdata.h:117
void(* fdct[2])(DCTELEM *block)
Definition: dv.c:62
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:111
#define OPEN_READER(name, gb)
Definition: get_bits.h:124
#define DV_VLC_MAP_LEV_SIZE
Definition: dv_tablegen.h:34
#define init_vlc(vlc, nb_bits, nb_codes,bits, bits_wrap, bits_size,codes, codes_wrap, codes_size,flags)
Definition: get_bits.h:384
uint8_t dv_zigzag[2][64]
Definition: dv.c:59
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:268
int index
Definition: gxfenc.c:73
static const uint8_t dv100_qstep[16]
Definition: dvdata.h:98
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:354
static const uint8_t dv_vlc_level[409]
Definition: dv_vlc_data.h:204
#define FF_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
Definition: avcodec.h:497
uint8_t partial_bit_count
Definition: dv.c:366
static int dv_write_ssyb_id(uint8_t syb_num, uint8_t fr, uint8_t *buf)
Definition: dvdata.h:294
#define DV_MAX_BPM
maximum number of blocks per macroblock in any DV format
Definition: dvdata.h:275
uint32_t size
Definition: dv_tablegen.h:40
short DCTELEM
Definition: dsputil.h:39
const uint8_t * quant
#define MIN_CACHE_BITS
Definition: get_bits.h:120
DCTELEM mb[64]
Definition: dv.c:699
static int dv_init_dynamic_tables(const DVprofile *d)
Definition: dv.c:197
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: avcodec.h:997
uint8_t level
Definition: svq3.c:123
uint8_t run
Definition: get_bits.h:72
static void dv_decode_ac(GetBitContext *gb, BlockInfo *mb, DCTELEM *block)
Definition: dv.c:376
uint32_t * idct_factor
Definition: dvdata.h:56
PixelFormat
Pixel format.
Definition: pixfmt.h:62
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:474
static const uint8_t dv_vlc_len[409]
Definition: dv_vlc_data.h:94
static av_always_inline int dv_init_enc_block(EncBlockInfo *bi, uint8_t *data, int linesize, DVVideoContext *s, int bias)
Definition: dv.c:762
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: dvdata.h:34
static av_cold int dvvideo_init_encoder(AVCodecContext *avctx)
Definition: dv.c:350
void * priv_data
Definition: avcodec.h:1531
float re
Definition: fft-test.c:61
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:2403
int top_field_first
If the content is interlaced, is top field displayed first.
Definition: avcodec.h:1174
simple idct header.
static void dv_calc_mb_coordinates(const DVprofile *d, int chan, int seq, int slot, uint16_t *tbl)
Definition: dv.c:82
int len
Constants for DV codec.
int area_q[4]
Definition: dv.c:693
enum PixelFormat pix_fmt
Definition: dvdata.h:57
VLC_TYPE(* table)[2]
code, bits
Definition: get_bits.h:65
#define CODEC_CAP_SLICE_THREADS
Codec supports slice-based (or partition-based) multithreading.
Definition: avcodec.h:792
int key_frame
1 -> keyframe, 0-> not
Definition: avcodec.h:1022
int16_t level
Definition: get_bits.h:70
Definition: vf_drawbox.c:32
static av_cold int dvvideo_init(AVCodecContext *avctx)
Definition: dv.c:258
static int dv_decode_video_segment(AVCodecContext *avctx, void *arg)
Definition: dv.c:457
int video_stype
Definition: dvdata.h:46
#define av_always_inline
Definition: attributes.h:39
static int dv_write_dif_id(enum dv_section_type t, uint8_t chan_num, uint8_t seq_num, uint8_t dif_num, uint8_t *buf)
Definition: dvdata.h:281
static struct dv_vlc_pair dv_vlc_map[DV_VLC_MAP_RUN_SIZE][DV_VLC_MAP_LEV_SIZE]
Definition: dv_tablegen.h:47
DVwork_chunk * work_chunks
Definition: dvdata.h:55
void ff_free_vlc(VLC *vlc)
Definition: bitstream.c:321
uint8_t next[64]
Definition: dv.c:700
void(* idct_put)(uint8_t *dest, int line_size, DCTELEM *block)
Definition: dv.c:365
DSPContext.
Definition: dsputil.h:226
static av_always_inline PutBitContext * dv_encode_ac(EncBlockInfo *bi, PutBitContext *pb_pool, PutBitContext *pb_end)
Definition: dv.c:706
static const int dv_iweight_720_c[64]
Definition: dvdata.h:182
bitstream writer API