74e29d8caa37898625916798c081e60a4db4815d
[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 "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
40 static av_cold int dvvideo_encode_init(AVCodecContext *avctx)
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));
53 ff_dv_print_profiles(avctx, AV_LOG_ERROR);
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
66 dv_vlc_map_tableinit();
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;
91 if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_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];
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 = bi->partial_bit_buffer = 0;
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
198 static av_always_inline int dv_guess_dct_mode(DVVideoContext *s, uint8_t *data, int linesize) {
199 if (s->avctx->flags & CODEC_FLAG_INTERLACED_DCT) {
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
634 static void dv_format_frame(DVVideoContext* c, uint8_t* buf)
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
684 static int dvvideo_encode_frame(AVCodecContext *c, AVPacket *pkt,
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;
698 c->coded_frame->pict_type = AV_PICTURE_TYPE_I;
699
700 s->buf = pkt->data;
701 c->execute(c, dv_encode_video_segment, s->work_chunks, NULL,
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
714 static int dvvideo_encode_close(AVCodecContext *avctx)
715 {
716 av_frame_free(&avctx->coded_frame);
717 return 0;
718 }
719
720 AVCodec ff_dvvideo_encoder = {
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),
726 .init = dvvideo_encode_init,
727 .encode2 = dvvideo_encode_frame,
728 .close = dvvideo_encode_close,
729 .capabilities = CODEC_CAP_SLICE_THREADS,
730 .pix_fmts = (const enum AVPixelFormat[]) {
731 AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE
732 },
733 };