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