83b6960f38fcac585268906e6b2e384da0bf2da2
[libav.git] / libavcodec / dv.c
1 /*
2 * DV decoder
3 * Copyright (c) 2002 Fabrice Bellard
4 * Copyright (c) 2004 Roman Shaposhnik
5 *
6 * DV encoder
7 * Copyright (c) 2003 Roman Shaposhnik
8 *
9 * 50 Mbps (DVCPRO50) support
10 * Copyright (c) 2006 Daniel Maas <dmaas@maasdigital.com>
11 *
12 * 100 Mbps (DVCPRO HD) support
13 * Initial code by Daniel Maas <dmaas@maasdigital.com> (funded by BBC R&D)
14 * Final code by Roman Shaposhnik
15 *
16 * Many thanks to Dan Dennedy <dan@dennedy.org> for providing wealth
17 * of DV technical info.
18 *
19 * This file is part of Libav.
20 *
21 * Libav is free software; you can redistribute it and/or
22 * modify it under the terms of the GNU Lesser General Public
23 * License as published by the Free Software Foundation; either
24 * version 2.1 of the License, or (at your option) any later version.
25 *
26 * Libav is distributed in the hope that it will be useful,
27 * but WITHOUT ANY WARRANTY; without even the implied warranty of
28 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
29 * Lesser General Public License for more details.
30 *
31 * You should have received a copy of the GNU Lesser General Public
32 * License along with Libav; if not, write to the Free Software
33 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
34 */
35
36 /**
37 * @file
38 * DV codec.
39 */
40
41 #include "libavutil/pixdesc.h"
42 #include "avcodec.h"
43 #include "dsputil.h"
44 #include "get_bits.h"
45 #include "internal.h"
46 #include "put_bits.h"
47 #include "simple_idct.h"
48 #include "dvdata.h"
49 #include "dvquant.h"
50 #include "dv_tablegen.h"
51
52 /* XXX: also include quantization */
53 RL_VLC_ELEM ff_dv_rl_vlc[1184];
54
55 static inline void dv_calc_mb_coordinates(const DVprofile *d, int chan, int seq, int slot,
56 uint16_t *tbl)
57 {
58 static const uint8_t off[] = { 2, 6, 8, 0, 4 };
59 static const uint8_t shuf1[] = { 36, 18, 54, 0, 72 };
60 static const uint8_t shuf2[] = { 24, 12, 36, 0, 48 };
61 static const uint8_t shuf3[] = { 18, 9, 27, 0, 36 };
62
63 static const uint8_t l_start[] = {0, 4, 9, 13, 18, 22, 27, 31, 36, 40};
64 static const uint8_t l_start_shuffled[] = { 9, 4, 13, 0, 18 };
65
66 static const uint8_t serpent1[] = {0, 1, 2, 2, 1, 0,
67 0, 1, 2, 2, 1, 0,
68 0, 1, 2, 2, 1, 0,
69 0, 1, 2, 2, 1, 0,
70 0, 1, 2};
71 static const uint8_t serpent2[] = {0, 1, 2, 3, 4, 5, 5, 4, 3, 2, 1, 0,
72 0, 1, 2, 3, 4, 5, 5, 4, 3, 2, 1, 0,
73 0, 1, 2, 3, 4, 5};
74
75 static const uint8_t remap[][2] = {{ 0, 0}, { 0, 0}, { 0, 0}, { 0, 0}, /* dummy */
76 { 0, 0}, { 0, 1}, { 0, 2}, { 0, 3}, {10, 0},
77 {10, 1}, {10, 2}, {10, 3}, {20, 0}, {20, 1},
78 {20, 2}, {20, 3}, {30, 0}, {30, 1}, {30, 2},
79 {30, 3}, {40, 0}, {40, 1}, {40, 2}, {40, 3},
80 {50, 0}, {50, 1}, {50, 2}, {50, 3}, {60, 0},
81 {60, 1}, {60, 2}, {60, 3}, {70, 0}, {70, 1},
82 {70, 2}, {70, 3}, { 0,64}, { 0,65}, { 0,66},
83 {10,64}, {10,65}, {10,66}, {20,64}, {20,65},
84 {20,66}, {30,64}, {30,65}, {30,66}, {40,64},
85 {40,65}, {40,66}, {50,64}, {50,65}, {50,66},
86 {60,64}, {60,65}, {60,66}, {70,64}, {70,65},
87 {70,66}, { 0,67}, {20,67}, {40,67}, {60,67}};
88
89 int i, k, m;
90 int x, y, blk;
91
92 for (m=0; m<5; m++) {
93 switch (d->width) {
94 case 1440:
95 blk = (chan*11+seq)*27+slot;
96
97 if (chan == 0 && seq == 11) {
98 x = m*27+slot;
99 if (x<90) {
100 y = 0;
101 } else {
102 x = (x - 90)*2;
103 y = 67;
104 }
105 } else {
106 i = (4*chan + blk + off[m])%11;
107 k = (blk/11)%27;
108
109 x = shuf1[m] + (chan&1)*9 + k%9;
110 y = (i*3+k/9)*2 + (chan>>1) + 1;
111 }
112 tbl[m] = (x<<1)|(y<<9);
113 break;
114 case 1280:
115 blk = (chan*10+seq)*27+slot;
116
117 i = (4*chan + (seq/5) + 2*blk + off[m])%10;
118 k = (blk/5)%27;
119
120 x = shuf1[m]+(chan&1)*9 + k%9;
121 y = (i*3+k/9)*2 + (chan>>1) + 4;
122
123 if (x >= 80) {
124 x = remap[y][0]+((x-80)<<(y>59));
125 y = remap[y][1];
126 }
127 tbl[m] = (x<<1)|(y<<9);
128 break;
129 case 960:
130 blk = (chan*10+seq)*27+slot;
131
132 i = (4*chan + (seq/5) + 2*blk + off[m])%10;
133 k = (blk/5)%27 + (i&1)*3;
134
135 x = shuf2[m] + k%6 + 6*(chan&1);
136 y = l_start[i] + k/6 + 45*(chan>>1);
137 tbl[m] = (x<<1)|(y<<9);
138 break;
139 case 720:
140 switch (d->pix_fmt) {
141 case PIX_FMT_YUV422P:
142 x = shuf3[m] + slot/3;
143 y = serpent1[slot] +
144 ((((seq + off[m]) % d->difseg_size)<<1) + chan)*3;
145 tbl[m] = (x<<1)|(y<<8);
146 break;
147 case PIX_FMT_YUV420P:
148 x = shuf3[m] + slot/3;
149 y = serpent1[slot] +
150 ((seq + off[m]) % d->difseg_size)*3;
151 tbl[m] = (x<<1)|(y<<9);
152 break;
153 case PIX_FMT_YUV411P:
154 i = (seq + off[m]) % d->difseg_size;
155 k = slot + ((m==1||m==2)?3:0);
156
157 x = l_start_shuffled[m] + k/6;
158 y = serpent2[k] + i*6;
159 if (x>21)
160 y = y*2 - i*6;
161 tbl[m] = (x<<2)|(y<<8);
162 break;
163 }
164 default:
165 break;
166 }
167 }
168 }
169
170 int ff_dv_init_dynamic_tables(const DVprofile *d)
171 {
172 int j,i,c,s,p;
173 uint32_t *factor1, *factor2;
174 const int *iweight1, *iweight2;
175
176 if (!d->work_chunks[dv_work_pool_size(d)-1].buf_offset) {
177 p = i = 0;
178 for (c=0; c<d->n_difchan; c++) {
179 for (s=0; s<d->difseg_size; s++) {
180 p += 6;
181 for (j=0; j<27; j++) {
182 p += !(j%3);
183 if (!(DV_PROFILE_IS_1080i50(d) && c != 0 && s == 11) &&
184 !(DV_PROFILE_IS_720p50(d) && s > 9)) {
185 dv_calc_mb_coordinates(d, c, s, j, &d->work_chunks[i].mb_coordinates[0]);
186 d->work_chunks[i++].buf_offset = p;
187 }
188 p += 5;
189 }
190 }
191 }
192 }
193
194 if (!d->idct_factor[DV_PROFILE_IS_HD(d)?8191:5631]) {
195 factor1 = &d->idct_factor[0];
196 factor2 = &d->idct_factor[DV_PROFILE_IS_HD(d)?4096:2816];
197 if (d->height == 720) {
198 iweight1 = &dv_iweight_720_y[0];
199 iweight2 = &dv_iweight_720_c[0];
200 } else {
201 iweight1 = &dv_iweight_1080_y[0];
202 iweight2 = &dv_iweight_1080_c[0];
203 }
204 if (DV_PROFILE_IS_HD(d)) {
205 for (c = 0; c < 4; c++) {
206 for (s = 0; s < 16; s++) {
207 for (i = 0; i < 64; i++) {
208 *factor1++ = (dv100_qstep[s] << (c + 9)) * iweight1[i];
209 *factor2++ = (dv100_qstep[s] << (c + 9)) * iweight2[i];
210 }
211 }
212 }
213 } else {
214 iweight1 = &dv_iweight_88[0];
215 for (j = 0; j < 2; j++, iweight1 = &dv_iweight_248[0]) {
216 for (s = 0; s < 22; s++) {
217 for (i = c = 0; c < 4; c++) {
218 for (; i < dv_quant_areas[c]; i++) {
219 *factor1 = iweight1[i] << (dv_quant_shifts[s][c] + 1);
220 *factor2++ = (*factor1++) << 1;
221 }
222 }
223 }
224 }
225 }
226 }
227
228 return 0;
229 }
230
231 av_cold int ff_dvvideo_init(AVCodecContext *avctx)
232 {
233 DVVideoContext *s = avctx->priv_data;
234 DSPContext dsp;
235 static int done = 0;
236 int i, j;
237
238 if (!done) {
239 VLC dv_vlc;
240 uint16_t new_dv_vlc_bits[NB_DV_VLC*2];
241 uint8_t new_dv_vlc_len[NB_DV_VLC*2];
242 uint8_t new_dv_vlc_run[NB_DV_VLC*2];
243 int16_t new_dv_vlc_level[NB_DV_VLC*2];
244
245 done = 1;
246
247 /* it's faster to include sign bit in a generic VLC parsing scheme */
248 for (i = 0, j = 0; i < NB_DV_VLC; i++, j++) {
249 new_dv_vlc_bits[j] = dv_vlc_bits[i];
250 new_dv_vlc_len[j] = dv_vlc_len[i];
251 new_dv_vlc_run[j] = dv_vlc_run[i];
252 new_dv_vlc_level[j] = dv_vlc_level[i];
253
254 if (dv_vlc_level[i]) {
255 new_dv_vlc_bits[j] <<= 1;
256 new_dv_vlc_len[j]++;
257
258 j++;
259 new_dv_vlc_bits[j] = (dv_vlc_bits[i] << 1) | 1;
260 new_dv_vlc_len[j] = dv_vlc_len[i] + 1;
261 new_dv_vlc_run[j] = dv_vlc_run[i];
262 new_dv_vlc_level[j] = -dv_vlc_level[i];
263 }
264 }
265
266 /* NOTE: as a trick, we use the fact the no codes are unused
267 to accelerate the parsing of partial codes */
268 init_vlc(&dv_vlc, TEX_VLC_BITS, j,
269 new_dv_vlc_len, 1, 1, new_dv_vlc_bits, 2, 2, 0);
270 assert(dv_vlc.table_size == 1184);
271
272 for (i = 0; i < dv_vlc.table_size; i++){
273 int code = dv_vlc.table[i][0];
274 int len = dv_vlc.table[i][1];
275 int level, run;
276
277 if (len < 0){ //more bits needed
278 run = 0;
279 level = code;
280 } else {
281 run = new_dv_vlc_run [code] + 1;
282 level = new_dv_vlc_level[code];
283 }
284 ff_dv_rl_vlc[i].len = len;
285 ff_dv_rl_vlc[i].level = level;
286 ff_dv_rl_vlc[i].run = run;
287 }
288 ff_free_vlc(&dv_vlc);
289
290 dv_vlc_map_tableinit();
291 }
292
293 /* Generic DSP setup */
294 ff_dsputil_init(&dsp, avctx);
295 ff_set_cmp(&dsp, dsp.ildct_cmp, avctx->ildct_cmp);
296 s->get_pixels = dsp.get_pixels;
297 s->ildct_cmp = dsp.ildct_cmp[5];
298
299 /* 88DCT setup */
300 s->fdct[0] = dsp.fdct;
301 s->idct_put[0] = dsp.idct_put;
302 for (i = 0; i < 64; i++)
303 s->dv_zigzag[0][i] = dsp.idct_permutation[ff_zigzag_direct[i]];
304
305 /* 248DCT setup */
306 s->fdct[1] = dsp.fdct248;
307 s->idct_put[1] = ff_simple_idct248_put; // FIXME: need to add it to DSP
308 if (avctx->lowres){
309 for (i = 0; i < 64; i++){
310 int j = ff_zigzag248_direct[i];
311 s->dv_zigzag[1][i] = dsp.idct_permutation[(j & 7) + (j & 8) * 4 + (j & 48) / 2];
312 }
313 }else
314 memcpy(s->dv_zigzag[1], ff_zigzag248_direct, 64);
315
316 avctx->coded_frame = &s->picture;
317 s->avctx = avctx;
318 avctx->chroma_sample_location = AVCHROMA_LOC_TOPLEFT;
319
320 return 0;
321 }
322
323 static av_cold int dvvideo_init_encoder(AVCodecContext *avctx)
324 {
325 if (!avpriv_dv_codec_profile(avctx)) {
326 av_log(avctx, AV_LOG_ERROR, "Found no DV profile for %ix%i %s video. "
327 "Valid DV profiles are:\n",
328 avctx->width, avctx->height, av_get_pix_fmt_name(avctx->pix_fmt));
329 ff_dv_print_profiles(avctx, AV_LOG_ERROR);
330 return AVERROR(EINVAL);
331 }
332
333 return ff_dvvideo_init(avctx);
334 }
335
336 /* bit budget for AC only in 5 MBs */
337 static const int vs_total_ac_bits = (100 * 4 + 68*2) * 5;
338 static const int mb_area_start[5] = { 1, 6, 21, 43, 64 };
339
340 static inline int put_bits_left(PutBitContext* s)
341 {
342 return (s->buf_end - s->buf) * 8 - put_bits_count(s);
343 }
344
345 #if CONFIG_SMALL
346 /* Converts run and level (where level != 0) pair into VLC, returning bit size */
347 static av_always_inline int dv_rl2vlc(int run, int level, int sign, uint32_t* vlc)
348 {
349 int size;
350 if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {
351 *vlc = dv_vlc_map[run][level].vlc | sign;
352 size = dv_vlc_map[run][level].size;
353 }
354 else {
355 if (level < DV_VLC_MAP_LEV_SIZE) {
356 *vlc = dv_vlc_map[0][level].vlc | sign;
357 size = dv_vlc_map[0][level].size;
358 } else {
359 *vlc = 0xfe00 | (level << 1) | sign;
360 size = 16;
361 }
362 if (run) {
363 *vlc |= ((run < 16) ? dv_vlc_map[run-1][0].vlc :
364 (0x1f80 | (run - 1))) << size;
365 size += (run < 16) ? dv_vlc_map[run-1][0].size : 13;
366 }
367 }
368
369 return size;
370 }
371
372 static av_always_inline int dv_rl2vlc_size(int run, int level)
373 {
374 int size;
375
376 if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {
377 size = dv_vlc_map[run][level].size;
378 }
379 else {
380 size = (level < DV_VLC_MAP_LEV_SIZE) ? dv_vlc_map[0][level].size : 16;
381 if (run) {
382 size += (run < 16) ? dv_vlc_map[run-1][0].size : 13;
383 }
384 }
385 return size;
386 }
387 #else
388 static av_always_inline int dv_rl2vlc(int run, int l, int sign, uint32_t* vlc)
389 {
390 *vlc = dv_vlc_map[run][l].vlc | sign;
391 return dv_vlc_map[run][l].size;
392 }
393
394 static av_always_inline int dv_rl2vlc_size(int run, int l)
395 {
396 return dv_vlc_map[run][l].size;
397 }
398 #endif
399
400 typedef struct EncBlockInfo {
401 int area_q[4];
402 int bit_size[4];
403 int prev[5];
404 int cur_ac;
405 int cno;
406 int dct_mode;
407 DCTELEM mb[64];
408 uint8_t next[64];
409 uint8_t sign[64];
410 uint8_t partial_bit_count;
411 uint32_t partial_bit_buffer; /* we can't use uint16_t here */
412 } EncBlockInfo;
413
414 static av_always_inline PutBitContext* dv_encode_ac(EncBlockInfo* bi,
415 PutBitContext* pb_pool,
416 PutBitContext* pb_end)
417 {
418 int prev, bits_left;
419 PutBitContext* pb = pb_pool;
420 int size = bi->partial_bit_count;
421 uint32_t vlc = bi->partial_bit_buffer;
422
423 bi->partial_bit_count = bi->partial_bit_buffer = 0;
424 for (;;){
425 /* Find suitable storage space */
426 for (; size > (bits_left = put_bits_left(pb)); pb++) {
427 if (bits_left) {
428 size -= bits_left;
429 put_bits(pb, bits_left, vlc >> size);
430 vlc = vlc & ((1 << size) - 1);
431 }
432 if (pb + 1 >= pb_end) {
433 bi->partial_bit_count = size;
434 bi->partial_bit_buffer = vlc;
435 return pb;
436 }
437 }
438
439 /* Store VLC */
440 put_bits(pb, size, vlc);
441
442 if (bi->cur_ac >= 64)
443 break;
444
445 /* Construct the next VLC */
446 prev = bi->cur_ac;
447 bi->cur_ac = bi->next[prev];
448 if (bi->cur_ac < 64){
449 size = dv_rl2vlc(bi->cur_ac - prev - 1, bi->mb[bi->cur_ac], bi->sign[bi->cur_ac], &vlc);
450 } else {
451 size = 4; vlc = 6; /* End Of Block stamp */
452 }
453 }
454 return pb;
455 }
456
457 static av_always_inline int dv_guess_dct_mode(DVVideoContext *s, uint8_t *data, int linesize) {
458 if (s->avctx->flags & CODEC_FLAG_INTERLACED_DCT) {
459 int ps = s->ildct_cmp(NULL, data, NULL, linesize, 8) - 400;
460 if (ps > 0) {
461 int is = s->ildct_cmp(NULL, data , NULL, linesize<<1, 4) +
462 s->ildct_cmp(NULL, data + linesize, NULL, linesize<<1, 4);
463 return ps > is;
464 }
465 }
466
467 return 0;
468 }
469
470 static av_always_inline int dv_init_enc_block(EncBlockInfo* bi, uint8_t *data, int linesize, DVVideoContext *s, int bias)
471 {
472 const int *weight;
473 const uint8_t* zigzag_scan;
474 LOCAL_ALIGNED_16(DCTELEM, blk, [64]);
475 int i, area;
476 /* We offer two different methods for class number assignment: the
477 method suggested in SMPTE 314M Table 22, and an improved
478 method. The SMPTE method is very conservative; it assigns class
479 3 (i.e. severe quantization) to any block where the largest AC
480 component is greater than 36. Libav's DV encoder tracks AC bit
481 consumption precisely, so there is no need to bias most blocks
482 towards strongly lossy compression. Instead, we assign class 2
483 to most blocks, and use class 3 only when strictly necessary
484 (for blocks whose largest AC component exceeds 255). */
485
486 #if 0 /* SMPTE spec method */
487 static const int classes[] = {12, 24, 36, 0xffff};
488 #else /* improved Libav method */
489 static const int classes[] = {-1, -1, 255, 0xffff};
490 #endif
491 int max = classes[0];
492 int prev = 0;
493
494 assert((((int)blk) & 15) == 0);
495
496 bi->area_q[0] = bi->area_q[1] = bi->area_q[2] = bi->area_q[3] = 0;
497 bi->partial_bit_count = 0;
498 bi->partial_bit_buffer = 0;
499 bi->cur_ac = 0;
500 if (data) {
501 bi->dct_mode = dv_guess_dct_mode(s, data, linesize);
502 s->get_pixels(blk, data, linesize);
503 s->fdct[bi->dct_mode](blk);
504 } else {
505 /* We rely on the fact that encoding all zeros leads to an immediate EOB,
506 which is precisely what the spec calls for in the "dummy" blocks. */
507 memset(blk, 0, 64*sizeof(*blk));
508 bi->dct_mode = 0;
509 }
510 bi->mb[0] = blk[0];
511
512 zigzag_scan = bi->dct_mode ? ff_zigzag248_direct : ff_zigzag_direct;
513 weight = bi->dct_mode ? dv_weight_248 : dv_weight_88;
514
515 for (area = 0; area < 4; area++) {
516 bi->prev[area] = prev;
517 bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
518 for (i = mb_area_start[area]; i < mb_area_start[area+1]; i++) {
519 int level = blk[zigzag_scan[i]];
520
521 if (level + 15 > 30U) {
522 bi->sign[i] = (level >> 31) & 1;
523 /* weight it and and shift down into range, adding for rounding */
524 /* the extra division by a factor of 2^4 reverses the 8x expansion of the DCT
525 AND the 2x doubling of the weights */
526 level = (FFABS(level) * weight[i] + (1 << (dv_weight_bits+3))) >> (dv_weight_bits+4);
527 bi->mb[i] = level;
528 if (level > max)
529 max = level;
530 bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, level);
531 bi->next[prev]= i;
532 prev = i;
533 }
534 }
535 }
536 bi->next[prev]= i;
537 for (bi->cno = 0; max > classes[bi->cno]; bi->cno++);
538
539 bi->cno += bias;
540
541 if (bi->cno >= 3) {
542 bi->cno = 3;
543 prev = 0;
544 i = bi->next[prev];
545 for (area = 0; area < 4; area++) {
546 bi->prev[area] = prev;
547 bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
548 for (; i < mb_area_start[area+1]; i = bi->next[i]) {
549 bi->mb[i] >>= 1;
550
551 if (bi->mb[i]) {
552 bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, bi->mb[i]);
553 bi->next[prev]= i;
554 prev = i;
555 }
556 }
557 }
558 bi->next[prev]= i;
559 }
560
561 return bi->bit_size[0] + bi->bit_size[1] + bi->bit_size[2] + bi->bit_size[3];
562 }
563
564 static inline void dv_guess_qnos(EncBlockInfo* blks, int* qnos)
565 {
566 int size[5];
567 int i, j, k, a, prev, a2;
568 EncBlockInfo* b;
569
570 size[0] = size[1] = size[2] = size[3] = size[4] = 1 << 24;
571 do {
572 b = blks;
573 for (i = 0; i < 5; i++) {
574 if (!qnos[i])
575 continue;
576
577 qnos[i]--;
578 size[i] = 0;
579 for (j = 0; j < 6; j++, b++) {
580 for (a = 0; a < 4; a++) {
581 if (b->area_q[a] != dv_quant_shifts[qnos[i] + dv_quant_offset[b->cno]][a]) {
582 b->bit_size[a] = 1; // 4 areas 4 bits for EOB :)
583 b->area_q[a]++;
584 prev = b->prev[a];
585 assert(b->next[prev] >= mb_area_start[a+1] || b->mb[prev]);
586 for (k = b->next[prev] ; k < mb_area_start[a+1]; k = b->next[k]) {
587 b->mb[k] >>= 1;
588 if (b->mb[k]) {
589 b->bit_size[a] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
590 prev = k;
591 } else {
592 if (b->next[k] >= mb_area_start[a+1] && b->next[k]<64){
593 for (a2 = a + 1; b->next[k] >= mb_area_start[a2+1]; a2++)
594 b->prev[a2] = prev;
595 assert(a2 < 4);
596 assert(b->mb[b->next[k]]);
597 b->bit_size[a2] += dv_rl2vlc_size(b->next[k] - prev - 1, b->mb[b->next[k]])
598 -dv_rl2vlc_size(b->next[k] - k - 1, b->mb[b->next[k]]);
599 assert(b->prev[a2] == k && (a2 + 1 >= 4 || b->prev[a2+1] != k));
600 b->prev[a2] = prev;
601 }
602 b->next[prev] = b->next[k];
603 }
604 }
605 b->prev[a+1]= prev;
606 }
607 size[i] += b->bit_size[a];
608 }
609 }
610 if (vs_total_ac_bits >= size[0] + size[1] + size[2] + size[3] + size[4])
611 return;
612 }
613 } while (qnos[0]|qnos[1]|qnos[2]|qnos[3]|qnos[4]);
614
615
616 for (a = 2; a == 2 || vs_total_ac_bits < size[0]; a += a){
617 b = blks;
618 size[0] = 5 * 6 * 4; //EOB
619 for (j = 0; j < 6 *5; j++, b++) {
620 prev = b->prev[0];
621 for (k = b->next[prev]; k < 64; k = b->next[k]) {
622 if (b->mb[k] < a && b->mb[k] > -a){
623 b->next[prev] = b->next[k];
624 }else{
625 size[0] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
626 prev = k;
627 }
628 }
629 }
630 }
631 }
632
633 static int dv_encode_video_segment(AVCodecContext *avctx, void *arg)
634 {
635 DVVideoContext *s = avctx->priv_data;
636 DVwork_chunk *work_chunk = arg;
637 int mb_index, i, j;
638 int mb_x, mb_y, c_offset, linesize, y_stride;
639 uint8_t* y_ptr;
640 uint8_t* dif;
641 LOCAL_ALIGNED_8(uint8_t, scratch, [64]);
642 EncBlockInfo enc_blks[5*DV_MAX_BPM];
643 PutBitContext pbs[5*DV_MAX_BPM];
644 PutBitContext* pb;
645 EncBlockInfo* enc_blk;
646 int vs_bit_size = 0;
647 int qnos[5] = {15, 15, 15, 15, 15}; /* No quantization */
648 int* qnosp = &qnos[0];
649
650 dif = &s->buf[work_chunk->buf_offset*80];
651 enc_blk = &enc_blks[0];
652 for (mb_index = 0; mb_index < 5; mb_index++) {
653 dv_calculate_mb_xy(s, work_chunk, mb_index, &mb_x, &mb_y);
654
655 /* initializing luminance blocks */
656 if ((s->sys->pix_fmt == PIX_FMT_YUV420P) ||
657 (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8)) ||
658 (s->sys->height >= 720 && mb_y != 134)) {
659 y_stride = s->picture.linesize[0] << 3;
660 } else {
661 y_stride = 16;
662 }
663 y_ptr = s->picture.data[0] + ((mb_y * s->picture.linesize[0] + mb_x) << 3);
664 linesize = s->picture.linesize[0];
665
666 if (s->sys->video_stype == 4) { /* SD 422 */
667 vs_bit_size +=
668 dv_init_enc_block(enc_blk+0, y_ptr , linesize, s, 0) +
669 dv_init_enc_block(enc_blk+1, NULL , linesize, s, 0) +
670 dv_init_enc_block(enc_blk+2, y_ptr + 8 , linesize, s, 0) +
671 dv_init_enc_block(enc_blk+3, NULL , linesize, s, 0);
672 } else {
673 vs_bit_size +=
674 dv_init_enc_block(enc_blk+0, y_ptr , linesize, s, 0) +
675 dv_init_enc_block(enc_blk+1, y_ptr + 8 , linesize, s, 0) +
676 dv_init_enc_block(enc_blk+2, y_ptr + y_stride, linesize, s, 0) +
677 dv_init_enc_block(enc_blk+3, y_ptr + 8 + y_stride, linesize, s, 0);
678 }
679 enc_blk += 4;
680
681 /* initializing chrominance blocks */
682 c_offset = (((mb_y >> (s->sys->pix_fmt == PIX_FMT_YUV420P)) * s->picture.linesize[1] +
683 (mb_x >> ((s->sys->pix_fmt == PIX_FMT_YUV411P) ? 2 : 1))) << 3);
684 for (j = 2; j; j--) {
685 uint8_t *c_ptr = s->picture.data[j] + c_offset;
686 linesize = s->picture.linesize[j];
687 y_stride = (mb_y == 134) ? 8 : (s->picture.linesize[j] << 3);
688 if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8)) {
689 uint8_t* d;
690 uint8_t* b = scratch;
691 for (i = 0; i < 8; i++) {
692 d = c_ptr + (linesize << 3);
693 b[0] = c_ptr[0]; b[1] = c_ptr[1]; b[2] = c_ptr[2]; b[3] = c_ptr[3];
694 b[4] = d[0]; b[5] = d[1]; b[6] = d[2]; b[7] = d[3];
695 c_ptr += linesize;
696 b += 8;
697 }
698 c_ptr = scratch;
699 linesize = 8;
700 }
701
702 vs_bit_size += dv_init_enc_block( enc_blk++, c_ptr , linesize, s, 1);
703 if (s->sys->bpm == 8) {
704 vs_bit_size += dv_init_enc_block(enc_blk++, c_ptr + y_stride, linesize, s, 1);
705 }
706 }
707 }
708
709 if (vs_total_ac_bits < vs_bit_size)
710 dv_guess_qnos(&enc_blks[0], qnosp);
711
712 /* DIF encoding process */
713 for (j=0; j<5*s->sys->bpm;) {
714 int start_mb = j;
715
716 dif[3] = *qnosp++;
717 dif += 4;
718
719 /* First pass over individual cells only */
720 for (i=0; i<s->sys->bpm; i++, j++) {
721 int sz = s->sys->block_sizes[i]>>3;
722
723 init_put_bits(&pbs[j], dif, sz);
724 put_sbits(&pbs[j], 9, ((enc_blks[j].mb[0] >> 3) - 1024 + 2) >> 2);
725 put_bits(&pbs[j], 1, enc_blks[j].dct_mode);
726 put_bits(&pbs[j], 2, enc_blks[j].cno);
727
728 dv_encode_ac(&enc_blks[j], &pbs[j], &pbs[j+1]);
729 dif += sz;
730 }
731
732 /* Second pass over each MB space */
733 pb = &pbs[start_mb];
734 for (i=0; i<s->sys->bpm; i++) {
735 if (enc_blks[start_mb+i].partial_bit_count)
736 pb = dv_encode_ac(&enc_blks[start_mb+i], pb, &pbs[start_mb+s->sys->bpm]);
737 }
738 }
739
740 /* Third and final pass over the whole video segment space */
741 pb = &pbs[0];
742 for (j=0; j<5*s->sys->bpm; j++) {
743 if (enc_blks[j].partial_bit_count)
744 pb = dv_encode_ac(&enc_blks[j], pb, &pbs[s->sys->bpm*5]);
745 if (enc_blks[j].partial_bit_count)
746 av_log(avctx, AV_LOG_ERROR, "ac bitstream overflow\n");
747 }
748
749 for (j=0; j<5*s->sys->bpm; j++) {
750 int pos;
751 int size = pbs[j].size_in_bits >> 3;
752 flush_put_bits(&pbs[j]);
753 pos = put_bits_count(&pbs[j]) >> 3;
754 if (pos > size) {
755 av_log(avctx, AV_LOG_ERROR, "bitstream written beyond buffer size\n");
756 return -1;
757 }
758 memset(pbs[j].buf + pos, 0xff, size - pos);
759 }
760
761 return 0;
762 }
763
764 static inline int dv_write_pack(enum dv_pack_type pack_id, DVVideoContext *c,
765 uint8_t* buf)
766 {
767 /*
768 * Here's what SMPTE314M says about these two:
769 * (page 6) APTn, AP1n, AP2n, AP3n: These data shall be identical
770 * as track application IDs (APTn = 001, AP1n =
771 * 001, AP2n = 001, AP3n = 001), if the source signal
772 * comes from a digital VCR. If the signal source is
773 * unknown, all bits for these data shall be set to 1.
774 * (page 12) STYPE: STYPE defines a signal type of video signal
775 * 00000b = 4:1:1 compression
776 * 00100b = 4:2:2 compression
777 * XXXXXX = Reserved
778 * Now, I've got two problems with these statements:
779 * 1. it looks like APT == 111b should be a safe bet, but it isn't.
780 * It seems that for PAL as defined in IEC 61834 we have to set
781 * APT to 000 and for SMPTE314M to 001.
782 * 2. It is not at all clear what STYPE is used for 4:2:0 PAL
783 * compression scheme (if any).
784 */
785 int apt = (c->sys->pix_fmt == PIX_FMT_YUV420P ? 0 : 1);
786
787 uint8_t aspect = 0;
788 if ((int)(av_q2d(c->avctx->sample_aspect_ratio) * c->avctx->width / c->avctx->height * 10) >= 17) /* 16:9 */
789 aspect = 0x02;
790
791 buf[0] = (uint8_t)pack_id;
792 switch (pack_id) {
793 case dv_header525: /* I can't imagine why these two weren't defined as real */
794 case dv_header625: /* packs in SMPTE314M -- they definitely look like ones */
795 buf[1] = 0xf8 | /* reserved -- always 1 */
796 (apt & 0x07); /* APT: Track application ID */
797 buf[2] = (0 << 7) | /* TF1: audio data is 0 - valid; 1 - invalid */
798 (0x0f << 3) | /* reserved -- always 1 */
799 (apt & 0x07); /* AP1: Audio application ID */
800 buf[3] = (0 << 7) | /* TF2: video data is 0 - valid; 1 - invalid */
801 (0x0f << 3) | /* reserved -- always 1 */
802 (apt & 0x07); /* AP2: Video application ID */
803 buf[4] = (0 << 7) | /* TF3: subcode(SSYB) is 0 - valid; 1 - invalid */
804 (0x0f << 3) | /* reserved -- always 1 */
805 (apt & 0x07); /* AP3: Subcode application ID */
806 break;
807 case dv_video_source:
808 buf[1] = 0xff; /* reserved -- always 1 */
809 buf[2] = (1 << 7) | /* B/W: 0 - b/w, 1 - color */
810 (1 << 6) | /* following CLF is valid - 0, invalid - 1 */
811 (3 << 4) | /* CLF: color frames ID (see ITU-R BT.470-4) */
812 0xf; /* reserved -- always 1 */
813 buf[3] = (3 << 6) | /* reserved -- always 1 */
814 (c->sys->dsf << 5) | /* system: 60fields/50fields */
815 c->sys->video_stype; /* signal type video compression */
816 buf[4] = 0xff; /* VISC: 0xff -- no information */
817 break;
818 case dv_video_control:
819 buf[1] = (0 << 6) | /* Copy generation management (CGMS) 0 -- free */
820 0x3f; /* reserved -- always 1 */
821 buf[2] = 0xc8 | /* reserved -- always b11001xxx */
822 aspect;
823 buf[3] = (1 << 7) | /* frame/field flag 1 -- frame, 0 -- field */
824 (1 << 6) | /* first/second field flag 0 -- field 2, 1 -- field 1 */
825 (1 << 5) | /* frame change flag 0 -- same picture as before, 1 -- different */
826 (1 << 4) | /* 1 - interlaced, 0 - noninterlaced */
827 0xc; /* reserved -- always b1100 */
828 buf[4] = 0xff; /* reserved -- always 1 */
829 break;
830 default:
831 buf[1] = buf[2] = buf[3] = buf[4] = 0xff;
832 }
833 return 5;
834 }
835
836 #if CONFIG_DVVIDEO_ENCODER
837 static inline int dv_write_dif_id(enum dv_section_type t, uint8_t chan_num,
838 uint8_t seq_num, uint8_t dif_num,
839 uint8_t* buf)
840 {
841 buf[0] = (uint8_t)t; /* Section type */
842 buf[1] = (seq_num << 4) | /* DIF seq number 0-9 for 525/60; 0-11 for 625/50 */
843 (chan_num << 3) | /* FSC: for 50Mb/s 0 - first channel; 1 - second */
844 7; /* reserved -- always 1 */
845 buf[2] = dif_num; /* DIF block number Video: 0-134, Audio: 0-8 */
846 return 3;
847 }
848
849
850 static inline int dv_write_ssyb_id(uint8_t syb_num, uint8_t fr, uint8_t* buf)
851 {
852 if (syb_num == 0 || syb_num == 6) {
853 buf[0] = (fr << 7) | /* FR ID 1 - first half of each channel; 0 - second */
854 (0 << 4) | /* AP3 (Subcode application ID) */
855 0x0f; /* reserved -- always 1 */
856 }
857 else if (syb_num == 11) {
858 buf[0] = (fr << 7) | /* FR ID 1 - first half of each channel; 0 - second */
859 0x7f; /* reserved -- always 1 */
860 }
861 else {
862 buf[0] = (fr << 7) | /* FR ID 1 - first half of each channel; 0 - second */
863 (0 << 4) | /* APT (Track application ID) */
864 0x0f; /* reserved -- always 1 */
865 }
866 buf[1] = 0xf0 | /* reserved -- always 1 */
867 (syb_num & 0x0f); /* SSYB number 0 - 11 */
868 buf[2] = 0xff; /* reserved -- always 1 */
869 return 3;
870 }
871
872 static void dv_format_frame(DVVideoContext* c, uint8_t* buf)
873 {
874 int chan, i, j, k;
875
876 for (chan = 0; chan < c->sys->n_difchan; chan++) {
877 for (i = 0; i < c->sys->difseg_size; i++) {
878 memset(buf, 0xff, 80 * 6); /* first 6 DIF blocks are for control data */
879
880 /* DV header: 1DIF */
881 buf += dv_write_dif_id(dv_sect_header, chan, i, 0, buf);
882 buf += dv_write_pack((c->sys->dsf ? dv_header625 : dv_header525), c, buf);
883 buf += 72; /* unused bytes */
884
885 /* DV subcode: 2DIFs */
886 for (j = 0; j < 2; j++) {
887 buf += dv_write_dif_id(dv_sect_subcode, chan, i, j, buf);
888 for (k = 0; k < 6; k++)
889 buf += dv_write_ssyb_id(k, (i < c->sys->difseg_size/2), buf) + 5;
890 buf += 29; /* unused bytes */
891 }
892
893 /* DV VAUX: 3DIFS */
894 for (j = 0; j < 3; j++) {
895 buf += dv_write_dif_id(dv_sect_vaux, chan, i, j, buf);
896 buf += dv_write_pack(dv_video_source, c, buf);
897 buf += dv_write_pack(dv_video_control, c, buf);
898 buf += 7*5;
899 buf += dv_write_pack(dv_video_source, c, buf);
900 buf += dv_write_pack(dv_video_control, c, buf);
901 buf += 4*5 + 2; /* unused bytes */
902 }
903
904 /* DV Audio/Video: 135 Video DIFs + 9 Audio DIFs */
905 for (j = 0; j < 135; j++) {
906 if (j%15 == 0) {
907 memset(buf, 0xff, 80);
908 buf += dv_write_dif_id(dv_sect_audio, chan, i, j/15, buf);
909 buf += 77; /* audio control & shuffled PCM audio */
910 }
911 buf += dv_write_dif_id(dv_sect_video, chan, i, j, buf);
912 buf += 77; /* 1 video macroblock: 1 bytes control
913 4 * 14 bytes Y 8x8 data
914 10 bytes Cr 8x8 data
915 10 bytes Cb 8x8 data */
916 }
917 }
918 }
919 }
920
921
922 static int dvvideo_encode_frame(AVCodecContext *c, AVPacket *pkt,
923 const AVFrame *frame, int *got_packet)
924 {
925 DVVideoContext *s = c->priv_data;
926 int ret;
927
928 s->sys = avpriv_dv_codec_profile(c);
929 if (!s->sys || ff_dv_init_dynamic_tables(s->sys))
930 return -1;
931 if ((ret = ff_alloc_packet(pkt, s->sys->frame_size)) < 0) {
932 av_log(c, AV_LOG_ERROR, "Error getting output packet.\n");
933 return ret;
934 }
935
936 c->pix_fmt = s->sys->pix_fmt;
937 s->picture = *frame;
938 s->picture.key_frame = 1;
939 s->picture.pict_type = AV_PICTURE_TYPE_I;
940
941 s->buf = pkt->data;
942 c->execute(c, dv_encode_video_segment, s->sys->work_chunks, NULL,
943 dv_work_pool_size(s->sys), sizeof(DVwork_chunk));
944
945 emms_c();
946
947 dv_format_frame(s, pkt->data);
948
949 pkt->flags |= AV_PKT_FLAG_KEY;
950 *got_packet = 1;
951
952 return 0;
953 }
954
955 AVCodec ff_dvvideo_encoder = {
956 .name = "dvvideo",
957 .type = AVMEDIA_TYPE_VIDEO,
958 .id = CODEC_ID_DVVIDEO,
959 .priv_data_size = sizeof(DVVideoContext),
960 .init = dvvideo_init_encoder,
961 .encode2 = dvvideo_encode_frame,
962 .capabilities = CODEC_CAP_SLICE_THREADS,
963 .pix_fmts = (const enum PixelFormat[]) {PIX_FMT_YUV411P, PIX_FMT_YUV422P, PIX_FMT_YUV420P, PIX_FMT_NONE},
964 .long_name = NULL_IF_CONFIG_SMALL("DV (Digital Video)"),
965 };
966 #endif // CONFIG_DVVIDEO_ENCODER