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