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 static inline int put_bits_left(PutBitContext* s)
376 {
377  return (s->buf_end - s->buf) * 8 - put_bits_count(s);
378 }
379 
380 /* decode AC coefficients */
382 {
383  int last_index = gb->size_in_bits;
384  const uint8_t *scan_table = mb->scan_table;
385  const uint32_t *factor_table = mb->factor_table;
386  int pos = mb->pos;
387  int partial_bit_count = mb->partial_bit_count;
388  int level, run, vlc_len, index;
389 
390  OPEN_READER(re, gb);
391  UPDATE_CACHE(re, gb);
392 
393  /* if we must parse a partial VLC, we do it here */
394  if (partial_bit_count > 0) {
395  re_cache = re_cache >> partial_bit_count | mb->partial_bit_buffer;
396  re_index -= partial_bit_count;
397  mb->partial_bit_count = 0;
398  }
399 
400  /* get the AC coefficients until last_index is reached */
401  for (;;) {
402  av_dlog(NULL, "%2d: bits=%04x index=%d\n", pos, SHOW_UBITS(re, gb, 16),
403  re_index);
404  /* our own optimized GET_RL_VLC */
405  index = NEG_USR32(re_cache, TEX_VLC_BITS);
406  vlc_len = dv_rl_vlc[index].len;
407  if (vlc_len < 0) {
408  index = NEG_USR32((unsigned)re_cache << TEX_VLC_BITS, -vlc_len) + dv_rl_vlc[index].level;
409  vlc_len = TEX_VLC_BITS - vlc_len;
410  }
411  level = dv_rl_vlc[index].level;
412  run = dv_rl_vlc[index].run;
413 
414  /* gotta check if we're still within gb boundaries */
415  if (re_index + vlc_len > last_index) {
416  /* should be < 16 bits otherwise a codeword could have been parsed */
417  mb->partial_bit_count = last_index - re_index;
418  mb->partial_bit_buffer = re_cache & ~(-1u >> mb->partial_bit_count);
419  re_index = last_index;
420  break;
421  }
422  re_index += vlc_len;
423 
424  av_dlog(NULL, "run=%d level=%d\n", run, level);
425  pos += run;
426  if (pos >= 64)
427  break;
428 
429  level = (level * factor_table[pos] + (1 << (dv_iweight_bits - 1))) >> dv_iweight_bits;
430  block[scan_table[pos]] = level;
431 
432  UPDATE_CACHE(re, gb);
433  }
434  CLOSE_READER(re, gb);
435  mb->pos = pos;
436 }
437 
438 static inline void bit_copy(PutBitContext *pb, GetBitContext *gb)
439 {
440  int bits_left = get_bits_left(gb);
441  while (bits_left >= MIN_CACHE_BITS) {
443  bits_left -= MIN_CACHE_BITS;
444  }
445  if (bits_left > 0) {
446  put_bits(pb, bits_left, get_bits(gb, bits_left));
447  }
448 }
449 
450 static inline void dv_calculate_mb_xy(DVVideoContext *s, DVwork_chunk *work_chunk, int m, int *mb_x, int *mb_y)
451 {
452  *mb_x = work_chunk->mb_coordinates[m] & 0xff;
453  *mb_y = work_chunk->mb_coordinates[m] >> 8;
454 
455  /* We work with 720p frames split in half. The odd half-frame (chan==2,3) is displaced :-( */
456  if (s->sys->height == 720 && !(s->buf[1]&0x0C)) {
457  *mb_y -= (*mb_y>17)?18:-72; /* shifting the Y coordinate down by 72/2 macro blocks */
458  }
459 }
460 
461 /* mb_x and mb_y are in units of 8 pixels */
462 static int dv_decode_video_segment(AVCodecContext *avctx, void *arg)
463 {
464  DVVideoContext *s = avctx->priv_data;
465  DVwork_chunk *work_chunk = arg;
466  int quant, dc, dct_mode, class1, j;
467  int mb_index, mb_x, mb_y, last_index;
468  int y_stride, linesize;
469  DCTELEM *block, *block1;
470  int c_offset;
471  uint8_t *y_ptr;
472  const uint8_t *buf_ptr;
473  PutBitContext pb, vs_pb;
474  GetBitContext gb;
475  BlockInfo mb_data[5 * DV_MAX_BPM], *mb, *mb1;
476  LOCAL_ALIGNED_16(DCTELEM, sblock, [5*DV_MAX_BPM], [64]);
477  LOCAL_ALIGNED_16(uint8_t, mb_bit_buffer, [ 80 + FF_INPUT_BUFFER_PADDING_SIZE]); /* allow some slack */
478  LOCAL_ALIGNED_16(uint8_t, vs_bit_buffer, [5*80 + FF_INPUT_BUFFER_PADDING_SIZE]); /* allow some slack */
479  const int log2_blocksize = 3-s->avctx->lowres;
480  int is_field_mode[5];
481 
482  assert((((int)mb_bit_buffer) & 7) == 0);
483  assert((((int)vs_bit_buffer) & 7) == 0);
484 
485  memset(sblock, 0, 5*DV_MAX_BPM*sizeof(*sblock));
486 
487  /* pass 1: read DC and AC coefficients in blocks */
488  buf_ptr = &s->buf[work_chunk->buf_offset*80];
489  block1 = &sblock[0][0];
490  mb1 = mb_data;
491  init_put_bits(&vs_pb, vs_bit_buffer, 5 * 80);
492  for (mb_index = 0; mb_index < 5; mb_index++, mb1 += s->sys->bpm, block1 += s->sys->bpm * 64) {
493  /* skip header */
494  quant = buf_ptr[3] & 0x0f;
495  buf_ptr += 4;
496  init_put_bits(&pb, mb_bit_buffer, 80);
497  mb = mb1;
498  block = block1;
499  is_field_mode[mb_index] = 0;
500  for (j = 0; j < s->sys->bpm; j++) {
501  last_index = s->sys->block_sizes[j];
502  init_get_bits(&gb, buf_ptr, last_index);
503 
504  /* get the DC */
505  dc = get_sbits(&gb, 9);
506  dct_mode = get_bits1(&gb);
507  class1 = get_bits(&gb, 2);
508  if (DV_PROFILE_IS_HD(s->sys)) {
509  mb->idct_put = s->idct_put[0];
510  mb->scan_table = s->dv_zigzag[0];
511  mb->factor_table = &s->sys->idct_factor[(j >= 4)*4*16*64 + class1*16*64 + quant*64];
512  is_field_mode[mb_index] |= !j && dct_mode;
513  } else {
514  mb->idct_put = s->idct_put[dct_mode && log2_blocksize == 3];
515  mb->scan_table = s->dv_zigzag[dct_mode];
516  mb->factor_table = &s->sys->idct_factor[(class1 == 3)*2*22*64 + dct_mode*22*64 +
517  (quant + dv_quant_offset[class1])*64];
518  }
519  dc = dc << 2;
520  /* convert to unsigned because 128 is not added in the
521  standard IDCT */
522  dc += 1024;
523  block[0] = dc;
524  buf_ptr += last_index >> 3;
525  mb->pos = 0;
526  mb->partial_bit_count = 0;
527 
528  av_dlog(avctx, "MB block: %d, %d ", mb_index, j);
529  dv_decode_ac(&gb, mb, block);
530 
531  /* write the remaining bits in a new buffer only if the
532  block is finished */
533  if (mb->pos >= 64)
534  bit_copy(&pb, &gb);
535 
536  block += 64;
537  mb++;
538  }
539 
540  /* pass 2: we can do it just after */
541  av_dlog(avctx, "***pass 2 size=%d MB#=%d\n", put_bits_count(&pb), mb_index);
542  block = block1;
543  mb = mb1;
544  init_get_bits(&gb, mb_bit_buffer, put_bits_count(&pb));
545  put_bits32(&pb, 0); // padding must be zeroed
546  flush_put_bits(&pb);
547  for (j = 0; j < s->sys->bpm; j++, block += 64, mb++) {
548  if (mb->pos < 64 && get_bits_left(&gb) > 0) {
549  dv_decode_ac(&gb, mb, block);
550  /* if still not finished, no need to parse other blocks */
551  if (mb->pos < 64)
552  break;
553  }
554  }
555  /* all blocks are finished, so the extra bytes can be used at
556  the video segment level */
557  if (j >= s->sys->bpm)
558  bit_copy(&vs_pb, &gb);
559  }
560 
561  /* we need a pass over the whole video segment */
562  av_dlog(avctx, "***pass 3 size=%d\n", put_bits_count(&vs_pb));
563  block = &sblock[0][0];
564  mb = mb_data;
565  init_get_bits(&gb, vs_bit_buffer, put_bits_count(&vs_pb));
566  put_bits32(&vs_pb, 0); // padding must be zeroed
567  flush_put_bits(&vs_pb);
568  for (mb_index = 0; mb_index < 5; mb_index++) {
569  for (j = 0; j < s->sys->bpm; j++) {
570  if (mb->pos < 64) {
571  av_dlog(avctx, "start %d:%d\n", mb_index, j);
572  dv_decode_ac(&gb, mb, block);
573  }
574  if (mb->pos >= 64 && mb->pos < 127)
575  av_log(avctx, AV_LOG_ERROR, "AC EOB marker is absent pos=%d\n", mb->pos);
576  block += 64;
577  mb++;
578  }
579  }
580 
581  /* compute idct and place blocks */
582  block = &sblock[0][0];
583  mb = mb_data;
584  for (mb_index = 0; mb_index < 5; mb_index++) {
585  dv_calculate_mb_xy(s, work_chunk, mb_index, &mb_x, &mb_y);
586 
587  /* idct_put'ting luminance */
588  if ((s->sys->pix_fmt == PIX_FMT_YUV420P) ||
589  (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8)) ||
590  (s->sys->height >= 720 && mb_y != 134)) {
591  y_stride = (s->picture.linesize[0] << ((!is_field_mode[mb_index]) * log2_blocksize));
592  } else {
593  y_stride = (2 << log2_blocksize);
594  }
595  y_ptr = s->picture.data[0] + ((mb_y * s->picture.linesize[0] + mb_x) << log2_blocksize);
596  linesize = s->picture.linesize[0] << is_field_mode[mb_index];
597  mb[0] .idct_put(y_ptr , linesize, block + 0*64);
598  if (s->sys->video_stype == 4) { /* SD 422 */
599  mb[2].idct_put(y_ptr + (1 << log2_blocksize) , linesize, block + 2*64);
600  } else {
601  mb[1].idct_put(y_ptr + (1 << log2_blocksize) , linesize, block + 1*64);
602  mb[2].idct_put(y_ptr + y_stride, linesize, block + 2*64);
603  mb[3].idct_put(y_ptr + (1 << log2_blocksize) + y_stride, linesize, block + 3*64);
604  }
605  mb += 4;
606  block += 4*64;
607 
608  /* idct_put'ting chrominance */
609  c_offset = (((mb_y >> (s->sys->pix_fmt == PIX_FMT_YUV420P)) * s->picture.linesize[1] +
610  (mb_x >> ((s->sys->pix_fmt == PIX_FMT_YUV411P) ? 2 : 1))) << log2_blocksize);
611  for (j = 2; j; j--) {
612  uint8_t *c_ptr = s->picture.data[j] + c_offset;
613  if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8)) {
614  uint64_t aligned_pixels[64/8];
615  uint8_t *pixels = (uint8_t*)aligned_pixels;
616  uint8_t *c_ptr1, *ptr1;
617  int x, y;
618  mb->idct_put(pixels, 8, block);
619  for (y = 0; y < (1 << log2_blocksize); y++, c_ptr += s->picture.linesize[j], pixels += 8) {
620  ptr1 = pixels + (1 << (log2_blocksize - 1));
621  c_ptr1 = c_ptr + (s->picture.linesize[j] << log2_blocksize);
622  for (x = 0; x < (1 << (log2_blocksize - 1)); x++) {
623  c_ptr[x] = pixels[x];
624  c_ptr1[x] = ptr1[x];
625  }
626  }
627  block += 64; mb++;
628  } else {
629  y_stride = (mb_y == 134) ? (1 << log2_blocksize) :
630  s->picture.linesize[j] << ((!is_field_mode[mb_index]) * log2_blocksize);
631  linesize = s->picture.linesize[j] << is_field_mode[mb_index];
632  (mb++)-> idct_put(c_ptr , linesize, block); block += 64;
633  if (s->sys->bpm == 8) {
634  (mb++)->idct_put(c_ptr + y_stride, linesize, block); block += 64;
635  }
636  }
637  }
638  }
639  return 0;
640 }
641 
642 #if CONFIG_SMALL
643 /* Converts run and level (where level != 0) pair into VLC, returning bit size */
644 static av_always_inline int dv_rl2vlc(int run, int level, int sign, uint32_t* vlc)
645 {
646  int size;
647  if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {
648  *vlc = dv_vlc_map[run][level].vlc | sign;
649  size = dv_vlc_map[run][level].size;
650  }
651  else {
652  if (level < DV_VLC_MAP_LEV_SIZE) {
653  *vlc = dv_vlc_map[0][level].vlc | sign;
654  size = dv_vlc_map[0][level].size;
655  } else {
656  *vlc = 0xfe00 | (level << 1) | sign;
657  size = 16;
658  }
659  if (run) {
660  *vlc |= ((run < 16) ? dv_vlc_map[run-1][0].vlc :
661  (0x1f80 | (run - 1))) << size;
662  size += (run < 16) ? dv_vlc_map[run-1][0].size : 13;
663  }
664  }
665 
666  return size;
667 }
668 
669 static av_always_inline int dv_rl2vlc_size(int run, int level)
670 {
671  int size;
672 
673  if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {
674  size = dv_vlc_map[run][level].size;
675  }
676  else {
677  size = (level < DV_VLC_MAP_LEV_SIZE) ? dv_vlc_map[0][level].size : 16;
678  if (run) {
679  size += (run < 16) ? dv_vlc_map[run-1][0].size : 13;
680  }
681  }
682  return size;
683 }
684 #else
685 static av_always_inline int dv_rl2vlc(int run, int l, int sign, uint32_t* vlc)
686 {
687  *vlc = dv_vlc_map[run][l].vlc | sign;
688  return dv_vlc_map[run][l].size;
689 }
690 
691 static av_always_inline int dv_rl2vlc_size(int run, int l)
692 {
693  return dv_vlc_map[run][l].size;
694 }
695 #endif
696 
697 typedef struct EncBlockInfo {
698  int area_q[4];
699  int bit_size[4];
700  int prev[5];
701  int cur_ac;
702  int cno;
703  int dct_mode;
704  DCTELEM mb[64];
705  uint8_t next[64];
706  uint8_t sign[64];
708  uint32_t partial_bit_buffer; /* we can't use uint16_t here */
709 } EncBlockInfo;
710 
712  PutBitContext* pb_pool,
713  PutBitContext* pb_end)
714 {
715  int prev, bits_left;
716  PutBitContext* pb = pb_pool;
717  int size = bi->partial_bit_count;
718  uint32_t vlc = bi->partial_bit_buffer;
719 
721  for (;;){
722  /* Find suitable storage space */
723  for (; size > (bits_left = put_bits_left(pb)); pb++) {
724  if (bits_left) {
725  size -= bits_left;
726  put_bits(pb, bits_left, vlc >> size);
727  vlc = vlc & ((1 << size) - 1);
728  }
729  if (pb + 1 >= pb_end) {
730  bi->partial_bit_count = size;
731  bi->partial_bit_buffer = vlc;
732  return pb;
733  }
734  }
735 
736  /* Store VLC */
737  put_bits(pb, size, vlc);
738 
739  if (bi->cur_ac >= 64)
740  break;
741 
742  /* Construct the next VLC */
743  prev = bi->cur_ac;
744  bi->cur_ac = bi->next[prev];
745  if (bi->cur_ac < 64){
746  size = dv_rl2vlc(bi->cur_ac - prev - 1, bi->mb[bi->cur_ac], bi->sign[bi->cur_ac], &vlc);
747  } else {
748  size = 4; vlc = 6; /* End Of Block stamp */
749  }
750  }
751  return pb;
752 }
753 
754 static av_always_inline int dv_guess_dct_mode(DVVideoContext *s, uint8_t *data, int linesize) {
756  int ps = s->ildct_cmp(NULL, data, NULL, linesize, 8) - 400;
757  if (ps > 0) {
758  int is = s->ildct_cmp(NULL, data , NULL, linesize<<1, 4) +
759  s->ildct_cmp(NULL, data + linesize, NULL, linesize<<1, 4);
760  return ps > is;
761  }
762  }
763 
764  return 0;
765 }
766 
767 static av_always_inline int dv_init_enc_block(EncBlockInfo* bi, uint8_t *data, int linesize, DVVideoContext *s, int bias)
768 {
769  const int *weight;
770  const uint8_t* zigzag_scan;
771  LOCAL_ALIGNED_16(DCTELEM, blk, [64]);
772  int i, area;
773  /* We offer two different methods for class number assignment: the
774  method suggested in SMPTE 314M Table 22, and an improved
775  method. The SMPTE method is very conservative; it assigns class
776  3 (i.e. severe quantization) to any block where the largest AC
777  component is greater than 36. Libav's DV encoder tracks AC bit
778  consumption precisely, so there is no need to bias most blocks
779  towards strongly lossy compression. Instead, we assign class 2
780  to most blocks, and use class 3 only when strictly necessary
781  (for blocks whose largest AC component exceeds 255). */
782 
783 #if 0 /* SMPTE spec method */
784  static const int classes[] = {12, 24, 36, 0xffff};
785 #else /* improved Libav method */
786  static const int classes[] = {-1, -1, 255, 0xffff};
787 #endif
788  int max = classes[0];
789  int prev = 0;
790 
791  assert((((int)blk) & 15) == 0);
792 
793  bi->area_q[0] = bi->area_q[1] = bi->area_q[2] = bi->area_q[3] = 0;
794  bi->partial_bit_count = 0;
795  bi->partial_bit_buffer = 0;
796  bi->cur_ac = 0;
797  if (data) {
798  bi->dct_mode = dv_guess_dct_mode(s, data, linesize);
799  s->get_pixels(blk, data, linesize);
800  s->fdct[bi->dct_mode](blk);
801  } else {
802  /* We rely on the fact that encoding all zeros leads to an immediate EOB,
803  which is precisely what the spec calls for in the "dummy" blocks. */
804  memset(blk, 0, 64*sizeof(*blk));
805  bi->dct_mode = 0;
806  }
807  bi->mb[0] = blk[0];
808 
809  zigzag_scan = bi->dct_mode ? ff_zigzag248_direct : ff_zigzag_direct;
810  weight = bi->dct_mode ? dv_weight_248 : dv_weight_88;
811 
812  for (area = 0; area < 4; area++) {
813  bi->prev[area] = prev;
814  bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
815  for (i = mb_area_start[area]; i < mb_area_start[area+1]; i++) {
816  int level = blk[zigzag_scan[i]];
817 
818  if (level + 15 > 30U) {
819  bi->sign[i] = (level >> 31) & 1;
820  /* weight it and and shift down into range, adding for rounding */
821  /* the extra division by a factor of 2^4 reverses the 8x expansion of the DCT
822  AND the 2x doubling of the weights */
823  level = (FFABS(level) * weight[i] + (1 << (dv_weight_bits+3))) >> (dv_weight_bits+4);
824  bi->mb[i] = level;
825  if (level > max)
826  max = level;
827  bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, level);
828  bi->next[prev]= i;
829  prev = i;
830  }
831  }
832  }
833  bi->next[prev]= i;
834  for (bi->cno = 0; max > classes[bi->cno]; bi->cno++);
835 
836  bi->cno += bias;
837 
838  if (bi->cno >= 3) {
839  bi->cno = 3;
840  prev = 0;
841  i = bi->next[prev];
842  for (area = 0; area < 4; area++) {
843  bi->prev[area] = prev;
844  bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
845  for (; i < mb_area_start[area+1]; i = bi->next[i]) {
846  bi->mb[i] >>= 1;
847 
848  if (bi->mb[i]) {
849  bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, bi->mb[i]);
850  bi->next[prev]= i;
851  prev = i;
852  }
853  }
854  }
855  bi->next[prev]= i;
856  }
857 
858  return bi->bit_size[0] + bi->bit_size[1] + bi->bit_size[2] + bi->bit_size[3];
859 }
860 
861 static inline void dv_guess_qnos(EncBlockInfo* blks, int* qnos)
862 {
863  int size[5];
864  int i, j, k, a, prev, a2;
865  EncBlockInfo* b;
866 
867  size[0] = size[1] = size[2] = size[3] = size[4] = 1 << 24;
868  do {
869  b = blks;
870  for (i = 0; i < 5; i++) {
871  if (!qnos[i])
872  continue;
873 
874  qnos[i]--;
875  size[i] = 0;
876  for (j = 0; j < 6; j++, b++) {
877  for (a = 0; a < 4; a++) {
878  if (b->area_q[a] != dv_quant_shifts[qnos[i] + dv_quant_offset[b->cno]][a]) {
879  b->bit_size[a] = 1; // 4 areas 4 bits for EOB :)
880  b->area_q[a]++;
881  prev = b->prev[a];
882  assert(b->next[prev] >= mb_area_start[a+1] || b->mb[prev]);
883  for (k = b->next[prev] ; k < mb_area_start[a+1]; k = b->next[k]) {
884  b->mb[k] >>= 1;
885  if (b->mb[k]) {
886  b->bit_size[a] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
887  prev = k;
888  } else {
889  if (b->next[k] >= mb_area_start[a+1] && b->next[k]<64){
890  for (a2 = a + 1; b->next[k] >= mb_area_start[a2+1]; a2++)
891  b->prev[a2] = prev;
892  assert(a2 < 4);
893  assert(b->mb[b->next[k]]);
894  b->bit_size[a2] += dv_rl2vlc_size(b->next[k] - prev - 1, b->mb[b->next[k]])
895  -dv_rl2vlc_size(b->next[k] - k - 1, b->mb[b->next[k]]);
896  assert(b->prev[a2] == k && (a2 + 1 >= 4 || b->prev[a2+1] != k));
897  b->prev[a2] = prev;
898  }
899  b->next[prev] = b->next[k];
900  }
901  }
902  b->prev[a+1]= prev;
903  }
904  size[i] += b->bit_size[a];
905  }
906  }
907  if (vs_total_ac_bits >= size[0] + size[1] + size[2] + size[3] + size[4])
908  return;
909  }
910  } while (qnos[0]|qnos[1]|qnos[2]|qnos[3]|qnos[4]);
911 
912 
913  for (a = 2; a == 2 || vs_total_ac_bits < size[0]; a += a){
914  b = blks;
915  size[0] = 5 * 6 * 4; //EOB
916  for (j = 0; j < 6 *5; j++, b++) {
917  prev = b->prev[0];
918  for (k = b->next[prev]; k < 64; k = b->next[k]) {
919  if (b->mb[k] < a && b->mb[k] > -a){
920  b->next[prev] = b->next[k];
921  }else{
922  size[0] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
923  prev = k;
924  }
925  }
926  }
927  }
928 }
929 
930 static int dv_encode_video_segment(AVCodecContext *avctx, void *arg)
931 {
932  DVVideoContext *s = avctx->priv_data;
933  DVwork_chunk *work_chunk = arg;
934  int mb_index, i, j;
935  int mb_x, mb_y, c_offset, linesize, y_stride;
936  uint8_t* y_ptr;
937  uint8_t* dif;
938  LOCAL_ALIGNED_8(uint8_t, scratch, [64]);
939  EncBlockInfo enc_blks[5*DV_MAX_BPM];
940  PutBitContext pbs[5*DV_MAX_BPM];
941  PutBitContext* pb;
942  EncBlockInfo* enc_blk;
943  int vs_bit_size = 0;
944  int qnos[5] = {15, 15, 15, 15, 15}; /* No quantization */
945  int* qnosp = &qnos[0];
946 
947  dif = &s->buf[work_chunk->buf_offset*80];
948  enc_blk = &enc_blks[0];
949  for (mb_index = 0; mb_index < 5; mb_index++) {
950  dv_calculate_mb_xy(s, work_chunk, mb_index, &mb_x, &mb_y);
951 
952  /* initializing luminance blocks */
953  if ((s->sys->pix_fmt == PIX_FMT_YUV420P) ||
954  (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8)) ||
955  (s->sys->height >= 720 && mb_y != 134)) {
956  y_stride = s->picture.linesize[0] << 3;
957  } else {
958  y_stride = 16;
959  }
960  y_ptr = s->picture.data[0] + ((mb_y * s->picture.linesize[0] + mb_x) << 3);
961  linesize = s->picture.linesize[0];
962 
963  if (s->sys->video_stype == 4) { /* SD 422 */
964  vs_bit_size +=
965  dv_init_enc_block(enc_blk+0, y_ptr , linesize, s, 0) +
966  dv_init_enc_block(enc_blk+1, NULL , linesize, s, 0) +
967  dv_init_enc_block(enc_blk+2, y_ptr + 8 , linesize, s, 0) +
968  dv_init_enc_block(enc_blk+3, NULL , linesize, s, 0);
969  } else {
970  vs_bit_size +=
971  dv_init_enc_block(enc_blk+0, y_ptr , linesize, s, 0) +
972  dv_init_enc_block(enc_blk+1, y_ptr + 8 , linesize, s, 0) +
973  dv_init_enc_block(enc_blk+2, y_ptr + y_stride, linesize, s, 0) +
974  dv_init_enc_block(enc_blk+3, y_ptr + 8 + y_stride, linesize, s, 0);
975  }
976  enc_blk += 4;
977 
978  /* initializing chrominance blocks */
979  c_offset = (((mb_y >> (s->sys->pix_fmt == PIX_FMT_YUV420P)) * s->picture.linesize[1] +
980  (mb_x >> ((s->sys->pix_fmt == PIX_FMT_YUV411P) ? 2 : 1))) << 3);
981  for (j = 2; j; j--) {
982  uint8_t *c_ptr = s->picture.data[j] + c_offset;
983  linesize = s->picture.linesize[j];
984  y_stride = (mb_y == 134) ? 8 : (s->picture.linesize[j] << 3);
985  if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8)) {
986  uint8_t* d;
987  uint8_t* b = scratch;
988  for (i = 0; i < 8; i++) {
989  d = c_ptr + (linesize << 3);
990  b[0] = c_ptr[0]; b[1] = c_ptr[1]; b[2] = c_ptr[2]; b[3] = c_ptr[3];
991  b[4] = d[0]; b[5] = d[1]; b[6] = d[2]; b[7] = d[3];
992  c_ptr += linesize;
993  b += 8;
994  }
995  c_ptr = scratch;
996  linesize = 8;
997  }
998 
999  vs_bit_size += dv_init_enc_block( enc_blk++, c_ptr , linesize, s, 1);
1000  if (s->sys->bpm == 8) {
1001  vs_bit_size += dv_init_enc_block(enc_blk++, c_ptr + y_stride, linesize, s, 1);
1002  }
1003  }
1004  }
1005 
1006  if (vs_total_ac_bits < vs_bit_size)
1007  dv_guess_qnos(&enc_blks[0], qnosp);
1008 
1009  /* DIF encoding process */
1010  for (j=0; j<5*s->sys->bpm;) {
1011  int start_mb = j;
1012 
1013  dif[3] = *qnosp++;
1014  dif += 4;
1015 
1016  /* First pass over individual cells only */
1017  for (i=0; i<s->sys->bpm; i++, j++) {
1018  int sz = s->sys->block_sizes[i]>>3;
1019 
1020  init_put_bits(&pbs[j], dif, sz);
1021  put_sbits(&pbs[j], 9, ((enc_blks[j].mb[0] >> 3) - 1024 + 2) >> 2);
1022  put_bits(&pbs[j], 1, enc_blks[j].dct_mode);
1023  put_bits(&pbs[j], 2, enc_blks[j].cno);
1024 
1025  dv_encode_ac(&enc_blks[j], &pbs[j], &pbs[j+1]);
1026  dif += sz;
1027  }
1028 
1029  /* Second pass over each MB space */
1030  pb = &pbs[start_mb];
1031  for (i=0; i<s->sys->bpm; i++) {
1032  if (enc_blks[start_mb+i].partial_bit_count)
1033  pb = dv_encode_ac(&enc_blks[start_mb+i], pb, &pbs[start_mb+s->sys->bpm]);
1034  }
1035  }
1036 
1037  /* Third and final pass over the whole video segment space */
1038  pb = &pbs[0];
1039  for (j=0; j<5*s->sys->bpm; j++) {
1040  if (enc_blks[j].partial_bit_count)
1041  pb = dv_encode_ac(&enc_blks[j], pb, &pbs[s->sys->bpm*5]);
1042  if (enc_blks[j].partial_bit_count)
1043  av_log(avctx, AV_LOG_ERROR, "ac bitstream overflow\n");
1044  }
1045 
1046  for (j=0; j<5*s->sys->bpm; j++) {
1047  int pos;
1048  int size = pbs[j].size_in_bits >> 3;
1049  flush_put_bits(&pbs[j]);
1050  pos = put_bits_count(&pbs[j]) >> 3;
1051  if (pos > size) {
1052  av_log(avctx, AV_LOG_ERROR, "bitstream written beyond buffer size\n");
1053  return -1;
1054  }
1055  memset(pbs[j].buf + pos, 0xff, size - pos);
1056  }
1057 
1058  return 0;
1059 }
1060 
1061 #if CONFIG_DVVIDEO_DECODER
1062 /* NOTE: exactly one frame must be given (120000 bytes for NTSC,
1063  144000 bytes for PAL - or twice those for 50Mbps) */
1064 static int dvvideo_decode_frame(AVCodecContext *avctx,
1065  void *data, int *data_size,
1066  AVPacket *avpkt)
1067 {
1068  const uint8_t *buf = avpkt->data;
1069  int buf_size = avpkt->size;
1070  DVVideoContext *s = avctx->priv_data;
1071  const uint8_t* vsc_pack;
1072  int apt, is16_9;
1073 
1074  s->sys = avpriv_dv_frame_profile(s->sys, buf, buf_size);
1075  if (!s->sys || buf_size < s->sys->frame_size || dv_init_dynamic_tables(s->sys)) {
1076  av_log(avctx, AV_LOG_ERROR, "could not find dv frame profile\n");
1077  return -1; /* NOTE: we only accept several full frames */
1078  }
1079 
1080  if (s->picture.data[0])
1081  avctx->release_buffer(avctx, &s->picture);
1082 
1083  s->picture.reference = 0;
1084  s->picture.key_frame = 1;
1086  avctx->pix_fmt = s->sys->pix_fmt;
1087  avctx->time_base = s->sys->time_base;
1088  avcodec_set_dimensions(avctx, s->sys->width, s->sys->height);
1089  if (avctx->get_buffer(avctx, &s->picture) < 0) {
1090  av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1091  return -1;
1092  }
1093  s->picture.interlaced_frame = 1;
1094  s->picture.top_field_first = 0;
1095 
1096  s->buf = buf;
1097  avctx->execute(avctx, dv_decode_video_segment, s->sys->work_chunks, NULL,
1098  dv_work_pool_size(s->sys), sizeof(DVwork_chunk));
1099 
1100  emms_c();
1101 
1102  /* return image */
1103  *data_size = sizeof(AVFrame);
1104  *(AVFrame*)data = s->picture;
1105 
1106  /* Determine the codec's sample_aspect ratio from the packet */
1107  vsc_pack = buf + 80*5 + 48 + 5;
1108  if ( *vsc_pack == dv_video_control ) {
1109  apt = buf[4] & 0x07;
1110  is16_9 = (vsc_pack && ((vsc_pack[2] & 0x07) == 0x02 || (!apt && (vsc_pack[2] & 0x07) == 0x07)));
1111  avctx->sample_aspect_ratio = s->sys->sar[is16_9];
1112  }
1113 
1114  return s->sys->frame_size;
1115 }
1116 #endif /* CONFIG_DVVIDEO_DECODER */
1117 
1118 
1119 static inline int dv_write_pack(enum dv_pack_type pack_id, DVVideoContext *c,
1120  uint8_t* buf)
1121 {
1122  /*
1123  * Here's what SMPTE314M says about these two:
1124  * (page 6) APTn, AP1n, AP2n, AP3n: These data shall be identical
1125  * as track application IDs (APTn = 001, AP1n =
1126  * 001, AP2n = 001, AP3n = 001), if the source signal
1127  * comes from a digital VCR. If the signal source is
1128  * unknown, all bits for these data shall be set to 1.
1129  * (page 12) STYPE: STYPE defines a signal type of video signal
1130  * 00000b = 4:1:1 compression
1131  * 00100b = 4:2:2 compression
1132  * XXXXXX = Reserved
1133  * Now, I've got two problems with these statements:
1134  * 1. it looks like APT == 111b should be a safe bet, but it isn't.
1135  * It seems that for PAL as defined in IEC 61834 we have to set
1136  * APT to 000 and for SMPTE314M to 001.
1137  * 2. It is not at all clear what STYPE is used for 4:2:0 PAL
1138  * compression scheme (if any).
1139  */
1140  int apt = (c->sys->pix_fmt == PIX_FMT_YUV420P ? 0 : 1);
1141 
1142  uint8_t aspect = 0;
1143  if ((int)(av_q2d(c->avctx->sample_aspect_ratio) * c->avctx->width / c->avctx->height * 10) >= 17) /* 16:9 */
1144  aspect = 0x02;
1145 
1146  buf[0] = (uint8_t)pack_id;
1147  switch (pack_id) {
1148  case dv_header525: /* I can't imagine why these two weren't defined as real */
1149  case dv_header625: /* packs in SMPTE314M -- they definitely look like ones */
1150  buf[1] = 0xf8 | /* reserved -- always 1 */
1151  (apt & 0x07); /* APT: Track application ID */
1152  buf[2] = (0 << 7) | /* TF1: audio data is 0 - valid; 1 - invalid */
1153  (0x0f << 3) | /* reserved -- always 1 */
1154  (apt & 0x07); /* AP1: Audio application ID */
1155  buf[3] = (0 << 7) | /* TF2: video data is 0 - valid; 1 - invalid */
1156  (0x0f << 3) | /* reserved -- always 1 */
1157  (apt & 0x07); /* AP2: Video application ID */
1158  buf[4] = (0 << 7) | /* TF3: subcode(SSYB) is 0 - valid; 1 - invalid */
1159  (0x0f << 3) | /* reserved -- always 1 */
1160  (apt & 0x07); /* AP3: Subcode application ID */
1161  break;
1162  case dv_video_source:
1163  buf[1] = 0xff; /* reserved -- always 1 */
1164  buf[2] = (1 << 7) | /* B/W: 0 - b/w, 1 - color */
1165  (1 << 6) | /* following CLF is valid - 0, invalid - 1 */
1166  (3 << 4) | /* CLF: color frames ID (see ITU-R BT.470-4) */
1167  0xf; /* reserved -- always 1 */
1168  buf[3] = (3 << 6) | /* reserved -- always 1 */
1169  (c->sys->dsf << 5) | /* system: 60fields/50fields */
1170  c->sys->video_stype; /* signal type video compression */
1171  buf[4] = 0xff; /* VISC: 0xff -- no information */
1172  break;
1173  case dv_video_control:
1174  buf[1] = (0 << 6) | /* Copy generation management (CGMS) 0 -- free */
1175  0x3f; /* reserved -- always 1 */
1176  buf[2] = 0xc8 | /* reserved -- always b11001xxx */
1177  aspect;
1178  buf[3] = (1 << 7) | /* frame/field flag 1 -- frame, 0 -- field */
1179  (1 << 6) | /* first/second field flag 0 -- field 2, 1 -- field 1 */
1180  (1 << 5) | /* frame change flag 0 -- same picture as before, 1 -- different */
1181  (1 << 4) | /* 1 - interlaced, 0 - noninterlaced */
1182  0xc; /* reserved -- always b1100 */
1183  buf[4] = 0xff; /* reserved -- always 1 */
1184  break;
1185  default:
1186  buf[1] = buf[2] = buf[3] = buf[4] = 0xff;
1187  }
1188  return 5;
1189 }
1190 
1191 #if CONFIG_DVVIDEO_ENCODER
1192 static void dv_format_frame(DVVideoContext* c, uint8_t* buf)
1193 {
1194  int chan, i, j, k;
1195 
1196  for (chan = 0; chan < c->sys->n_difchan; chan++) {
1197  for (i = 0; i < c->sys->difseg_size; i++) {
1198  memset(buf, 0xff, 80 * 6); /* first 6 DIF blocks are for control data */
1199 
1200  /* DV header: 1DIF */
1201  buf += dv_write_dif_id(dv_sect_header, chan, i, 0, buf);
1202  buf += dv_write_pack((c->sys->dsf ? dv_header625 : dv_header525), c, buf);
1203  buf += 72; /* unused bytes */
1204 
1205  /* DV subcode: 2DIFs */
1206  for (j = 0; j < 2; j++) {
1207  buf += dv_write_dif_id(dv_sect_subcode, chan, i, j, buf);
1208  for (k = 0; k < 6; k++)
1209  buf += dv_write_ssyb_id(k, (i < c->sys->difseg_size/2), buf) + 5;
1210  buf += 29; /* unused bytes */
1211  }
1212 
1213  /* DV VAUX: 3DIFS */
1214  for (j = 0; j < 3; j++) {
1215  buf += dv_write_dif_id(dv_sect_vaux, chan, i, j, buf);
1216  buf += dv_write_pack(dv_video_source, c, buf);
1217  buf += dv_write_pack(dv_video_control, c, buf);
1218  buf += 7*5;
1219  buf += dv_write_pack(dv_video_source, c, buf);
1220  buf += dv_write_pack(dv_video_control, c, buf);
1221  buf += 4*5 + 2; /* unused bytes */
1222  }
1223 
1224  /* DV Audio/Video: 135 Video DIFs + 9 Audio DIFs */
1225  for (j = 0; j < 135; j++) {
1226  if (j%15 == 0) {
1227  memset(buf, 0xff, 80);
1228  buf += dv_write_dif_id(dv_sect_audio, chan, i, j/15, buf);
1229  buf += 77; /* audio control & shuffled PCM audio */
1230  }
1231  buf += dv_write_dif_id(dv_sect_video, chan, i, j, buf);
1232  buf += 77; /* 1 video macroblock: 1 bytes control
1233  4 * 14 bytes Y 8x8 data
1234  10 bytes Cr 8x8 data
1235  10 bytes Cb 8x8 data */
1236  }
1237  }
1238  }
1239 }
1240 
1241 
1242 static int dvvideo_encode_frame(AVCodecContext *c, uint8_t *buf, int buf_size,
1243  void *data)
1244 {
1245  DVVideoContext *s = c->priv_data;
1246 
1247  s->sys = avpriv_dv_codec_profile(c);
1248  if (!s->sys || buf_size < s->sys->frame_size || dv_init_dynamic_tables(s->sys))
1249  return -1;
1250 
1251  c->pix_fmt = s->sys->pix_fmt;
1252  s->picture = *((AVFrame *)data);
1253  s->picture.key_frame = 1;
1255 
1256  s->buf = buf;
1258  dv_work_pool_size(s->sys), sizeof(DVwork_chunk));
1259 
1260  emms_c();
1261 
1262  dv_format_frame(s, buf);
1263 
1264  return s->sys->frame_size;
1265 }
1266 #endif
1267 
1269 {
1270  DVVideoContext *s = c->priv_data;
1271 
1272  if (s->picture.data[0])
1273  c->release_buffer(c, &s->picture);
1274 
1275  return 0;
1276 }
1277 
1278 
1279 #if CONFIG_DVVIDEO_ENCODER
1280 AVCodec ff_dvvideo_encoder = {
1281  .name = "dvvideo",
1282  .type = AVMEDIA_TYPE_VIDEO,
1283  .id = CODEC_ID_DVVIDEO,
1284  .priv_data_size = sizeof(DVVideoContext),
1286  .encode = dvvideo_encode_frame,
1287  .capabilities = CODEC_CAP_SLICE_THREADS,
1289  .long_name = NULL_IF_CONFIG_SMALL("DV (Digital Video)"),
1290 };
1291 #endif // CONFIG_DVVIDEO_ENCODER
1292 
1293 #if CONFIG_DVVIDEO_DECODER
1294 AVCodec ff_dvvideo_decoder = {
1295  .name = "dvvideo",
1296  .type = AVMEDIA_TYPE_VIDEO,
1297  .id = CODEC_ID_DVVIDEO,
1298  .priv_data_size = sizeof(DVVideoContext),
1299  .init = dvvideo_init,
1300  .close = dvvideo_close,
1301  .decode = dvvideo_decode_frame,
1302  .capabilities = CODEC_CAP_DR1 | CODEC_CAP_SLICE_THREADS,
1303  .max_lowres = 3,
1304  .long_name = NULL_IF_CONFIG_SMALL("DV (Digital Video)"),
1305 };
1306 #endif