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