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