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