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