FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
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 
36 /**
37  * @file
38  * DV codec.
39  */
40 
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  s->avctx = avctx;
325 
326  return 0;
327 }
328 
330 {
331  if (!avpriv_dv_codec_profile(avctx)) {
332  av_log(avctx, AV_LOG_ERROR, "Found no DV profile for %ix%i %s video. "
333  "Valid DV profiles are:\n",
334  avctx->width, avctx->height, av_get_pix_fmt_name(avctx->pix_fmt));
336  return AVERROR(EINVAL);
337  }
338  if (avctx->height > 576) {
339  av_log(avctx, AV_LOG_ERROR, "DVCPRO HD encoding is not supported.\n");
340  return AVERROR_PATCHWELCOME;
341  }
342 
343  avctx->coded_frame = av_frame_alloc();
344  if (!avctx->coded_frame)
345  return AVERROR(ENOMEM);
346 
348 
349  return ff_dvvideo_init(avctx);
350 }
351 
352 /* bit budget for AC only in 5 MBs */
353 static const int vs_total_ac_bits = (100 * 4 + 68*2) * 5;
354 static const int mb_area_start[5] = { 1, 6, 21, 43, 64 };
355 
356 #if CONFIG_SMALL
357 /* Converts run and level (where level != 0) pair into VLC, returning bit size */
358 static av_always_inline int dv_rl2vlc(int run, int level, int sign, uint32_t* vlc)
359 {
360  int size;
361  if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {
362  *vlc = dv_vlc_map[run][level].vlc | sign;
363  size = dv_vlc_map[run][level].size;
364  }
365  else {
366  if (level < DV_VLC_MAP_LEV_SIZE) {
367  *vlc = dv_vlc_map[0][level].vlc | sign;
368  size = dv_vlc_map[0][level].size;
369  } else {
370  *vlc = 0xfe00 | (level << 1) | sign;
371  size = 16;
372  }
373  if (run) {
374  *vlc |= ((run < 16) ? dv_vlc_map[run-1][0].vlc :
375  (0x1f80 | (run - 1))) << size;
376  size += (run < 16) ? dv_vlc_map[run-1][0].size : 13;
377  }
378  }
379 
380  return size;
381 }
382 
383 static av_always_inline int dv_rl2vlc_size(int run, int level)
384 {
385  int size;
386 
387  if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {
388  size = dv_vlc_map[run][level].size;
389  }
390  else {
391  size = (level < DV_VLC_MAP_LEV_SIZE) ? dv_vlc_map[0][level].size : 16;
392  if (run) {
393  size += (run < 16) ? dv_vlc_map[run-1][0].size : 13;
394  }
395  }
396  return size;
397 }
398 #else
399 static av_always_inline int dv_rl2vlc(int run, int l, int sign, uint32_t* vlc)
400 {
401  *vlc = dv_vlc_map[run][l].vlc | sign;
402  return dv_vlc_map[run][l].size;
403 }
404 
405 static av_always_inline int dv_rl2vlc_size(int run, int l)
406 {
407  return dv_vlc_map[run][l].size;
408 }
409 #endif
410 
411 typedef struct EncBlockInfo {
412  int area_q[4];
413  int bit_size[4];
414  int prev[5];
415  int cur_ac;
416  int cno;
417  int dct_mode;
418  int16_t mb[64];
420  uint8_t sign[64];
422  uint32_t partial_bit_buffer; /* we can't use uint16_t here */
423 } EncBlockInfo;
424 
426  PutBitContext* pb_pool,
427  PutBitContext* pb_end)
428 {
429  int prev, bits_left;
430  PutBitContext* pb = pb_pool;
431  int size = bi->partial_bit_count;
432  uint32_t vlc = bi->partial_bit_buffer;
433 
435  for (;;){
436  /* Find suitable storage space */
437  for (; size > (bits_left = put_bits_left(pb)); pb++) {
438  if (bits_left) {
439  size -= bits_left;
440  put_bits(pb, bits_left, vlc >> size);
441  vlc = vlc & ((1 << size) - 1);
442  }
443  if (pb + 1 >= pb_end) {
444  bi->partial_bit_count = size;
445  bi->partial_bit_buffer = vlc;
446  return pb;
447  }
448  }
449 
450  /* Store VLC */
451  put_bits(pb, size, vlc);
452 
453  if (bi->cur_ac >= 64)
454  break;
455 
456  /* Construct the next VLC */
457  prev = bi->cur_ac;
458  bi->cur_ac = bi->next[prev];
459  if (bi->cur_ac < 64){
460  size = dv_rl2vlc(bi->cur_ac - prev - 1, bi->mb[bi->cur_ac], bi->sign[bi->cur_ac], &vlc);
461  } else {
462  size = 4; vlc = 6; /* End Of Block stamp */
463  }
464  }
465  return pb;
466 }
467 
470  int ps = s->ildct_cmp(NULL, data, NULL, linesize, 8) - 400;
471  if (ps > 0) {
472  int is = s->ildct_cmp(NULL, data , NULL, linesize<<1, 4) +
473  s->ildct_cmp(NULL, data + linesize, NULL, linesize<<1, 4);
474  return ps > is;
475  }
476  }
477 
478  return 0;
479 }
480 
481 static const int dv_weight_bits = 18;
482 static const int dv_weight_88[64] = {
483  131072, 257107, 257107, 242189, 252167, 242189, 235923, 237536,
484  237536, 235923, 229376, 231390, 223754, 231390, 229376, 222935,
485  224969, 217965, 217965, 224969, 222935, 200636, 218652, 211916,
486  212325, 211916, 218652, 200636, 188995, 196781, 205965, 206433,
487  206433, 205965, 196781, 188995, 185364, 185364, 200636, 200704,
488  200636, 185364, 185364, 174609, 180568, 195068, 195068, 180568,
489  174609, 170091, 175557, 189591, 175557, 170091, 165371, 170627,
490  170627, 165371, 160727, 153560, 160727, 144651, 144651, 136258,
491 };
492 static const int dv_weight_248[64] = {
493  131072, 242189, 257107, 237536, 229376, 200636, 242189, 223754,
494  224969, 196781, 262144, 242189, 229376, 200636, 257107, 237536,
495  211916, 185364, 235923, 217965, 229376, 211916, 206433, 180568,
496  242189, 223754, 224969, 196781, 211916, 185364, 235923, 217965,
497  200704, 175557, 222935, 205965, 200636, 185364, 195068, 170627,
498  229376, 211916, 206433, 180568, 200704, 175557, 222935, 205965,
499  175557, 153560, 188995, 174609, 165371, 144651, 200636, 185364,
500  195068, 170627, 175557, 153560, 188995, 174609, 165371, 144651,
501 };
502 
503 static av_always_inline int dv_init_enc_block(EncBlockInfo* bi, uint8_t *data, int linesize, DVVideoContext *s, int bias)
504 {
505  const int *weight;
506  const uint8_t* zigzag_scan;
507  LOCAL_ALIGNED_16(int16_t, blk, [64]);
508  int i, area;
509  /* We offer two different methods for class number assignment: the
510  method suggested in SMPTE 314M Table 22, and an improved
511  method. The SMPTE method is very conservative; it assigns class
512  3 (i.e. severe quantization) to any block where the largest AC
513  component is greater than 36. FFmpeg's DV encoder tracks AC bit
514  consumption precisely, so there is no need to bias most blocks
515  towards strongly lossy compression. Instead, we assign class 2
516  to most blocks, and use class 3 only when strictly necessary
517  (for blocks whose largest AC component exceeds 255). */
518 
519 #if 0 /* SMPTE spec method */
520  static const int classes[] = {12, 24, 36, 0xffff};
521 #else /* improved FFmpeg method */
522  static const int classes[] = {-1, -1, 255, 0xffff};
523 #endif
524  int max = classes[0];
525  int prev = 0;
526 
527  av_assert2((((int)blk) & 15) == 0);
528 
529  bi->area_q[0] = bi->area_q[1] = bi->area_q[2] = bi->area_q[3] = 0;
530  bi->partial_bit_count = 0;
531  bi->partial_bit_buffer = 0;
532  bi->cur_ac = 0;
533  if (data) {
534  bi->dct_mode = dv_guess_dct_mode(s, data, linesize);
535  s->get_pixels(blk, data, linesize);
536  s->fdct[bi->dct_mode](blk);
537  } else {
538  /* We rely on the fact that encoding all zeros leads to an immediate EOB,
539  which is precisely what the spec calls for in the "dummy" blocks. */
540  memset(blk, 0, 64*sizeof(*blk));
541  bi->dct_mode = 0;
542  }
543  bi->mb[0] = blk[0];
544 
545  zigzag_scan = bi->dct_mode ? ff_zigzag248_direct : ff_zigzag_direct;
546  weight = bi->dct_mode ? dv_weight_248 : dv_weight_88;
547 
548  for (area = 0; area < 4; area++) {
549  bi->prev[area] = prev;
550  bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
551  for (i = mb_area_start[area]; i < mb_area_start[area+1]; i++) {
552  int level = blk[zigzag_scan[i]];
553 
554  if (level + 15 > 30U) {
555  bi->sign[i] = (level >> 31) & 1;
556  /* weight it and shift down into range, adding for rounding */
557  /* the extra division by a factor of 2^4 reverses the 8x expansion of the DCT
558  AND the 2x doubling of the weights */
559  level = (FFABS(level) * weight[i] + (1 << (dv_weight_bits+3))) >> (dv_weight_bits+4);
560  bi->mb[i] = level;
561  if (level > max)
562  max = level;
563  bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, level);
564  bi->next[prev]= i;
565  prev = i;
566  }
567  }
568  }
569  bi->next[prev]= i;
570  for (bi->cno = 0; max > classes[bi->cno]; bi->cno++);
571 
572  bi->cno += bias;
573 
574  if (bi->cno >= 3) {
575  bi->cno = 3;
576  prev = 0;
577  i = bi->next[prev];
578  for (area = 0; area < 4; area++) {
579  bi->prev[area] = prev;
580  bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
581  for (; i < mb_area_start[area+1]; i = bi->next[i]) {
582  bi->mb[i] >>= 1;
583 
584  if (bi->mb[i]) {
585  bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, bi->mb[i]);
586  bi->next[prev]= i;
587  prev = i;
588  }
589  }
590  }
591  bi->next[prev]= i;
592  }
593 
594  return bi->bit_size[0] + bi->bit_size[1] + bi->bit_size[2] + bi->bit_size[3];
595 }
596 
597 static inline void dv_guess_qnos(EncBlockInfo* blks, int* qnos)
598 {
599  int size[5];
600  int i, j, k, a, prev, a2;
601  EncBlockInfo* b;
602 
603  size[0] = size[1] = size[2] = size[3] = size[4] = 1 << 24;
604  do {
605  b = blks;
606  for (i = 0; i < 5; i++) {
607  if (!qnos[i])
608  continue;
609 
610  qnos[i]--;
611  size[i] = 0;
612  for (j = 0; j < 6; j++, b++) {
613  for (a = 0; a < 4; a++) {
614  if (b->area_q[a] != ff_dv_quant_shifts[qnos[i] + ff_dv_quant_offset[b->cno]][a]) {
615  b->bit_size[a] = 1; // 4 areas 4 bits for EOB :)
616  b->area_q[a]++;
617  prev = b->prev[a];
618  av_assert2(b->next[prev] >= mb_area_start[a+1] || b->mb[prev]);
619  for (k = b->next[prev] ; k < mb_area_start[a+1]; k = b->next[k]) {
620  b->mb[k] >>= 1;
621  if (b->mb[k]) {
622  b->bit_size[a] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
623  prev = k;
624  } else {
625  if (b->next[k] >= mb_area_start[a+1] && b->next[k]<64){
626  for (a2 = a + 1; b->next[k] >= mb_area_start[a2+1]; a2++)
627  b->prev[a2] = prev;
628  av_assert2(a2 < 4);
629  av_assert2(b->mb[b->next[k]]);
630  b->bit_size[a2] += dv_rl2vlc_size(b->next[k] - prev - 1, b->mb[b->next[k]])
631  -dv_rl2vlc_size(b->next[k] - k - 1, b->mb[b->next[k]]);
632  av_assert2(b->prev[a2] == k && (a2 + 1 >= 4 || b->prev[a2+1] != k));
633  b->prev[a2] = prev;
634  }
635  b->next[prev] = b->next[k];
636  }
637  }
638  b->prev[a+1]= prev;
639  }
640  size[i] += b->bit_size[a];
641  }
642  }
643  if (vs_total_ac_bits >= size[0] + size[1] + size[2] + size[3] + size[4])
644  return;
645  }
646  } while (qnos[0]|qnos[1]|qnos[2]|qnos[3]|qnos[4]);
647 
648 
649  for (a = 2; a == 2 || vs_total_ac_bits < size[0]; a += a){
650  b = blks;
651  size[0] = 5 * 6 * 4; //EOB
652  for (j = 0; j < 6 *5; j++, b++) {
653  prev = b->prev[0];
654  for (k = b->next[prev]; k < 64; k = b->next[k]) {
655  if (b->mb[k] < a && b->mb[k] > -a){
656  b->next[prev] = b->next[k];
657  }else{
658  size[0] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
659  prev = k;
660  }
661  }
662  }
663  }
664 }
665 
666 static int dv_encode_video_segment(AVCodecContext *avctx, void *arg)
667 {
668  DVVideoContext *s = avctx->priv_data;
669  DVwork_chunk *work_chunk = arg;
670  int mb_index, i, j;
671  int mb_x, mb_y, c_offset, linesize, y_stride;
672  uint8_t* y_ptr;
673  uint8_t* dif;
674  LOCAL_ALIGNED_8(uint8_t, scratch, [128]);
675  EncBlockInfo enc_blks[5*DV_MAX_BPM];
676  PutBitContext pbs[5*DV_MAX_BPM];
677  PutBitContext* pb;
678  EncBlockInfo* enc_blk;
679  int vs_bit_size = 0;
680  int qnos[5] = {15, 15, 15, 15, 15}; /* No quantization */
681  int* qnosp = &qnos[0];
682 
683  dif = &s->buf[work_chunk->buf_offset*80];
684  enc_blk = &enc_blks[0];
685  for (mb_index = 0; mb_index < 5; mb_index++) {
686  dv_calculate_mb_xy(s, work_chunk, mb_index, &mb_x, &mb_y);
687 
688  /* initializing luminance blocks */
689  if ((s->sys->pix_fmt == AV_PIX_FMT_YUV420P) ||
690  (s->sys->pix_fmt == AV_PIX_FMT_YUV411P && mb_x >= (704 / 8)) ||
691  (s->sys->height >= 720 && mb_y != 134)) {
692  y_stride = s->frame->linesize[0] << 3;
693  } else {
694  y_stride = 16;
695  }
696  y_ptr = s->frame->data[0] + ((mb_y * s->frame->linesize[0] + mb_x) << 3);
697  linesize = s->frame->linesize[0];
698 
699  if (s->sys->video_stype == 4) { /* SD 422 */
700  vs_bit_size +=
701  dv_init_enc_block(enc_blk+0, y_ptr , linesize, s, 0) +
702  dv_init_enc_block(enc_blk+1, NULL , linesize, s, 0) +
703  dv_init_enc_block(enc_blk+2, y_ptr + 8 , linesize, s, 0) +
704  dv_init_enc_block(enc_blk+3, NULL , linesize, s, 0);
705  } else {
706  vs_bit_size +=
707  dv_init_enc_block(enc_blk+0, y_ptr , linesize, s, 0) +
708  dv_init_enc_block(enc_blk+1, y_ptr + 8 , linesize, s, 0) +
709  dv_init_enc_block(enc_blk+2, y_ptr + y_stride, linesize, s, 0) +
710  dv_init_enc_block(enc_blk+3, y_ptr + 8 + y_stride, linesize, s, 0);
711  }
712  enc_blk += 4;
713 
714  /* initializing chrominance blocks */
715  c_offset = (((mb_y >> (s->sys->pix_fmt == AV_PIX_FMT_YUV420P)) * s->frame->linesize[1] +
716  (mb_x >> ((s->sys->pix_fmt == AV_PIX_FMT_YUV411P) ? 2 : 1))) << 3);
717  for (j = 2; j; j--) {
718  uint8_t *c_ptr = s->frame->data[j] + c_offset;
719  linesize = s->frame->linesize[j];
720  y_stride = (mb_y == 134) ? 8 : (s->frame->linesize[j] << 3);
721  if (s->sys->pix_fmt == AV_PIX_FMT_YUV411P && mb_x >= (704 / 8)) {
722  uint8_t* d;
723  uint8_t* b = scratch;
724  for (i = 0; i < 8; i++) {
725  d = c_ptr + (linesize << 3);
726  b[0] = c_ptr[0]; b[1] = c_ptr[1]; b[2] = c_ptr[2]; b[3] = c_ptr[3];
727  b[4] = d[0]; b[5] = d[1]; b[6] = d[2]; b[7] = d[3];
728  c_ptr += linesize;
729  b += 16;
730  }
731  c_ptr = scratch;
732  linesize = 16;
733  }
734 
735  vs_bit_size += dv_init_enc_block( enc_blk++, c_ptr , linesize, s, 1);
736  if (s->sys->bpm == 8) {
737  vs_bit_size += dv_init_enc_block(enc_blk++, c_ptr + y_stride, linesize, s, 1);
738  }
739  }
740  }
741 
742  if (vs_total_ac_bits < vs_bit_size)
743  dv_guess_qnos(&enc_blks[0], qnosp);
744 
745  /* DIF encoding process */
746  for (j=0; j<5*s->sys->bpm;) {
747  int start_mb = j;
748 
749  dif[3] = *qnosp++;
750  dif += 4;
751 
752  /* First pass over individual cells only */
753  for (i=0; i<s->sys->bpm; i++, j++) {
754  int sz = s->sys->block_sizes[i]>>3;
755 
756  init_put_bits(&pbs[j], dif, sz);
757  put_sbits(&pbs[j], 9, ((enc_blks[j].mb[0] >> 3) - 1024 + 2) >> 2);
758  put_bits(&pbs[j], 1, enc_blks[j].dct_mode);
759  put_bits(&pbs[j], 2, enc_blks[j].cno);
760 
761  dv_encode_ac(&enc_blks[j], &pbs[j], &pbs[j+1]);
762  dif += sz;
763  }
764 
765  /* Second pass over each MB space */
766  pb = &pbs[start_mb];
767  for (i=0; i<s->sys->bpm; i++) {
768  if (enc_blks[start_mb+i].partial_bit_count)
769  pb = dv_encode_ac(&enc_blks[start_mb+i], pb, &pbs[start_mb+s->sys->bpm]);
770  }
771  }
772 
773  /* Third and final pass over the whole video segment space */
774  pb = &pbs[0];
775  for (j=0; j<5*s->sys->bpm; j++) {
776  if (enc_blks[j].partial_bit_count)
777  pb = dv_encode_ac(&enc_blks[j], pb, &pbs[s->sys->bpm*5]);
778  if (enc_blks[j].partial_bit_count)
779  av_log(avctx, AV_LOG_ERROR, "ac bitstream overflow\n");
780  }
781 
782  for (j=0; j<5*s->sys->bpm; j++) {
783  int pos;
784  int size = pbs[j].size_in_bits >> 3;
785  flush_put_bits(&pbs[j]);
786  pos = put_bits_count(&pbs[j]) >> 3;
787  if (pos > size) {
788  av_log(avctx, AV_LOG_ERROR, "bitstream written beyond buffer size\n");
789  return -1;
790  }
791  memset(pbs[j].buf + pos, 0xff, size - pos);
792  }
793 
794  return 0;
795 }
796 
797 static inline int dv_write_pack(enum dv_pack_type pack_id, DVVideoContext *c,
798  uint8_t* buf)
799 {
800  /*
801  * Here's what SMPTE314M says about these two:
802  * (page 6) APTn, AP1n, AP2n, AP3n: These data shall be identical
803  * as track application IDs (APTn = 001, AP1n =
804  * 001, AP2n = 001, AP3n = 001), if the source signal
805  * comes from a digital VCR. If the signal source is
806  * unknown, all bits for these data shall be set to 1.
807  * (page 12) STYPE: STYPE defines a signal type of video signal
808  * 00000b = 4:1:1 compression
809  * 00100b = 4:2:2 compression
810  * XXXXXX = Reserved
811  * Now, I've got two problems with these statements:
812  * 1. it looks like APT == 111b should be a safe bet, but it isn't.
813  * It seems that for PAL as defined in IEC 61834 we have to set
814  * APT to 000 and for SMPTE314M to 001.
815  * 2. It is not at all clear what STYPE is used for 4:2:0 PAL
816  * compression scheme (if any).
817  */
818  int apt = (c->sys->pix_fmt == AV_PIX_FMT_YUV420P ? 0 : 1);
819  int fs = c->frame->top_field_first ? 0x00 : 0x40;
820 
821  uint8_t aspect = 0;
822  if ((int)(av_q2d(c->avctx->sample_aspect_ratio) * c->avctx->width / c->avctx->height * 10) >= 17) /* 16:9 */
823  aspect = 0x02;
824 
825  buf[0] = (uint8_t)pack_id;
826  switch (pack_id) {
827  case dv_header525: /* I can't imagine why these two weren't defined as real */
828  case dv_header625: /* packs in SMPTE314M -- they definitely look like ones */
829  buf[1] = 0xf8 | /* reserved -- always 1 */
830  (apt & 0x07); /* APT: Track application ID */
831  buf[2] = (0 << 7) | /* TF1: audio data is 0 - valid; 1 - invalid */
832  (0x0f << 3) | /* reserved -- always 1 */
833  (apt & 0x07); /* AP1: Audio application ID */
834  buf[3] = (0 << 7) | /* TF2: video data is 0 - valid; 1 - invalid */
835  (0x0f << 3) | /* reserved -- always 1 */
836  (apt & 0x07); /* AP2: Video application ID */
837  buf[4] = (0 << 7) | /* TF3: subcode(SSYB) is 0 - valid; 1 - invalid */
838  (0x0f << 3) | /* reserved -- always 1 */
839  (apt & 0x07); /* AP3: Subcode application ID */
840  break;
841  case dv_video_source:
842  buf[1] = 0xff; /* reserved -- always 1 */
843  buf[2] = (1 << 7) | /* B/W: 0 - b/w, 1 - color */
844  (1 << 6) | /* following CLF is valid - 0, invalid - 1 */
845  (3 << 4) | /* CLF: color frames ID (see ITU-R BT.470-4) */
846  0xf; /* reserved -- always 1 */
847  buf[3] = (3 << 6) | /* reserved -- always 1 */
848  (c->sys->dsf << 5) | /* system: 60fields/50fields */
849  c->sys->video_stype; /* signal type video compression */
850  buf[4] = 0xff; /* VISC: 0xff -- no information */
851  break;
852  case dv_video_control:
853  buf[1] = (0 << 6) | /* Copy generation management (CGMS) 0 -- free */
854  0x3f; /* reserved -- always 1 */
855  buf[2] = 0xc8 | /* reserved -- always b11001xxx */
856  aspect;
857  buf[3] = (1 << 7) | /* frame/field flag 1 -- frame, 0 -- field */
858  fs | /* first/second field flag 0 -- field 2, 1 -- field 1 */
859  (1 << 5) | /* frame change flag 0 -- same picture as before, 1 -- different */
860  (1 << 4) | /* 1 - interlaced, 0 - noninterlaced */
861  0xc; /* reserved -- always b1100 */
862  buf[4] = 0xff; /* reserved -- always 1 */
863  break;
864  default:
865  buf[1] = buf[2] = buf[3] = buf[4] = 0xff;
866  }
867  return 5;
868 }
869 
870 #if CONFIG_DVVIDEO_ENCODER
871 static inline int dv_write_dif_id(enum dv_section_type t, uint8_t chan_num,
872  uint8_t seq_num, uint8_t dif_num,
873  uint8_t* buf)
874 {
875  buf[0] = (uint8_t)t; /* Section type */
876  buf[1] = (seq_num << 4) | /* DIF seq number 0-9 for 525/60; 0-11 for 625/50 */
877  (chan_num << 3) | /* FSC: for 50Mb/s 0 - first channel; 1 - second */
878  7; /* reserved -- always 1 */
879  buf[2] = dif_num; /* DIF block number Video: 0-134, Audio: 0-8 */
880  return 3;
881 }
882 
883 
884 static inline int dv_write_ssyb_id(uint8_t syb_num, uint8_t fr, uint8_t* buf)
885 {
886  if (syb_num == 0 || syb_num == 6) {
887  buf[0] = (fr << 7) | /* FR ID 1 - first half of each channel; 0 - second */
888  (0 << 4) | /* AP3 (Subcode application ID) */
889  0x0f; /* reserved -- always 1 */
890  }
891  else if (syb_num == 11) {
892  buf[0] = (fr << 7) | /* FR ID 1 - first half of each channel; 0 - second */
893  0x7f; /* reserved -- always 1 */
894  }
895  else {
896  buf[0] = (fr << 7) | /* FR ID 1 - first half of each channel; 0 - second */
897  (0 << 4) | /* APT (Track application ID) */
898  0x0f; /* reserved -- always 1 */
899  }
900  buf[1] = 0xf0 | /* reserved -- always 1 */
901  (syb_num & 0x0f); /* SSYB number 0 - 11 */
902  buf[2] = 0xff; /* reserved -- always 1 */
903  return 3;
904 }
905 
906 static void dv_format_frame(DVVideoContext* c, uint8_t* buf)
907 {
908  int chan, i, j, k;
909 
910  for (chan = 0; chan < c->sys->n_difchan; chan++) {
911  for (i = 0; i < c->sys->difseg_size; i++) {
912  memset(buf, 0xff, 80 * 6); /* first 6 DIF blocks are for control data */
913 
914  /* DV header: 1DIF */
915  buf += dv_write_dif_id(dv_sect_header, chan, i, 0, buf);
916  buf += dv_write_pack((c->sys->dsf ? dv_header625 : dv_header525), c, buf);
917  buf += 72; /* unused bytes */
918 
919  /* DV subcode: 2DIFs */
920  for (j = 0; j < 2; j++) {
921  buf += dv_write_dif_id(dv_sect_subcode, chan, i, j, buf);
922  for (k = 0; k < 6; k++)
923  buf += dv_write_ssyb_id(k, (i < c->sys->difseg_size/2), buf) + 5;
924  buf += 29; /* unused bytes */
925  }
926 
927  /* DV VAUX: 3DIFS */
928  for (j = 0; j < 3; j++) {
929  buf += dv_write_dif_id(dv_sect_vaux, chan, i, j, buf);
930  buf += dv_write_pack(dv_video_source, c, buf);
931  buf += dv_write_pack(dv_video_control, c, buf);
932  buf += 7*5;
933  buf += dv_write_pack(dv_video_source, c, buf);
934  buf += dv_write_pack(dv_video_control, c, buf);
935  buf += 4*5 + 2; /* unused bytes */
936  }
937 
938  /* DV Audio/Video: 135 Video DIFs + 9 Audio DIFs */
939  for (j = 0; j < 135; j++) {
940  if (j%15 == 0) {
941  memset(buf, 0xff, 80);
942  buf += dv_write_dif_id(dv_sect_audio, chan, i, j/15, buf);
943  buf += 77; /* audio control & shuffled PCM audio */
944  }
945  buf += dv_write_dif_id(dv_sect_video, chan, i, j, buf);
946  buf += 77; /* 1 video macroblock: 1 bytes control
947  4 * 14 bytes Y 8x8 data
948  10 bytes Cr 8x8 data
949  10 bytes Cb 8x8 data */
950  }
951  }
952  }
953 }
954 
955 
956 static int dvvideo_encode_frame(AVCodecContext *c, AVPacket *pkt,
957  const AVFrame *frame, int *got_packet)
958 {
959  DVVideoContext *s = c->priv_data;
960  int ret;
961 
963  if (!s->sys || ff_dv_init_dynamic_tables(s->sys))
964  return -1;
965  if ((ret = ff_alloc_packet2(c, pkt, s->sys->frame_size)) < 0)
966  return ret;
967 
968  c->pix_fmt = s->sys->pix_fmt;
969  s->frame = frame;
970  c->coded_frame->key_frame = 1;
972 
973  s->buf = pkt->data;
975  dv_work_pool_size(s->sys), sizeof(DVwork_chunk));
976 
977  emms_c();
978 
979  dv_format_frame(s, pkt->data);
980 
981  pkt->flags |= AV_PKT_FLAG_KEY;
982  *got_packet = 1;
983 
984  return 0;
985 }
986 
987 static int dvvideo_encode_close(AVCodecContext *avctx)
988 {
989  av_frame_free(&avctx->coded_frame);
990  return 0;
991 }
992 
993 AVCodec ff_dvvideo_encoder = {
994  .name = "dvvideo",
995  .long_name = NULL_IF_CONFIG_SMALL("DV (Digital Video)"),
996  .type = AVMEDIA_TYPE_VIDEO,
997  .id = AV_CODEC_ID_DVVIDEO,
998  .priv_data_size = sizeof(DVVideoContext),
1000  .encode2 = dvvideo_encode_frame,
1001  .close = dvvideo_encode_close,
1002  .capabilities = CODEC_CAP_SLICE_THREADS,
1003  .pix_fmts = (const enum AVPixelFormat[]) {
1005  },
1006 };
1007 #endif // CONFIG_DVVIDEO_ENCODER