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