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