FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
dvenc.c
Go to the documentation of this file.
1 /*
2  * DV encoder
3  * Copyright (c) 2003 Roman Shaposhnik
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
22 /**
23  * @file
24  * DV encoder
25  */
26 
27 #include "libavutil/attributes.h"
28 #include "libavutil/pixdesc.h"
29 #include "config.h"
30 #include "avcodec.h"
31 #include "internal.h"
32 #include "put_bits.h"
33 #include "dv.h"
34 #include "dv_tablegen.h"
35 
37 {
38  if (!avpriv_dv_codec_profile(avctx)) {
39  av_log(avctx, AV_LOG_ERROR, "Found no DV profile for %ix%i %s video. "
40  "Valid DV profiles are:\n",
41  avctx->width, avctx->height, av_get_pix_fmt_name(avctx->pix_fmt));
43  return AVERROR(EINVAL);
44  }
45  if (avctx->height > 576) {
46  av_log(avctx, AV_LOG_ERROR, "DVCPRO HD encoding is not supported.\n");
47  return AVERROR_PATCHWELCOME;
48  }
49 
50  avctx->coded_frame = av_frame_alloc();
51  if (!avctx->coded_frame)
52  return AVERROR(ENOMEM);
53 
55 
56  return ff_dvvideo_init(avctx);
57 }
58 
59 /* bit budget for AC only in 5 MBs */
60 static const int vs_total_ac_bits = (100 * 4 + 68*2) * 5;
61 static const int mb_area_start[5] = { 1, 6, 21, 43, 64 };
62 
63 #if CONFIG_SMALL
64 /* Converts run and level (where level != 0) pair into VLC, returning bit size */
65 static av_always_inline int dv_rl2vlc(int run, int level, int sign, uint32_t* vlc)
66 {
67  int size;
68  if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {
69  *vlc = dv_vlc_map[run][level].vlc | sign;
70  size = dv_vlc_map[run][level].size;
71  }
72  else {
73  if (level < DV_VLC_MAP_LEV_SIZE) {
74  *vlc = dv_vlc_map[0][level].vlc | sign;
75  size = dv_vlc_map[0][level].size;
76  } else {
77  *vlc = 0xfe00 | (level << 1) | sign;
78  size = 16;
79  }
80  if (run) {
81  *vlc |= ((run < 16) ? dv_vlc_map[run-1][0].vlc :
82  (0x1f80 | (run - 1))) << size;
83  size += (run < 16) ? dv_vlc_map[run-1][0].size : 13;
84  }
85  }
86 
87  return size;
88 }
89 
90 static av_always_inline int dv_rl2vlc_size(int run, int level)
91 {
92  int size;
93 
94  if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {
95  size = dv_vlc_map[run][level].size;
96  }
97  else {
98  size = (level < DV_VLC_MAP_LEV_SIZE) ? dv_vlc_map[0][level].size : 16;
99  if (run) {
100  size += (run < 16) ? dv_vlc_map[run-1][0].size : 13;
101  }
102  }
103  return size;
104 }
105 #else
106 static av_always_inline int dv_rl2vlc(int run, int l, int sign, uint32_t* vlc)
107 {
108  *vlc = dv_vlc_map[run][l].vlc | sign;
109  return dv_vlc_map[run][l].size;
110 }
111 
112 static av_always_inline int dv_rl2vlc_size(int run, int l)
113 {
114  return dv_vlc_map[run][l].size;
115 }
116 #endif
117 
118 typedef struct EncBlockInfo {
119  int area_q[4];
120  int bit_size[4];
121  int prev[5];
122  int cur_ac;
123  int cno;
124  int dct_mode;
125  int16_t mb[64];
127  uint8_t sign[64];
129  uint32_t partial_bit_buffer; /* we can't use uint16_t here */
130 } EncBlockInfo;
131 
133  PutBitContext* pb_pool,
134  PutBitContext* pb_end)
135 {
136  int prev, bits_left;
137  PutBitContext* pb = pb_pool;
138  int size = bi->partial_bit_count;
139  uint32_t vlc = bi->partial_bit_buffer;
140 
142  for (;;){
143  /* Find suitable storage space */
144  for (; size > (bits_left = put_bits_left(pb)); pb++) {
145  if (bits_left) {
146  size -= bits_left;
147  put_bits(pb, bits_left, vlc >> size);
148  vlc = vlc & ((1 << size) - 1);
149  }
150  if (pb + 1 >= pb_end) {
151  bi->partial_bit_count = size;
152  bi->partial_bit_buffer = vlc;
153  return pb;
154  }
155  }
156 
157  /* Store VLC */
158  put_bits(pb, size, vlc);
159 
160  if (bi->cur_ac >= 64)
161  break;
162 
163  /* Construct the next VLC */
164  prev = bi->cur_ac;
165  bi->cur_ac = bi->next[prev];
166  if (bi->cur_ac < 64){
167  size = dv_rl2vlc(bi->cur_ac - prev - 1, bi->mb[bi->cur_ac], bi->sign[bi->cur_ac], &vlc);
168  } else {
169  size = 4; vlc = 6; /* End Of Block stamp */
170  }
171  }
172  return pb;
173 }
174 
177  int ps = s->ildct_cmp(NULL, data, NULL, linesize, 8) - 400;
178  if (ps > 0) {
179  int is = s->ildct_cmp(NULL, data , NULL, linesize<<1, 4) +
180  s->ildct_cmp(NULL, data + linesize, NULL, linesize<<1, 4);
181  return ps > is;
182  }
183  }
184 
185  return 0;
186 }
187 
188 static const int dv_weight_bits = 18;
189 static const int dv_weight_88[64] = {
190  131072, 257107, 257107, 242189, 252167, 242189, 235923, 237536,
191  237536, 235923, 229376, 231390, 223754, 231390, 229376, 222935,
192  224969, 217965, 217965, 224969, 222935, 200636, 218652, 211916,
193  212325, 211916, 218652, 200636, 188995, 196781, 205965, 206433,
194  206433, 205965, 196781, 188995, 185364, 185364, 200636, 200704,
195  200636, 185364, 185364, 174609, 180568, 195068, 195068, 180568,
196  174609, 170091, 175557, 189591, 175557, 170091, 165371, 170627,
197  170627, 165371, 160727, 153560, 160727, 144651, 144651, 136258,
198 };
199 static const int dv_weight_248[64] = {
200  131072, 242189, 257107, 237536, 229376, 200636, 242189, 223754,
201  224969, 196781, 262144, 242189, 229376, 200636, 257107, 237536,
202  211916, 185364, 235923, 217965, 229376, 211916, 206433, 180568,
203  242189, 223754, 224969, 196781, 211916, 185364, 235923, 217965,
204  200704, 175557, 222935, 205965, 200636, 185364, 195068, 170627,
205  229376, 211916, 206433, 180568, 200704, 175557, 222935, 205965,
206  175557, 153560, 188995, 174609, 165371, 144651, 200636, 185364,
207  195068, 170627, 175557, 153560, 188995, 174609, 165371, 144651,
208 };
209 
210 static av_always_inline int dv_init_enc_block(EncBlockInfo* bi, uint8_t *data, int linesize, DVVideoContext *s, int bias)
211 {
212  const int *weight;
213  const uint8_t* zigzag_scan;
214  LOCAL_ALIGNED_16(int16_t, blk, [64]);
215  int i, area;
216  /* We offer two different methods for class number assignment: the
217  method suggested in SMPTE 314M Table 22, and an improved
218  method. The SMPTE method is very conservative; it assigns class
219  3 (i.e. severe quantization) to any block where the largest AC
220  component is greater than 36. FFmpeg's DV encoder tracks AC bit
221  consumption precisely, so there is no need to bias most blocks
222  towards strongly lossy compression. Instead, we assign class 2
223  to most blocks, and use class 3 only when strictly necessary
224  (for blocks whose largest AC component exceeds 255). */
225 
226 #if 0 /* SMPTE spec method */
227  static const int classes[] = {12, 24, 36, 0xffff};
228 #else /* improved FFmpeg method */
229  static const int classes[] = {-1, -1, 255, 0xffff};
230 #endif
231  int max = classes[0];
232  int prev = 0;
233 
234  av_assert2((((int)blk) & 15) == 0);
235 
236  bi->area_q[0] = bi->area_q[1] = bi->area_q[2] = bi->area_q[3] = 0;
237  bi->partial_bit_count = 0;
238  bi->partial_bit_buffer = 0;
239  bi->cur_ac = 0;
240  if (data) {
241  bi->dct_mode = dv_guess_dct_mode(s, data, linesize);
242  s->get_pixels(blk, data, linesize);
243  s->fdct[bi->dct_mode](blk);
244  } else {
245  /* We rely on the fact that encoding all zeros leads to an immediate EOB,
246  which is precisely what the spec calls for in the "dummy" blocks. */
247  memset(blk, 0, 64*sizeof(*blk));
248  bi->dct_mode = 0;
249  }
250  bi->mb[0] = blk[0];
251 
252  zigzag_scan = bi->dct_mode ? ff_zigzag248_direct : ff_zigzag_direct;
253  weight = bi->dct_mode ? dv_weight_248 : dv_weight_88;
254 
255  for (area = 0; area < 4; area++) {
256  bi->prev[area] = prev;
257  bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
258  for (i = mb_area_start[area]; i < mb_area_start[area+1]; i++) {
259  int level = blk[zigzag_scan[i]];
260 
261  if (level + 15 > 30U) {
262  bi->sign[i] = (level >> 31) & 1;
263  /* weight it and shift down into range, adding for rounding */
264  /* the extra division by a factor of 2^4 reverses the 8x expansion of the DCT
265  AND the 2x doubling of the weights */
266  level = (FFABS(level) * weight[i] + (1 << (dv_weight_bits+3))) >> (dv_weight_bits+4);
267  bi->mb[i] = level;
268  if (level > max)
269  max = level;
270  bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, level);
271  bi->next[prev]= i;
272  prev = i;
273  }
274  }
275  }
276  bi->next[prev]= i;
277  for (bi->cno = 0; max > classes[bi->cno]; bi->cno++);
278 
279  bi->cno += bias;
280 
281  if (bi->cno >= 3) {
282  bi->cno = 3;
283  prev = 0;
284  i = bi->next[prev];
285  for (area = 0; area < 4; area++) {
286  bi->prev[area] = prev;
287  bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
288  for (; i < mb_area_start[area+1]; i = bi->next[i]) {
289  bi->mb[i] >>= 1;
290 
291  if (bi->mb[i]) {
292  bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, bi->mb[i]);
293  bi->next[prev]= i;
294  prev = i;
295  }
296  }
297  }
298  bi->next[prev]= i;
299  }
300 
301  return bi->bit_size[0] + bi->bit_size[1] + bi->bit_size[2] + bi->bit_size[3];
302 }
303 
304 static inline void dv_guess_qnos(EncBlockInfo* blks, int* qnos)
305 {
306  int size[5];
307  int i, j, k, a, prev, a2;
308  EncBlockInfo* b;
309 
310  size[0] = size[1] = size[2] = size[3] = size[4] = 1 << 24;
311  do {
312  b = blks;
313  for (i = 0; i < 5; i++) {
314  if (!qnos[i])
315  continue;
316 
317  qnos[i]--;
318  size[i] = 0;
319  for (j = 0; j < 6; j++, b++) {
320  for (a = 0; a < 4; a++) {
321  if (b->area_q[a] != ff_dv_quant_shifts[qnos[i] + ff_dv_quant_offset[b->cno]][a]) {
322  b->bit_size[a] = 1; // 4 areas 4 bits for EOB :)
323  b->area_q[a]++;
324  prev = b->prev[a];
325  av_assert2(b->next[prev] >= mb_area_start[a+1] || b->mb[prev]);
326  for (k = b->next[prev] ; k < mb_area_start[a+1]; k = b->next[k]) {
327  b->mb[k] >>= 1;
328  if (b->mb[k]) {
329  b->bit_size[a] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
330  prev = k;
331  } else {
332  if (b->next[k] >= mb_area_start[a+1] && b->next[k]<64){
333  for (a2 = a + 1; b->next[k] >= mb_area_start[a2+1]; a2++)
334  b->prev[a2] = prev;
335  av_assert2(a2 < 4);
336  av_assert2(b->mb[b->next[k]]);
337  b->bit_size[a2] += dv_rl2vlc_size(b->next[k] - prev - 1, b->mb[b->next[k]])
338  -dv_rl2vlc_size(b->next[k] - k - 1, b->mb[b->next[k]]);
339  av_assert2(b->prev[a2] == k && (a2 + 1 >= 4 || b->prev[a2+1] != k));
340  b->prev[a2] = prev;
341  }
342  b->next[prev] = b->next[k];
343  }
344  }
345  b->prev[a+1]= prev;
346  }
347  size[i] += b->bit_size[a];
348  }
349  }
350  if (vs_total_ac_bits >= size[0] + size[1] + size[2] + size[3] + size[4])
351  return;
352  }
353  } while (qnos[0]|qnos[1]|qnos[2]|qnos[3]|qnos[4]);
354 
355 
356  for (a = 2; a == 2 || vs_total_ac_bits < size[0]; a += a){
357  b = blks;
358  size[0] = 5 * 6 * 4; //EOB
359  for (j = 0; j < 6 *5; j++, b++) {
360  prev = b->prev[0];
361  for (k = b->next[prev]; k < 64; k = b->next[k]) {
362  if (b->mb[k] < a && b->mb[k] > -a){
363  b->next[prev] = b->next[k];
364  }else{
365  size[0] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
366  prev = k;
367  }
368  }
369  }
370  }
371 }
372 
373 static int dv_encode_video_segment(AVCodecContext *avctx, void *arg)
374 {
375  DVVideoContext *s = avctx->priv_data;
376  DVwork_chunk *work_chunk = arg;
377  int mb_index, i, j;
378  int mb_x, mb_y, c_offset, linesize, y_stride;
379  uint8_t* y_ptr;
380  uint8_t* dif;
381  LOCAL_ALIGNED_8(uint8_t, scratch, [128]);
382  EncBlockInfo enc_blks[5*DV_MAX_BPM];
383  PutBitContext pbs[5*DV_MAX_BPM];
384  PutBitContext* pb;
385  EncBlockInfo* enc_blk;
386  int vs_bit_size = 0;
387  int qnos[5] = {15, 15, 15, 15, 15}; /* No quantization */
388  int* qnosp = &qnos[0];
389 
390  dif = &s->buf[work_chunk->buf_offset*80];
391  enc_blk = &enc_blks[0];
392  for (mb_index = 0; mb_index < 5; mb_index++) {
393  dv_calculate_mb_xy(s, work_chunk, mb_index, &mb_x, &mb_y);
394 
395  /* initializing luminance blocks */
396  if ((s->sys->pix_fmt == AV_PIX_FMT_YUV420P) ||
397  (s->sys->pix_fmt == AV_PIX_FMT_YUV411P && mb_x >= (704 / 8)) ||
398  (s->sys->height >= 720 && mb_y != 134)) {
399  y_stride = s->frame->linesize[0] << 3;
400  } else {
401  y_stride = 16;
402  }
403  y_ptr = s->frame->data[0] + ((mb_y * s->frame->linesize[0] + mb_x) << 3);
404  linesize = s->frame->linesize[0];
405 
406  if (s->sys->video_stype == 4) { /* SD 422 */
407  vs_bit_size +=
408  dv_init_enc_block(enc_blk+0, y_ptr , linesize, s, 0) +
409  dv_init_enc_block(enc_blk+1, NULL , linesize, s, 0) +
410  dv_init_enc_block(enc_blk+2, y_ptr + 8 , linesize, s, 0) +
411  dv_init_enc_block(enc_blk+3, NULL , linesize, s, 0);
412  } else {
413  vs_bit_size +=
414  dv_init_enc_block(enc_blk+0, y_ptr , linesize, s, 0) +
415  dv_init_enc_block(enc_blk+1, y_ptr + 8 , linesize, s, 0) +
416  dv_init_enc_block(enc_blk+2, y_ptr + y_stride, linesize, s, 0) +
417  dv_init_enc_block(enc_blk+3, y_ptr + 8 + y_stride, linesize, s, 0);
418  }
419  enc_blk += 4;
420 
421  /* initializing chrominance blocks */
422  c_offset = (((mb_y >> (s->sys->pix_fmt == AV_PIX_FMT_YUV420P)) * s->frame->linesize[1] +
423  (mb_x >> ((s->sys->pix_fmt == AV_PIX_FMT_YUV411P) ? 2 : 1))) << 3);
424  for (j = 2; j; j--) {
425  uint8_t *c_ptr = s->frame->data[j] + c_offset;
426  linesize = s->frame->linesize[j];
427  y_stride = (mb_y == 134) ? 8 : (s->frame->linesize[j] << 3);
428  if (s->sys->pix_fmt == AV_PIX_FMT_YUV411P && mb_x >= (704 / 8)) {
429  uint8_t* d;
430  uint8_t* b = scratch;
431  for (i = 0; i < 8; i++) {
432  d = c_ptr + (linesize << 3);
433  b[0] = c_ptr[0]; b[1] = c_ptr[1]; b[2] = c_ptr[2]; b[3] = c_ptr[3];
434  b[4] = d[0]; b[5] = d[1]; b[6] = d[2]; b[7] = d[3];
435  c_ptr += linesize;
436  b += 16;
437  }
438  c_ptr = scratch;
439  linesize = 16;
440  }
441 
442  vs_bit_size += dv_init_enc_block( enc_blk++, c_ptr , linesize, s, 1);
443  if (s->sys->bpm == 8) {
444  vs_bit_size += dv_init_enc_block(enc_blk++, c_ptr + y_stride, linesize, s, 1);
445  }
446  }
447  }
448 
449  if (vs_total_ac_bits < vs_bit_size)
450  dv_guess_qnos(&enc_blks[0], qnosp);
451 
452  /* DIF encoding process */
453  for (j=0; j<5*s->sys->bpm;) {
454  int start_mb = j;
455 
456  dif[3] = *qnosp++;
457  dif += 4;
458 
459  /* First pass over individual cells only */
460  for (i=0; i<s->sys->bpm; i++, j++) {
461  int sz = s->sys->block_sizes[i]>>3;
462 
463  init_put_bits(&pbs[j], dif, sz);
464  put_sbits(&pbs[j], 9, ((enc_blks[j].mb[0] >> 3) - 1024 + 2) >> 2);
465  put_bits(&pbs[j], 1, enc_blks[j].dct_mode);
466  put_bits(&pbs[j], 2, enc_blks[j].cno);
467 
468  dv_encode_ac(&enc_blks[j], &pbs[j], &pbs[j+1]);
469  dif += sz;
470  }
471 
472  /* Second pass over each MB space */
473  pb = &pbs[start_mb];
474  for (i=0; i<s->sys->bpm; i++) {
475  if (enc_blks[start_mb+i].partial_bit_count)
476  pb = dv_encode_ac(&enc_blks[start_mb+i], pb, &pbs[start_mb+s->sys->bpm]);
477  }
478  }
479 
480  /* Third and final pass over the whole video segment space */
481  pb = &pbs[0];
482  for (j=0; j<5*s->sys->bpm; j++) {
483  if (enc_blks[j].partial_bit_count)
484  pb = dv_encode_ac(&enc_blks[j], pb, &pbs[s->sys->bpm*5]);
485  if (enc_blks[j].partial_bit_count)
486  av_log(avctx, AV_LOG_ERROR, "ac bitstream overflow\n");
487  }
488 
489  for (j=0; j<5*s->sys->bpm; j++) {
490  int pos;
491  int size = pbs[j].size_in_bits >> 3;
492  flush_put_bits(&pbs[j]);
493  pos = put_bits_count(&pbs[j]) >> 3;
494  if (pos > size) {
495  av_log(avctx, AV_LOG_ERROR, "bitstream written beyond buffer size\n");
496  return -1;
497  }
498  memset(pbs[j].buf + pos, 0xff, size - pos);
499  }
500 
501  return 0;
502 }
503 
504 static inline int dv_write_pack(enum dv_pack_type pack_id, DVVideoContext *c,
505  uint8_t* buf)
506 {
507  /*
508  * Here's what SMPTE314M says about these two:
509  * (page 6) APTn, AP1n, AP2n, AP3n: These data shall be identical
510  * as track application IDs (APTn = 001, AP1n =
511  * 001, AP2n = 001, AP3n = 001), if the source signal
512  * comes from a digital VCR. If the signal source is
513  * unknown, all bits for these data shall be set to 1.
514  * (page 12) STYPE: STYPE defines a signal type of video signal
515  * 00000b = 4:1:1 compression
516  * 00100b = 4:2:2 compression
517  * XXXXXX = Reserved
518  * Now, I've got two problems with these statements:
519  * 1. it looks like APT == 111b should be a safe bet, but it isn't.
520  * It seems that for PAL as defined in IEC 61834 we have to set
521  * APT to 000 and for SMPTE314M to 001.
522  * 2. It is not at all clear what STYPE is used for 4:2:0 PAL
523  * compression scheme (if any).
524  */
525  int apt = (c->sys->pix_fmt == AV_PIX_FMT_YUV420P ? 0 : 1);
526  int fs = c->frame->top_field_first ? 0x00 : 0x40;
527 
528  uint8_t aspect = 0;
529  if ((int)(av_q2d(c->avctx->sample_aspect_ratio) * c->avctx->width / c->avctx->height * 10) >= 17) /* 16:9 */
530  aspect = 0x02;
531 
532  buf[0] = (uint8_t)pack_id;
533  switch (pack_id) {
534  case dv_header525: /* I can't imagine why these two weren't defined as real */
535  case dv_header625: /* packs in SMPTE314M -- they definitely look like ones */
536  buf[1] = 0xf8 | /* reserved -- always 1 */
537  (apt & 0x07); /* APT: Track application ID */
538  buf[2] = (0 << 7) | /* TF1: audio data is 0 - valid; 1 - invalid */
539  (0x0f << 3) | /* reserved -- always 1 */
540  (apt & 0x07); /* AP1: Audio application ID */
541  buf[3] = (0 << 7) | /* TF2: video data is 0 - valid; 1 - invalid */
542  (0x0f << 3) | /* reserved -- always 1 */
543  (apt & 0x07); /* AP2: Video application ID */
544  buf[4] = (0 << 7) | /* TF3: subcode(SSYB) is 0 - valid; 1 - invalid */
545  (0x0f << 3) | /* reserved -- always 1 */
546  (apt & 0x07); /* AP3: Subcode application ID */
547  break;
548  case dv_video_source:
549  buf[1] = 0xff; /* reserved -- always 1 */
550  buf[2] = (1 << 7) | /* B/W: 0 - b/w, 1 - color */
551  (1 << 6) | /* following CLF is valid - 0, invalid - 1 */
552  (3 << 4) | /* CLF: color frames ID (see ITU-R BT.470-4) */
553  0xf; /* reserved -- always 1 */
554  buf[3] = (3 << 6) | /* reserved -- always 1 */
555  (c->sys->dsf << 5) | /* system: 60fields/50fields */
556  c->sys->video_stype; /* signal type video compression */
557  buf[4] = 0xff; /* VISC: 0xff -- no information */
558  break;
559  case dv_video_control:
560  buf[1] = (0 << 6) | /* Copy generation management (CGMS) 0 -- free */
561  0x3f; /* reserved -- always 1 */
562  buf[2] = 0xc8 | /* reserved -- always b11001xxx */
563  aspect;
564  buf[3] = (1 << 7) | /* frame/field flag 1 -- frame, 0 -- field */
565  fs | /* first/second field flag 0 -- field 2, 1 -- field 1 */
566  (1 << 5) | /* frame change flag 0 -- same picture as before, 1 -- different */
567  (1 << 4) | /* 1 - interlaced, 0 - noninterlaced */
568  0xc; /* reserved -- always b1100 */
569  buf[4] = 0xff; /* reserved -- always 1 */
570  break;
571  default:
572  buf[1] = buf[2] = buf[3] = buf[4] = 0xff;
573  }
574  return 5;
575 }
576 
577 static inline int dv_write_dif_id(enum dv_section_type t, uint8_t chan_num,
578  uint8_t seq_num, uint8_t dif_num,
579  uint8_t* buf)
580 {
581  buf[0] = (uint8_t)t; /* Section type */
582  buf[1] = (seq_num << 4) | /* DIF seq number 0-9 for 525/60; 0-11 for 625/50 */
583  (chan_num << 3) | /* FSC: for 50Mb/s 0 - first channel; 1 - second */
584  7; /* reserved -- always 1 */
585  buf[2] = dif_num; /* DIF block number Video: 0-134, Audio: 0-8 */
586  return 3;
587 }
588 
589 
590 static inline int dv_write_ssyb_id(uint8_t syb_num, uint8_t fr, uint8_t* buf)
591 {
592  if (syb_num == 0 || syb_num == 6) {
593  buf[0] = (fr << 7) | /* FR ID 1 - first half of each channel; 0 - second */
594  (0 << 4) | /* AP3 (Subcode application ID) */
595  0x0f; /* reserved -- always 1 */
596  }
597  else if (syb_num == 11) {
598  buf[0] = (fr << 7) | /* FR ID 1 - first half of each channel; 0 - second */
599  0x7f; /* reserved -- always 1 */
600  }
601  else {
602  buf[0] = (fr << 7) | /* FR ID 1 - first half of each channel; 0 - second */
603  (0 << 4) | /* APT (Track application ID) */
604  0x0f; /* reserved -- always 1 */
605  }
606  buf[1] = 0xf0 | /* reserved -- always 1 */
607  (syb_num & 0x0f); /* SSYB number 0 - 11 */
608  buf[2] = 0xff; /* reserved -- always 1 */
609  return 3;
610 }
611 
613 {
614  int chan, i, j, k;
615 
616  for (chan = 0; chan < c->sys->n_difchan; chan++) {
617  for (i = 0; i < c->sys->difseg_size; i++) {
618  memset(buf, 0xff, 80 * 6); /* first 6 DIF blocks are for control data */
619 
620  /* DV header: 1DIF */
621  buf += dv_write_dif_id(dv_sect_header, chan, i, 0, buf);
622  buf += dv_write_pack((c->sys->dsf ? dv_header625 : dv_header525), c, buf);
623  buf += 72; /* unused bytes */
624 
625  /* DV subcode: 2DIFs */
626  for (j = 0; j < 2; j++) {
627  buf += dv_write_dif_id(dv_sect_subcode, chan, i, j, buf);
628  for (k = 0; k < 6; k++)
629  buf += dv_write_ssyb_id(k, (i < c->sys->difseg_size/2), buf) + 5;
630  buf += 29; /* unused bytes */
631  }
632 
633  /* DV VAUX: 3DIFS */
634  for (j = 0; j < 3; j++) {
635  buf += dv_write_dif_id(dv_sect_vaux, chan, i, j, buf);
636  buf += dv_write_pack(dv_video_source, c, buf);
637  buf += dv_write_pack(dv_video_control, c, buf);
638  buf += 7*5;
639  buf += dv_write_pack(dv_video_source, c, buf);
640  buf += dv_write_pack(dv_video_control, c, buf);
641  buf += 4*5 + 2; /* unused bytes */
642  }
643 
644  /* DV Audio/Video: 135 Video DIFs + 9 Audio DIFs */
645  for (j = 0; j < 135; j++) {
646  if (j%15 == 0) {
647  memset(buf, 0xff, 80);
648  buf += dv_write_dif_id(dv_sect_audio, chan, i, j/15, buf);
649  buf += 77; /* audio control & shuffled PCM audio */
650  }
651  buf += dv_write_dif_id(dv_sect_video, chan, i, j, buf);
652  buf += 77; /* 1 video macroblock: 1 bytes control
653  4 * 14 bytes Y 8x8 data
654  10 bytes Cr 8x8 data
655  10 bytes Cb 8x8 data */
656  }
657  }
658  }
659 }
660 
661 
663  const AVFrame *frame, int *got_packet)
664 {
665  DVVideoContext *s = c->priv_data;
666  int ret;
667 
669  if (!s->sys || ff_dv_init_dynamic_tables(s->sys))
670  return -1;
671  if ((ret = ff_alloc_packet2(c, pkt, s->sys->frame_size)) < 0)
672  return ret;
673 
674  c->pix_fmt = s->sys->pix_fmt;
675  s->frame = frame;
676  c->coded_frame->key_frame = 1;
678 
679  s->buf = pkt->data;
681  dv_work_pool_size(s->sys), sizeof(DVwork_chunk));
682 
683  emms_c();
684 
685  dv_format_frame(s, pkt->data);
686 
687  pkt->flags |= AV_PKT_FLAG_KEY;
688  *got_packet = 1;
689 
690  return 0;
691 }
692 
694 {
695  av_frame_free(&avctx->coded_frame);
696  return 0;
697 }
698 
700  .name = "dvvideo",
701  .long_name = NULL_IF_CONFIG_SMALL("DV (Digital Video)"),
702  .type = AVMEDIA_TYPE_VIDEO,
703  .id = AV_CODEC_ID_DVVIDEO,
704  .priv_data_size = sizeof(DVVideoContext),
706  .encode2 = dvvideo_encode_frame,
708  .capabilities = CODEC_CAP_SLICE_THREADS,
709  .pix_fmts = (const enum AVPixelFormat[]) {
711  },
712 };