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