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