DVCPRO50 support.
[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 * Many thanks to Dan Dennedy <dan@dennedy.org> for providing wealth
13 * of DV technical info.
14 *
15 * This library is free software; you can redistribute it and/or
16 * modify it under the terms of the GNU Lesser General Public
17 * License as published by the Free Software Foundation; either
18 * version 2 of the License, or (at your option) any later version.
19 *
20 * This library is distributed in the hope that it will be useful,
21 * but WITHOUT ANY WARRANTY; without even the implied warranty of
22 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
23 * Lesser General Public License for more details.
24 *
25 * You should have received a copy of the GNU Lesser General Public
26 * License along with this library; if not, write to the Free Software
27 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
28 */
29
30 /**
31 * @file dv.c
32 * DV codec.
33 */
34 #include "avcodec.h"
35 #include "dsputil.h"
36 #include "mpegvideo.h"
37 #include "simple_idct.h"
38 #include "dvdata.h"
39
40 //#undef NDEBUG
41 //#include <assert.h>
42
43 typedef struct DVVideoContext {
44 const DVprofile* sys;
45 AVFrame picture;
46 AVCodecContext *avctx;
47 uint8_t *buf;
48
49 uint8_t dv_zigzag[2][64];
50 uint8_t dv_idct_shift[2][2][22][64];
51
52 void (*get_pixels)(DCTELEM *block, const uint8_t *pixels, int line_size);
53 void (*fdct[2])(DCTELEM *block);
54 void (*idct_put[2])(uint8_t *dest, int line_size, DCTELEM *block);
55 } DVVideoContext;
56
57 /* MultiThreading - dv_anchor applies to entire DV codec, not just the avcontext */
58 /* one element is needed for each video segment in a DV frame */
59 /* at most there are 2 DIF channels * 12 DIF sequences * 27 video segments (PAL 50Mbps) */
60 #define DV_ANCHOR_SIZE (2*12*27)
61
62 static void* dv_anchor[DV_ANCHOR_SIZE];
63
64 #define TEX_VLC_BITS 9
65
66 #ifdef DV_CODEC_TINY_TARGET
67 #define DV_VLC_MAP_RUN_SIZE 15
68 #define DV_VLC_MAP_LEV_SIZE 23
69 #else
70 #define DV_VLC_MAP_RUN_SIZE 64
71 #define DV_VLC_MAP_LEV_SIZE 512 //FIXME sign was removed so this should be /2 but needs check
72 #endif
73
74 /* XXX: also include quantization */
75 static RL_VLC_ELEM *dv_rl_vlc;
76 /* VLC encoding lookup table */
77 static struct dv_vlc_pair {
78 uint32_t vlc;
79 uint8_t size;
80 } (*dv_vlc_map)[DV_VLC_MAP_LEV_SIZE] = NULL;
81
82 static void dv_build_unquantize_tables(DVVideoContext *s, uint8_t* perm)
83 {
84 int i, q, j;
85
86 /* NOTE: max left shift is 6 */
87 for(q = 0; q < 22; q++) {
88 /* 88DCT */
89 for(i = 1; i < 64; i++) {
90 /* 88 table */
91 j = perm[i];
92 s->dv_idct_shift[0][0][q][j] =
93 dv_quant_shifts[q][dv_88_areas[i]] + 1;
94 s->dv_idct_shift[1][0][q][j] = s->dv_idct_shift[0][0][q][j] + 1;
95 }
96
97 /* 248DCT */
98 for(i = 1; i < 64; i++) {
99 /* 248 table */
100 s->dv_idct_shift[0][1][q][i] =
101 dv_quant_shifts[q][dv_248_areas[i]] + 1;
102 s->dv_idct_shift[1][1][q][i] = s->dv_idct_shift[0][1][q][i] + 1;
103 }
104 }
105 }
106
107 static int dvvideo_init(AVCodecContext *avctx)
108 {
109 DVVideoContext *s = avctx->priv_data;
110 DSPContext dsp;
111 static int done=0;
112 int i, j;
113
114 if (!done) {
115 VLC dv_vlc;
116 uint16_t new_dv_vlc_bits[NB_DV_VLC*2];
117 uint8_t new_dv_vlc_len[NB_DV_VLC*2];
118 uint8_t new_dv_vlc_run[NB_DV_VLC*2];
119 int16_t new_dv_vlc_level[NB_DV_VLC*2];
120
121 done = 1;
122
123 dv_vlc_map = av_mallocz_static(DV_VLC_MAP_LEV_SIZE*DV_VLC_MAP_RUN_SIZE*sizeof(struct dv_vlc_pair));
124 if (!dv_vlc_map)
125 return -ENOMEM;
126
127 /* dv_anchor lets each thread know its Id */
128 for (i=0; i<DV_ANCHOR_SIZE; i++)
129 dv_anchor[i] = (void*)(size_t)i;
130
131 /* it's faster to include sign bit in a generic VLC parsing scheme */
132 for (i=0, j=0; i<NB_DV_VLC; i++, j++) {
133 new_dv_vlc_bits[j] = dv_vlc_bits[i];
134 new_dv_vlc_len[j] = dv_vlc_len[i];
135 new_dv_vlc_run[j] = dv_vlc_run[i];
136 new_dv_vlc_level[j] = dv_vlc_level[i];
137
138 if (dv_vlc_level[i]) {
139 new_dv_vlc_bits[j] <<= 1;
140 new_dv_vlc_len[j]++;
141
142 j++;
143 new_dv_vlc_bits[j] = (dv_vlc_bits[i] << 1) | 1;
144 new_dv_vlc_len[j] = dv_vlc_len[i] + 1;
145 new_dv_vlc_run[j] = dv_vlc_run[i];
146 new_dv_vlc_level[j] = -dv_vlc_level[i];
147 }
148 }
149
150 /* NOTE: as a trick, we use the fact the no codes are unused
151 to accelerate the parsing of partial codes */
152 init_vlc(&dv_vlc, TEX_VLC_BITS, j,
153 new_dv_vlc_len, 1, 1, new_dv_vlc_bits, 2, 2, 0);
154
155 dv_rl_vlc = av_mallocz_static(dv_vlc.table_size * sizeof(RL_VLC_ELEM));
156 if (!dv_rl_vlc)
157 return -ENOMEM;
158
159 for(i = 0; i < dv_vlc.table_size; i++){
160 int code= dv_vlc.table[i][0];
161 int len = dv_vlc.table[i][1];
162 int level, run;
163
164 if(len<0){ //more bits needed
165 run= 0;
166 level= code;
167 } else {
168 run= new_dv_vlc_run[code] + 1;
169 level= new_dv_vlc_level[code];
170 }
171 dv_rl_vlc[i].len = len;
172 dv_rl_vlc[i].level = level;
173 dv_rl_vlc[i].run = run;
174 }
175 free_vlc(&dv_vlc);
176
177 for (i = 0; i < NB_DV_VLC - 1; i++) {
178 if (dv_vlc_run[i] >= DV_VLC_MAP_RUN_SIZE)
179 continue;
180 #ifdef DV_CODEC_TINY_TARGET
181 if (dv_vlc_level[i] >= DV_VLC_MAP_LEV_SIZE)
182 continue;
183 #endif
184
185 if (dv_vlc_map[dv_vlc_run[i]][dv_vlc_level[i]].size != 0)
186 continue;
187
188 dv_vlc_map[dv_vlc_run[i]][dv_vlc_level[i]].vlc = dv_vlc_bits[i] <<
189 (!!dv_vlc_level[i]);
190 dv_vlc_map[dv_vlc_run[i]][dv_vlc_level[i]].size = dv_vlc_len[i] +
191 (!!dv_vlc_level[i]);
192 }
193 for (i = 0; i < DV_VLC_MAP_RUN_SIZE; i++) {
194 #ifdef DV_CODEC_TINY_TARGET
195 for (j = 1; j < DV_VLC_MAP_LEV_SIZE; j++) {
196 if (dv_vlc_map[i][j].size == 0) {
197 dv_vlc_map[i][j].vlc = dv_vlc_map[0][j].vlc |
198 (dv_vlc_map[i-1][0].vlc << (dv_vlc_map[0][j].size));
199 dv_vlc_map[i][j].size = dv_vlc_map[i-1][0].size +
200 dv_vlc_map[0][j].size;
201 }
202 }
203 #else
204 for (j = 1; j < DV_VLC_MAP_LEV_SIZE/2; j++) {
205 if (dv_vlc_map[i][j].size == 0) {
206 dv_vlc_map[i][j].vlc = dv_vlc_map[0][j].vlc |
207 (dv_vlc_map[i-1][0].vlc << (dv_vlc_map[0][j].size));
208 dv_vlc_map[i][j].size = dv_vlc_map[i-1][0].size +
209 dv_vlc_map[0][j].size;
210 }
211 dv_vlc_map[i][((uint16_t)(-j))&0x1ff].vlc =
212 dv_vlc_map[i][j].vlc | 1;
213 dv_vlc_map[i][((uint16_t)(-j))&0x1ff].size =
214 dv_vlc_map[i][j].size;
215 }
216 #endif
217 }
218 }
219
220 /* Generic DSP setup */
221 dsputil_init(&dsp, avctx);
222 s->get_pixels = dsp.get_pixels;
223
224 /* 88DCT setup */
225 s->fdct[0] = dsp.fdct;
226 s->idct_put[0] = dsp.idct_put;
227 for (i=0; i<64; i++)
228 s->dv_zigzag[0][i] = dsp.idct_permutation[ff_zigzag_direct[i]];
229
230 /* 248DCT setup */
231 s->fdct[1] = dsp.fdct248;
232 s->idct_put[1] = simple_idct248_put; // FIXME: need to add it to DSP
233 if(avctx->lowres){
234 for (i=0; i<64; i++){
235 int j= ff_zigzag248_direct[i];
236 s->dv_zigzag[1][i] = dsp.idct_permutation[(j&7) + (j&8)*4 + (j&48)/2];
237 }
238 }else
239 memcpy(s->dv_zigzag[1], ff_zigzag248_direct, 64);
240
241 /* XXX: do it only for constant case */
242 dv_build_unquantize_tables(s, dsp.idct_permutation);
243
244 /* FIXME: I really don't think this should be here */
245 s->sys = dv_codec_profile(avctx);
246 if(!s->sys) {
247 av_log(avctx, AV_LOG_ERROR, "Cannot determine type of DV output stream\n");
248 return -EINVAL;
249 }
250 avctx->pix_fmt = s->sys->pix_fmt;
251 avctx->bit_rate = av_rescale(s->sys->frame_size * 8,
252 s->sys->frame_rate,
253 s->sys->frame_rate_base);
254 avctx->coded_frame = &s->picture;
255 s->avctx= avctx;
256
257 return 0;
258 }
259
260 // #define VLC_DEBUG
261 // #define printf(...) av_log(NULL, AV_LOG_ERROR, __VA_ARGS__)
262
263 typedef struct BlockInfo {
264 const uint8_t *shift_table;
265 const uint8_t *scan_table;
266 const int *iweight_table;
267 uint8_t pos; /* position in block */
268 uint8_t dct_mode;
269 uint8_t partial_bit_count;
270 uint16_t partial_bit_buffer;
271 int shift_offset;
272 } BlockInfo;
273
274 /* block size in bits */
275 static const uint16_t block_sizes[6] = {
276 112, 112, 112, 112, 80, 80
277 };
278 /* bit budget for AC only in 5 MBs */
279 static const int vs_total_ac_bits = (100 * 4 + 68*2) * 5;
280 /* see dv_88_areas and dv_248_areas for details */
281 static const int mb_area_start[5] = { 1, 6, 21, 43, 64 };
282
283 #ifndef ALT_BITSTREAM_READER
284 #warning only works with ALT_BITSTREAM_READER
285 static int re_index; //Hack to make it compile
286 #endif
287
288 static inline int get_bits_left(GetBitContext *s)
289 {
290 return s->size_in_bits - get_bits_count(s);
291 }
292
293 static inline int get_bits_size(GetBitContext *s)
294 {
295 return s->size_in_bits;
296 }
297
298 static inline int put_bits_left(PutBitContext* s)
299 {
300 return (s->buf_end - s->buf) * 8 - put_bits_count(s);
301 }
302
303 /* decode ac coefs */
304 static void dv_decode_ac(GetBitContext *gb, BlockInfo *mb, DCTELEM *block)
305 {
306 int last_index = get_bits_size(gb);
307 const uint8_t *scan_table = mb->scan_table;
308 const uint8_t *shift_table = mb->shift_table;
309 const int *iweight_table = mb->iweight_table;
310 int pos = mb->pos;
311 int partial_bit_count = mb->partial_bit_count;
312 int level, pos1, run, vlc_len, index;
313
314 OPEN_READER(re, gb);
315 UPDATE_CACHE(re, gb);
316
317 /* if we must parse a partial vlc, we do it here */
318 if (partial_bit_count > 0) {
319 re_cache = ((unsigned)re_cache >> partial_bit_count) |
320 (mb->partial_bit_buffer << (sizeof(re_cache)*8 - partial_bit_count));
321 re_index -= partial_bit_count;
322 mb->partial_bit_count = 0;
323 }
324
325 /* get the AC coefficients until last_index is reached */
326 for(;;) {
327 #ifdef VLC_DEBUG
328 printf("%2d: bits=%04x index=%d\n", pos, SHOW_UBITS(re, gb, 16), re_index);
329 #endif
330 /* our own optimized GET_RL_VLC */
331 index = NEG_USR32(re_cache, TEX_VLC_BITS);
332 vlc_len = dv_rl_vlc[index].len;
333 if (vlc_len < 0) {
334 index = NEG_USR32((unsigned)re_cache << TEX_VLC_BITS, -vlc_len) + dv_rl_vlc[index].level;
335 vlc_len = TEX_VLC_BITS - vlc_len;
336 }
337 level = dv_rl_vlc[index].level;
338 run = dv_rl_vlc[index].run;
339
340 /* gotta check if we're still within gb boundaries */
341 if (re_index + vlc_len > last_index) {
342 /* should be < 16 bits otherwise a codeword could have been parsed */
343 mb->partial_bit_count = last_index - re_index;
344 mb->partial_bit_buffer = NEG_USR32(re_cache, mb->partial_bit_count);
345 re_index = last_index;
346 break;
347 }
348 re_index += vlc_len;
349
350 #ifdef VLC_DEBUG
351 printf("run=%d level=%d\n", run, level);
352 #endif
353 pos += run;
354 if (pos >= 64)
355 break;
356
357 pos1 = scan_table[pos];
358 level <<= shift_table[pos1];
359
360 /* unweigh, round, and shift down */
361 level = (level*iweight_table[pos] + (1 << (dv_iweight_bits-1))) >> dv_iweight_bits;
362
363 block[pos1] = level;
364
365 UPDATE_CACHE(re, gb);
366 }
367 CLOSE_READER(re, gb);
368 mb->pos = pos;
369 }
370
371 static inline void bit_copy(PutBitContext *pb, GetBitContext *gb)
372 {
373 int bits_left = get_bits_left(gb);
374 while (bits_left >= MIN_CACHE_BITS) {
375 put_bits(pb, MIN_CACHE_BITS, get_bits(gb, MIN_CACHE_BITS));
376 bits_left -= MIN_CACHE_BITS;
377 }
378 if (bits_left > 0) {
379 put_bits(pb, bits_left, get_bits(gb, bits_left));
380 }
381 }
382
383 /* mb_x and mb_y are in units of 8 pixels */
384 static inline void dv_decode_video_segment(DVVideoContext *s,
385 uint8_t *buf_ptr1,
386 const uint16_t *mb_pos_ptr)
387 {
388 int quant, dc, dct_mode, class1, j;
389 int mb_index, mb_x, mb_y, v, last_index;
390 DCTELEM *block, *block1;
391 int c_offset;
392 uint8_t *y_ptr;
393 void (*idct_put)(uint8_t *dest, int line_size, DCTELEM *block);
394 uint8_t *buf_ptr;
395 PutBitContext pb, vs_pb;
396 GetBitContext gb;
397 BlockInfo mb_data[5 * 6], *mb, *mb1;
398 DECLARE_ALIGNED_8(DCTELEM, sblock[5*6][64]);
399 DECLARE_ALIGNED_8(uint8_t, mb_bit_buffer[80 + 4]); /* allow some slack */
400 DECLARE_ALIGNED_8(uint8_t, vs_bit_buffer[5 * 80 + 4]); /* allow some slack */
401 const int log2_blocksize= 3-s->avctx->lowres;
402
403 assert((((int)mb_bit_buffer)&7)==0);
404 assert((((int)vs_bit_buffer)&7)==0);
405
406 memset(sblock, 0, sizeof(sblock));
407
408 /* pass 1 : read DC and AC coefficients in blocks */
409 buf_ptr = buf_ptr1;
410 block1 = &sblock[0][0];
411 mb1 = mb_data;
412 init_put_bits(&vs_pb, vs_bit_buffer, 5 * 80);
413 for(mb_index = 0; mb_index < 5; mb_index++, mb1 += 6, block1 += 6 * 64) {
414 /* skip header */
415 quant = buf_ptr[3] & 0x0f;
416 buf_ptr += 4;
417 init_put_bits(&pb, mb_bit_buffer, 80);
418 mb = mb1;
419 block = block1;
420 for(j = 0;j < 6; j++) {
421 last_index = block_sizes[j];
422 init_get_bits(&gb, buf_ptr, last_index);
423
424 /* get the dc */
425 dc = get_sbits(&gb, 9);
426 dct_mode = get_bits1(&gb);
427 mb->dct_mode = dct_mode;
428 mb->scan_table = s->dv_zigzag[dct_mode];
429 mb->iweight_table = dct_mode ? dv_iweight_248 : dv_iweight_88;
430 class1 = get_bits(&gb, 2);
431 mb->shift_table = s->dv_idct_shift[class1 == 3][dct_mode]
432 [quant + dv_quant_offset[class1]];
433 dc = dc << 2;
434 /* convert to unsigned because 128 is not added in the
435 standard IDCT */
436 dc += 1024;
437 block[0] = dc;
438 buf_ptr += last_index >> 3;
439 mb->pos = 0;
440 mb->partial_bit_count = 0;
441
442 #ifdef VLC_DEBUG
443 printf("MB block: %d, %d ", mb_index, j);
444 #endif
445 dv_decode_ac(&gb, mb, block);
446
447 /* write the remaining bits in a new buffer only if the
448 block is finished */
449 if (mb->pos >= 64)
450 bit_copy(&pb, &gb);
451
452 block += 64;
453 mb++;
454 }
455
456 /* pass 2 : we can do it just after */
457 #ifdef VLC_DEBUG
458 printf("***pass 2 size=%d MB#=%d\n", put_bits_count(&pb), mb_index);
459 #endif
460 block = block1;
461 mb = mb1;
462 init_get_bits(&gb, mb_bit_buffer, put_bits_count(&pb));
463 flush_put_bits(&pb);
464 for(j = 0;j < 6; j++, block += 64, mb++) {
465 if (mb->pos < 64 && get_bits_left(&gb) > 0) {
466 dv_decode_ac(&gb, mb, block);
467 /* if still not finished, no need to parse other blocks */
468 if (mb->pos < 64)
469 break;
470 }
471 }
472 /* all blocks are finished, so the extra bytes can be used at
473 the video segment level */
474 if (j >= 6)
475 bit_copy(&vs_pb, &gb);
476 }
477
478 /* we need a pass other the whole video segment */
479 #ifdef VLC_DEBUG
480 printf("***pass 3 size=%d\n", put_bits_count(&vs_pb));
481 #endif
482 block = &sblock[0][0];
483 mb = mb_data;
484 init_get_bits(&gb, vs_bit_buffer, put_bits_count(&vs_pb));
485 flush_put_bits(&vs_pb);
486 for(mb_index = 0; mb_index < 5; mb_index++) {
487 for(j = 0;j < 6; j++) {
488 if (mb->pos < 64) {
489 #ifdef VLC_DEBUG
490 printf("start %d:%d\n", mb_index, j);
491 #endif
492 dv_decode_ac(&gb, mb, block);
493 }
494 if (mb->pos >= 64 && mb->pos < 127)
495 av_log(NULL, AV_LOG_ERROR, "AC EOB marker is absent pos=%d\n", mb->pos);
496 block += 64;
497 mb++;
498 }
499 }
500
501 /* compute idct and place blocks */
502 block = &sblock[0][0];
503 mb = mb_data;
504 for(mb_index = 0; mb_index < 5; mb_index++) {
505 v = *mb_pos_ptr++;
506 mb_x = v & 0xff;
507 mb_y = v >> 8;
508 if (s->sys->pix_fmt == PIX_FMT_YUV422P) {
509 y_ptr = s->picture.data[0] + ((mb_y * s->picture.linesize[0] + (mb_x>>1))<<log2_blocksize);
510 c_offset = ((mb_y * s->picture.linesize[1] + (mb_x >> 2))<<log2_blocksize);
511 } else { /* 4:1:1 or 4:2:0 */
512 y_ptr = s->picture.data[0] + ((mb_y * s->picture.linesize[0] + mb_x)<<log2_blocksize);
513 if (s->sys->pix_fmt == PIX_FMT_YUV411P)
514 c_offset = ((mb_y * s->picture.linesize[1] + (mb_x >> 2))<<log2_blocksize);
515 else /* 4:2:0 */
516 c_offset = (((mb_y >> 1) * s->picture.linesize[1] + (mb_x >> 1))<<log2_blocksize);
517 }
518 for(j = 0;j < 6; j++) {
519 idct_put = s->idct_put[mb->dct_mode && log2_blocksize==3];
520 if (s->sys->pix_fmt == PIX_FMT_YUV422P) { /* 4:2:2 */
521 if (j == 0 || j == 2) {
522 /* Y0 Y1 */
523 idct_put(y_ptr + ((j >> 1)<<log2_blocksize),
524 s->picture.linesize[0], block);
525 } else if(j > 3) {
526 /* Cr Cb */
527 idct_put(s->picture.data[6 - j] + c_offset,
528 s->picture.linesize[6 - j], block);
529 }
530 /* note: j=1 and j=3 are "dummy" blocks in 4:2:2 */
531 } else { /* 4:1:1 or 4:2:0 */
532 if (j < 4) {
533 if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x < (704 / 8)) {
534 /* NOTE: at end of line, the macroblock is handled as 420 */
535 idct_put(y_ptr + (j<<log2_blocksize), s->picture.linesize[0], block);
536 } else {
537 idct_put(y_ptr + (((j & 1) + (j >> 1) * s->picture.linesize[0])<<log2_blocksize),
538 s->picture.linesize[0], block);
539 }
540 } else {
541 if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8)) {
542 uint64_t aligned_pixels[64/8];
543 uint8_t *pixels= (uint8_t*)aligned_pixels;
544 uint8_t *c_ptr, *c_ptr1, *ptr, *ptr1;
545 int x, y, linesize;
546 /* NOTE: at end of line, the macroblock is handled as 420 */
547 idct_put(pixels, 8, block);
548 linesize = s->picture.linesize[6 - j];
549 c_ptr = s->picture.data[6 - j] + c_offset;
550 ptr = pixels;
551 for(y = 0;y < (1<<log2_blocksize); y++) {
552 ptr1= ptr + (1<<(log2_blocksize-1));
553 c_ptr1 = c_ptr + (linesize<<log2_blocksize);
554 for(x=0; x < (1<<(log2_blocksize-1)); x++){
555 c_ptr[x]= ptr[x]; c_ptr1[x]= ptr1[x];
556 }
557 c_ptr += linesize;
558 ptr += 8;
559 }
560 } else {
561 /* don't ask me why they inverted Cb and Cr ! */
562 idct_put(s->picture.data[6 - j] + c_offset,
563 s->picture.linesize[6 - j], block);
564 }
565 }
566 }
567 block += 64;
568 mb++;
569 }
570 }
571 }
572
573 #ifdef DV_CODEC_TINY_TARGET
574 /* Converts run and level (where level != 0) pair into vlc, returning bit size */
575 static always_inline int dv_rl2vlc(int run, int level, int sign, uint32_t* vlc)
576 {
577 int size;
578 if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {
579 *vlc = dv_vlc_map[run][level].vlc | sign;
580 size = dv_vlc_map[run][level].size;
581 }
582 else {
583 if (level < DV_VLC_MAP_LEV_SIZE) {
584 *vlc = dv_vlc_map[0][level].vlc | sign;
585 size = dv_vlc_map[0][level].size;
586 } else {
587 *vlc = 0xfe00 | (level << 1) | sign;
588 size = 16;
589 }
590 if (run) {
591 *vlc |= ((run < 16) ? dv_vlc_map[run-1][0].vlc :
592 (0x1f80 | (run - 1))) << size;
593 size += (run < 16) ? dv_vlc_map[run-1][0].size : 13;
594 }
595 }
596
597 return size;
598 }
599
600 static always_inline int dv_rl2vlc_size(int run, int level)
601 {
602 int size;
603
604 if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {
605 size = dv_vlc_map[run][level].size;
606 }
607 else {
608 size = (level < DV_VLC_MAP_LEV_SIZE) ? dv_vlc_map[0][level].size : 16;
609 if (run) {
610 size += (run < 16) ? dv_vlc_map[run-1][0].size : 13;
611 }
612 }
613 return size;
614 }
615 #else
616 static always_inline int dv_rl2vlc(int run, int l, int sign, uint32_t* vlc)
617 {
618 *vlc = dv_vlc_map[run][l].vlc | sign;
619 return dv_vlc_map[run][l].size;
620 }
621
622 static always_inline int dv_rl2vlc_size(int run, int l)
623 {
624 return dv_vlc_map[run][l].size;
625 }
626 #endif
627
628 typedef struct EncBlockInfo {
629 int area_q[4];
630 int bit_size[4];
631 int prev[5];
632 int cur_ac;
633 int cno;
634 int dct_mode;
635 DCTELEM mb[64];
636 uint8_t next[64];
637 uint8_t sign[64];
638 uint8_t partial_bit_count;
639 uint32_t partial_bit_buffer; /* we can't use uint16_t here */
640 } EncBlockInfo;
641
642 static always_inline PutBitContext* dv_encode_ac(EncBlockInfo* bi, PutBitContext* pb_pool,
643 PutBitContext* pb_end)
644 {
645 int prev;
646 int bits_left;
647 PutBitContext* pb = pb_pool;
648 int size = bi->partial_bit_count;
649 uint32_t vlc = bi->partial_bit_buffer;
650
651 bi->partial_bit_count = bi->partial_bit_buffer = 0;
652 for(;;){
653 /* Find suitable storage space */
654 for (; size > (bits_left = put_bits_left(pb)); pb++) {
655 if (bits_left) {
656 size -= bits_left;
657 put_bits(pb, bits_left, vlc >> size);
658 vlc = vlc & ((1<<size)-1);
659 }
660 if (pb + 1 >= pb_end) {
661 bi->partial_bit_count = size;
662 bi->partial_bit_buffer = vlc;
663 return pb;
664 }
665 }
666
667 /* Store VLC */
668 put_bits(pb, size, vlc);
669
670 if(bi->cur_ac>=64)
671 break;
672
673 /* Construct the next VLC */
674 prev= bi->cur_ac;
675 bi->cur_ac = bi->next[prev];
676 if(bi->cur_ac < 64){
677 size = dv_rl2vlc(bi->cur_ac - prev - 1, bi->mb[bi->cur_ac], bi->sign[bi->cur_ac], &vlc);
678 } else {
679 size = 4; vlc = 6; /* End Of Block stamp */
680 }
681 }
682 return pb;
683 }
684
685 static always_inline void dv_set_class_number(DCTELEM* blk, EncBlockInfo* bi,
686 const uint8_t* zigzag_scan, const int *weight, int bias)
687 {
688 int i, area;
689 /* We offer two different methods for class number assignment: the
690 method suggested in SMPTE 314M Table 22, and an improved
691 method. The SMPTE method is very conservative; it assigns class
692 3 (i.e. severe quantization) to any block where the largest AC
693 component is greater than 36. ffmpeg's DV encoder tracks AC bit
694 consumption precisely, so there is no need to bias most blocks
695 towards strongly lossy compression. Instead, we assign class 2
696 to most blocks, and use class 3 only when strictly necessary
697 (for blocks whose largest AC component exceeds 255). */
698
699 #if 0 /* SMPTE spec method */
700 static const int classes[] = {12, 24, 36, 0xffff};
701 #else /* improved ffmpeg method */
702 static const int classes[] = {-1, -1, 255, 0xffff};
703 #endif
704 int max=classes[0];
705 int prev=0;
706
707 bi->mb[0] = blk[0];
708
709 for (area = 0; area < 4; area++) {
710 bi->prev[area] = prev;
711 bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
712 for (i=mb_area_start[area]; i<mb_area_start[area+1]; i++) {
713 int level = blk[zigzag_scan[i]];
714
715 if (level+15 > 30U) {
716 bi->sign[i] = (level>>31)&1;
717 /* weigh it and and shift down into range, adding for rounding */
718 /* the extra division by a factor of 2^4 reverses the 8x expansion of the DCT
719 AND the 2x doubling of the weights */
720 level = (ABS(level) * weight[i] + (1<<(dv_weight_bits+3))) >> (dv_weight_bits+4);
721 bi->mb[i] = level;
722 if(level>max) max= level;
723 bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, level);
724 bi->next[prev]= i;
725 prev= i;
726 }
727 }
728 }
729 bi->next[prev]= i;
730 for(bi->cno = 0; max > classes[bi->cno]; bi->cno++);
731
732 bi->cno += bias;
733
734 if (bi->cno >= 3) {
735 bi->cno = 3;
736 prev=0;
737 i= bi->next[prev];
738 for (area = 0; area < 4; area++) {
739 bi->prev[area] = prev;
740 bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
741 for (; i<mb_area_start[area+1]; i= bi->next[i]) {
742 bi->mb[i] >>=1;
743
744 if (bi->mb[i]) {
745 bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, bi->mb[i]);
746 bi->next[prev]= i;
747 prev= i;
748 }
749 }
750 }
751 bi->next[prev]= i;
752 }
753 }
754
755 //FIXME replace this by dsputil
756 #define SC(x, y) ((s[x] - s[y]) ^ ((s[x] - s[y]) >> 7))
757 static always_inline int dv_guess_dct_mode(DCTELEM *blk) {
758 DCTELEM *s;
759 int score88 = 0;
760 int score248 = 0;
761 int i;
762
763 /* Compute 8-8 score (small values give a better chance for 8-8 DCT) */
764 s = blk;
765 for(i=0; i<7; i++) {
766 score88 += SC(0, 8) + SC(1, 9) + SC(2, 10) + SC(3, 11) +
767 SC(4, 12) + SC(5,13) + SC(6, 14) + SC(7, 15);
768 s += 8;
769 }
770 /* Compute 2-4-8 score (small values give a better chance for 2-4-8 DCT) */
771 s = blk;
772 for(i=0; i<6; i++) {
773 score248 += SC(0, 16) + SC(1,17) + SC(2, 18) + SC(3, 19) +
774 SC(4, 20) + SC(5,21) + SC(6, 22) + SC(7, 23);
775 s += 8;
776 }
777
778 return (score88 - score248 > -10);
779 }
780
781 static inline void dv_guess_qnos(EncBlockInfo* blks, int* qnos)
782 {
783 int size[5];
784 int i, j, k, a, prev, a2;
785 EncBlockInfo* b;
786
787 size[0] = size[1] = size[2] = size[3] = size[4] = 1<<24;
788 do {
789 b = blks;
790 for (i=0; i<5; i++) {
791 if (!qnos[i])
792 continue;
793
794 qnos[i]--;
795 size[i] = 0;
796 for (j=0; j<6; j++, b++) {
797 for (a=0; a<4; a++) {
798 if (b->area_q[a] != dv_quant_shifts[qnos[i] + dv_quant_offset[b->cno]][a]) {
799 b->bit_size[a] = 1; // 4 areas 4 bits for EOB :)
800 b->area_q[a]++;
801 prev= b->prev[a];
802 assert(b->next[prev] >= mb_area_start[a+1] || b->mb[prev]);
803 for (k= b->next[prev] ; k<mb_area_start[a+1]; k= b->next[k]) {
804 b->mb[k] >>= 1;
805 if (b->mb[k]) {
806 b->bit_size[a] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
807 prev= k;
808 } else {
809 if(b->next[k] >= mb_area_start[a+1] && b->next[k]<64){
810 for(a2=a+1; b->next[k] >= mb_area_start[a2+1]; a2++)
811 b->prev[a2] = prev;
812 assert(a2<4);
813 assert(b->mb[b->next[k]]);
814 b->bit_size[a2] += dv_rl2vlc_size(b->next[k] - prev - 1, b->mb[b->next[k]])
815 -dv_rl2vlc_size(b->next[k] - k - 1, b->mb[b->next[k]]);
816 assert(b->prev[a2]==k && (a2+1 >= 4 || b->prev[a2+1]!=k));
817 b->prev[a2] = prev;
818 }
819 b->next[prev] = b->next[k];
820 }
821 }
822 b->prev[a+1]= prev;
823 }
824 size[i] += b->bit_size[a];
825 }
826 }
827 if(vs_total_ac_bits >= size[0] + size[1] + size[2] + size[3] + size[4])
828 return;
829 }
830 } while (qnos[0]|qnos[1]|qnos[2]|qnos[3]|qnos[4]);
831
832
833 for(a=2; a==2 || vs_total_ac_bits < size[0]; a+=a){
834 b = blks;
835 size[0] = 5*6*4; //EOB
836 for (j=0; j<6*5; j++, b++) {
837 prev= b->prev[0];
838 for (k= b->next[prev]; k<64; k= b->next[k]) {
839 if(b->mb[k] < a && b->mb[k] > -a){
840 b->next[prev] = b->next[k];
841 }else{
842 size[0] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
843 prev= k;
844 }
845 }
846 }
847 }
848 }
849
850 static inline void dv_encode_video_segment(DVVideoContext *s,
851 uint8_t *dif,
852 const uint16_t *mb_pos_ptr)
853 {
854 int mb_index, i, j, v;
855 int mb_x, mb_y, c_offset, linesize;
856 uint8_t* y_ptr;
857 uint8_t* data;
858 uint8_t* ptr;
859 int do_edge_wrap;
860 DECLARE_ALIGNED_8(DCTELEM, block[64]);
861 EncBlockInfo enc_blks[5*6];
862 PutBitContext pbs[5*6];
863 PutBitContext* pb;
864 EncBlockInfo* enc_blk;
865 int vs_bit_size = 0;
866 int qnos[5];
867
868 assert((((int)block) & 7) == 0);
869
870 enc_blk = &enc_blks[0];
871 pb = &pbs[0];
872 for(mb_index = 0; mb_index < 5; mb_index++) {
873 v = *mb_pos_ptr++;
874 mb_x = v & 0xff;
875 mb_y = v >> 8;
876 if (s->sys->pix_fmt == PIX_FMT_YUV422P) {
877 y_ptr = s->picture.data[0] + (mb_y * s->picture.linesize[0] * 8) + (mb_x * 4);
878 } else { /* 4:1:1 */
879 y_ptr = s->picture.data[0] + (mb_y * s->picture.linesize[0] * 8) + (mb_x * 8);
880 }
881 if (s->sys->pix_fmt == PIX_FMT_YUV420P) {
882 c_offset = (((mb_y >> 1) * s->picture.linesize[1] * 8) + ((mb_x >> 1) * 8));
883 } else { /* 4:2:2 or 4:1:1 */
884 c_offset = ((mb_y * s->picture.linesize[1] * 8) + ((mb_x >> 2) * 8));
885 }
886 do_edge_wrap = 0;
887 qnos[mb_index] = 15; /* No quantization */
888 ptr = dif + mb_index*80 + 4;
889 for(j = 0;j < 6; j++) {
890 int dummy = 0;
891 if (s->sys->pix_fmt == PIX_FMT_YUV422P) { /* 4:2:2 */
892 if (j == 0 || j == 2) {
893 /* Y0 Y1 */
894 data = y_ptr + ((j>>1) * 8);
895 linesize = s->picture.linesize[0];
896 } else if (j > 3) {
897 /* Cr Cb */
898 data = s->picture.data[6 - j] + c_offset;
899 linesize = s->picture.linesize[6 - j];
900 } else {
901 /* j=1 and j=3 are "dummy" blocks, used for AC data only */
902 data = 0;
903 linesize = 0;
904 dummy = 1;
905 }
906 } else { /* 4:1:1 or 4:2:0 */
907 if (j < 4) { /* Four Y blocks */
908 /* NOTE: at end of line, the macroblock is handled as 420 */
909 if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x < (704 / 8)) {
910 data = y_ptr + (j * 8);
911 } else {
912 data = y_ptr + ((j & 1) * 8) + ((j >> 1) * 8 * s->picture.linesize[0]);
913 }
914 linesize = s->picture.linesize[0];
915 } else { /* Cr and Cb blocks */
916 /* don't ask Fabrice why they inverted Cb and Cr ! */
917 data = s->picture.data[6 - j] + c_offset;
918 linesize = s->picture.linesize[6 - j];
919 if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8))
920 do_edge_wrap = 1;
921 }
922 }
923
924 /* Everything is set up -- now just copy data -> DCT block */
925 if (do_edge_wrap) { /* Edge wrap copy: 4x16 -> 8x8 */
926 uint8_t* d;
927 DCTELEM *b = block;
928 for (i=0;i<8;i++) {
929 d = data + 8 * linesize;
930 b[0] = data[0]; b[1] = data[1]; b[2] = data[2]; b[3] = data[3];
931 b[4] = d[0]; b[5] = d[1]; b[6] = d[2]; b[7] = d[3];
932 data += linesize;
933 b += 8;
934 }
935 } else { /* Simple copy: 8x8 -> 8x8 */
936 if (!dummy)
937 s->get_pixels(block, data, linesize);
938 }
939
940 if(s->avctx->flags & CODEC_FLAG_INTERLACED_DCT)
941 enc_blk->dct_mode = dv_guess_dct_mode(block);
942 else
943 enc_blk->dct_mode = 0;
944 enc_blk->area_q[0] = enc_blk->area_q[1] = enc_blk->area_q[2] = enc_blk->area_q[3] = 0;
945 enc_blk->partial_bit_count = 0;
946 enc_blk->partial_bit_buffer = 0;
947 enc_blk->cur_ac = 0;
948
949 if (dummy) {
950 /* We rely on the fact that encoding all zeros leads to an immediate EOB,
951 which is precisely what the spec calls for in the "dummy" blocks. */
952 memset(block, 0, sizeof(block));
953 } else {
954 s->fdct[enc_blk->dct_mode](block);
955 }
956
957 dv_set_class_number(block, enc_blk,
958 enc_blk->dct_mode ? ff_zigzag248_direct : ff_zigzag_direct,
959 enc_blk->dct_mode ? dv_weight_248 : dv_weight_88,
960 j/4);
961
962 init_put_bits(pb, ptr, block_sizes[j]/8);
963 put_bits(pb, 9, (uint16_t)(((enc_blk->mb[0] >> 3) - 1024 + 2) >> 2));
964 put_bits(pb, 1, enc_blk->dct_mode);
965 put_bits(pb, 2, enc_blk->cno);
966
967 vs_bit_size += enc_blk->bit_size[0] + enc_blk->bit_size[1] +
968 enc_blk->bit_size[2] + enc_blk->bit_size[3];
969 ++enc_blk;
970 ++pb;
971 ptr += block_sizes[j]/8;
972 }
973 }
974
975 if (vs_total_ac_bits < vs_bit_size)
976 dv_guess_qnos(&enc_blks[0], &qnos[0]);
977
978 for (i=0; i<5; i++) {
979 dif[i*80 + 3] = qnos[i];
980 }
981
982 /* First pass over individual cells only */
983 for (j=0; j<5*6; j++)
984 dv_encode_ac(&enc_blks[j], &pbs[j], &pbs[j+1]);
985
986 /* Second pass over each MB space */
987 for (j=0; j<5*6; j+=6) {
988 pb= &pbs[j];
989 for (i=0; i<6; i++) {
990 if (enc_blks[i+j].partial_bit_count)
991 pb=dv_encode_ac(&enc_blks[i+j], pb, &pbs[j+6]);
992 }
993 }
994
995 /* Third and final pass over the whole vides segment space */
996 pb= &pbs[0];
997 for (j=0; j<5*6; j++) {
998 if (enc_blks[j].partial_bit_count)
999 pb=dv_encode_ac(&enc_blks[j], pb, &pbs[6*5]);
1000 if (enc_blks[j].partial_bit_count)
1001 av_log(NULL, AV_LOG_ERROR, "ac bitstream overflow\n");
1002 }
1003
1004 for (j=0; j<5*6; j++)
1005 flush_put_bits(&pbs[j]);
1006 }
1007
1008 static int dv_decode_mt(AVCodecContext *avctx, void* sl)
1009 {
1010 DVVideoContext *s = avctx->priv_data;
1011 int slice = (size_t)sl;
1012
1013 /* which DIF channel is this? */
1014 int chan = slice / (s->sys->difseg_size * 27);
1015
1016 /* slice within the DIF channel */
1017 int chan_slice = slice % (s->sys->difseg_size * 27);
1018
1019 /* byte offset of this channel's data */
1020 int chan_offset = chan * s->sys->difseg_size * 150 * 80;
1021
1022 dv_decode_video_segment(s, &s->buf[((chan_slice/27)*6+(chan_slice/3)+chan_slice*5+7)*80 + chan_offset],
1023 &s->sys->video_place[slice*5]);
1024 return 0;
1025 }
1026
1027 static int dv_encode_mt(AVCodecContext *avctx, void* sl)
1028 {
1029 DVVideoContext *s = avctx->priv_data;
1030 int slice = (size_t)sl;
1031
1032 /* which DIF channel is this? */
1033 int chan = slice / (s->sys->difseg_size * 27);
1034
1035 /* slice within the DIF channel */
1036 int chan_slice = slice % (s->sys->difseg_size * 27);
1037
1038 /* byte offset of this channel's data */
1039 int chan_offset = chan * s->sys->difseg_size * 150 * 80;
1040
1041 dv_encode_video_segment(s, &s->buf[((chan_slice/27)*6+(chan_slice/3)+chan_slice*5+7)*80 + chan_offset],
1042 &s->sys->video_place[slice*5]);
1043 return 0;
1044 }
1045
1046 /* NOTE: exactly one frame must be given (120000 bytes for NTSC,
1047 144000 bytes for PAL - or twice those for 50Mbps) */
1048 static int dvvideo_decode_frame(AVCodecContext *avctx,
1049 void *data, int *data_size,
1050 uint8_t *buf, int buf_size)
1051 {
1052 DVVideoContext *s = avctx->priv_data;
1053
1054 s->sys = dv_frame_profile(buf);
1055 if (!s->sys || buf_size < s->sys->frame_size)
1056 return -1; /* NOTE: we only accept several full frames */
1057
1058 if(s->picture.data[0])
1059 avctx->release_buffer(avctx, &s->picture);
1060
1061 s->picture.reference = 0;
1062 s->picture.key_frame = 1;
1063 s->picture.pict_type = FF_I_TYPE;
1064 avctx->pix_fmt = s->sys->pix_fmt;
1065 avcodec_set_dimensions(avctx, s->sys->width, s->sys->height);
1066 if(avctx->get_buffer(avctx, &s->picture) < 0) {
1067 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1068 return -1;
1069 }
1070 s->picture.interlaced_frame = 1;
1071 s->picture.top_field_first = 0;
1072
1073 s->buf = buf;
1074 avctx->execute(avctx, dv_decode_mt, (void**)&dv_anchor[0], NULL,
1075 s->sys->n_difchan * s->sys->difseg_size * 27);
1076
1077 emms_c();
1078
1079 /* return image */
1080 *data_size = sizeof(AVFrame);
1081 *(AVFrame*)data= s->picture;
1082
1083 return s->sys->frame_size;
1084 }
1085
1086 static int dvvideo_encode_frame(AVCodecContext *c, uint8_t *buf, int buf_size,
1087 void *data)
1088 {
1089 DVVideoContext *s = c->priv_data;
1090
1091 s->sys = dv_codec_profile(c);
1092 if (!s->sys)
1093 return -1;
1094 if(buf_size < s->sys->frame_size)
1095 return -1;
1096
1097 c->pix_fmt = s->sys->pix_fmt;
1098 s->picture = *((AVFrame *)data);
1099 s->picture.key_frame = 1;
1100 s->picture.pict_type = FF_I_TYPE;
1101
1102 s->buf = buf;
1103 c->execute(c, dv_encode_mt, (void**)&dv_anchor[0], NULL,
1104 s->sys->n_difchan * s->sys->difseg_size * 27);
1105
1106 emms_c();
1107
1108 /* Fill in just enough of the header for dv_frame_profile() to
1109 return the correct result, so that the frame can be decoded
1110 correctly. The rest of the metadata is filled in by the dvvideo
1111 avformat. (this should probably change so that encode_frame()
1112 fills in ALL of the metadata - e.g. for Quicktime-wrapped DV
1113 streams) */
1114
1115 /* NTSC/PAL format */
1116 buf[3] = s->sys->dsf ? 0x80 : 0x00;
1117
1118 /* 25Mbps or 50Mbps */
1119 buf[80*5 + 48 + 3] = (s->sys->pix_fmt == PIX_FMT_YUV422P) ? 0x4 : 0x0;
1120
1121 return s->sys->frame_size;
1122 }
1123
1124 static int dvvideo_close(AVCodecContext *c)
1125 {
1126
1127 return 0;
1128 }
1129
1130
1131 #ifdef CONFIG_DVVIDEO_ENCODER
1132 AVCodec dvvideo_encoder = {
1133 "dvvideo",
1134 CODEC_TYPE_VIDEO,
1135 CODEC_ID_DVVIDEO,
1136 sizeof(DVVideoContext),
1137 dvvideo_init,
1138 dvvideo_encode_frame,
1139 dvvideo_close,
1140 NULL,
1141 CODEC_CAP_DR1,
1142 NULL
1143 };
1144 #endif // CONFIG_DVVIDEO_ENCODER
1145
1146 AVCodec dvvideo_decoder = {
1147 "dvvideo",
1148 CODEC_TYPE_VIDEO,
1149 CODEC_ID_DVVIDEO,
1150 sizeof(DVVideoContext),
1151 dvvideo_init,
1152 NULL,
1153 dvvideo_close,
1154 dvvideo_decode_frame,
1155 CODEC_CAP_DR1,
1156 NULL
1157 };