optimizations
[ffmpeg.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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  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 #define TEX_VLC_BITS 9
55
56 #ifdef DV_CODEC_TINY_TARGET
57 #define DV_VLC_MAP_RUN_SIZE 15
58 #define DV_VLC_MAP_LEV_SIZE 23
59 #else
60 #define DV_VLC_MAP_RUN_SIZE  64 
61 #define DV_VLC_MAP_LEV_SIZE 512 //FIXME sign was removed so this should be /2 but needs check
62 #endif
63
64 /* MultiThreading */
65 static uint8_t** dv_anchor;
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_malloc(dv_vlc.table_size * sizeof(RL_VLC_ELEM));
153         if (!dv_rl_vlc) {
154             av_free(dv_anchor);
155             return -ENOMEM;
156         }
157         for(i = 0; i < dv_vlc.table_size; i++){
158             int code= dv_vlc.table[i][0];
159             int len = dv_vlc.table[i][1];
160             int level, run;
161         
162             if(len<0){ //more bits needed
163                 run= 0;
164                 level= code;
165             } else {
166                 run=   new_dv_vlc_run[code] + 1;
167                 level= new_dv_vlc_level[code];
168             }
169             dv_rl_vlc[i].len = len;
170             dv_rl_vlc[i].level = level;
171             dv_rl_vlc[i].run = run;
172         }
173         free_vlc(&dv_vlc);
174
175         for (i = 0; i < NB_DV_VLC - 1; i++) {
176            if (dv_vlc_run[i] >= DV_VLC_MAP_RUN_SIZE)
177                continue;
178 #ifdef DV_CODEC_TINY_TARGET
179            if (dv_vlc_level[i] >= DV_VLC_MAP_LEV_SIZE)
180                continue;
181 #endif
182            
183            if (dv_vlc_map[dv_vlc_run[i]][dv_vlc_level[i]].size != 0)
184                continue;
185                
186            dv_vlc_map[dv_vlc_run[i]][dv_vlc_level[i]].vlc = dv_vlc_bits[i] << 
187                                                             (!!dv_vlc_level[i]);
188            dv_vlc_map[dv_vlc_run[i]][dv_vlc_level[i]].size = dv_vlc_len[i] + 
189                                                              (!!dv_vlc_level[i]);
190         }
191         for (i = 0; i < DV_VLC_MAP_RUN_SIZE; i++) {
192 #ifdef DV_CODEC_TINY_TARGET
193            for (j = 1; j < DV_VLC_MAP_LEV_SIZE; j++) {
194               if (dv_vlc_map[i][j].size == 0) {
195                   dv_vlc_map[i][j].vlc = dv_vlc_map[0][j].vlc |
196                             (dv_vlc_map[i-1][0].vlc << (dv_vlc_map[0][j].size));
197                   dv_vlc_map[i][j].size = dv_vlc_map[i-1][0].size + 
198                                           dv_vlc_map[0][j].size;
199               }
200            }
201 #else
202            for (j = 1; j < DV_VLC_MAP_LEV_SIZE/2; j++) {
203               if (dv_vlc_map[i][j].size == 0) {
204                   dv_vlc_map[i][j].vlc = dv_vlc_map[0][j].vlc |
205                             (dv_vlc_map[i-1][0].vlc << (dv_vlc_map[0][j].size));
206                   dv_vlc_map[i][j].size = dv_vlc_map[i-1][0].size + 
207                                           dv_vlc_map[0][j].size;
208               }
209               dv_vlc_map[i][((uint16_t)(-j))&0x1ff].vlc = 
210                                             dv_vlc_map[i][j].vlc | 1;
211               dv_vlc_map[i][((uint16_t)(-j))&0x1ff].size = 
212                                             dv_vlc_map[i][j].size;
213            }
214 #endif
215         }
216     }
217
218     /* Generic DSP setup */
219     dsputil_init(&dsp, avctx);
220     s->get_pixels = dsp.get_pixels;
221
222     /* 88DCT setup */
223     s->fdct[0] = dsp.fdct;
224     s->idct_put[0] = dsp.idct_put;
225     for (i=0; i<64; i++)
226        s->dv_zigzag[0][i] = dsp.idct_permutation[ff_zigzag_direct[i]];
227
228     /* 248DCT setup */
229     s->fdct[1] = dsp.fdct248;
230     s->idct_put[1] = simple_idct248_put;  // FIXME: need to add it to DSP
231     memcpy(s->dv_zigzag[1], ff_zigzag248_direct, 64);
232
233     /* XXX: do it only for constant case */
234     dv_build_unquantize_tables(s, dsp.idct_permutation);
235
236     /* FIXME: I really don't think this should be here */
237     if (dv_codec_profile(avctx))
238         avctx->pix_fmt = dv_codec_profile(avctx)->pix_fmt; 
239     avctx->coded_frame = &s->picture;
240     s->avctx= avctx;
241     
242     return 0;
243 }
244
245 // #define VLC_DEBUG
246 // #define printf(...) av_log(NULL, AV_LOG_ERROR, __VA_ARGS__)
247
248 typedef struct BlockInfo {
249     const uint8_t *shift_table;
250     const uint8_t *scan_table;
251     uint8_t pos; /* position in block */
252     uint8_t dct_mode;
253     uint8_t partial_bit_count;
254     uint16_t partial_bit_buffer;
255     int shift_offset;
256 } BlockInfo;
257
258 /* block size in bits */
259 static const uint16_t block_sizes[6] = {
260     112, 112, 112, 112, 80, 80
261 };
262 /* bit budget for AC only in 5 MBs */
263 static const int vs_total_ac_bits = (100 * 4 + 68*2) * 5;
264 /* see dv_88_areas and dv_248_areas for details */
265 static const int mb_area_start[5] = { 1, 6, 21, 43, 64 }; 
266
267 #ifndef ALT_BITSTREAM_READER
268 #warning only works with ALT_BITSTREAM_READER
269 static int re_index; //Hack to make it compile
270 #endif
271
272 static inline int get_bits_left(GetBitContext *s)
273 {
274     return s->size_in_bits - get_bits_count(s);
275 }
276
277 static inline int get_bits_size(GetBitContext *s)
278 {
279     return s->size_in_bits;
280 }
281
282 static inline int put_bits_left(PutBitContext* s)
283 {
284     return (s->buf_end - s->buf) * 8 - put_bits_count(s);
285 }
286
287 /* decode ac coefs */
288 static void dv_decode_ac(GetBitContext *gb, BlockInfo *mb, DCTELEM *block)
289 {
290     int last_index = get_bits_size(gb);
291     const uint8_t *scan_table = mb->scan_table;
292     const uint8_t *shift_table = mb->shift_table;
293     int pos = mb->pos;
294     int partial_bit_count = mb->partial_bit_count;
295     int level, pos1, run, vlc_len, index;
296     
297     OPEN_READER(re, gb);
298     UPDATE_CACHE(re, gb);
299     
300     /* if we must parse a partial vlc, we do it here */
301     if (partial_bit_count > 0) {
302         re_cache = ((unsigned)re_cache >> partial_bit_count) |
303                    (mb->partial_bit_buffer << (sizeof(re_cache)*8 - partial_bit_count));
304         re_index -= partial_bit_count;
305         mb->partial_bit_count = 0;
306     }
307
308     /* get the AC coefficients until last_index is reached */
309     for(;;) {
310 #ifdef VLC_DEBUG
311         printf("%2d: bits=%04x index=%d\n", pos, SHOW_UBITS(re, gb, 16), re_index);
312 #endif
313         /* our own optimized GET_RL_VLC */
314         index = NEG_USR32(re_cache, TEX_VLC_BITS);
315         vlc_len = dv_rl_vlc[index].len;
316         if (vlc_len < 0) {
317             index = NEG_USR32((unsigned)re_cache << TEX_VLC_BITS, -vlc_len) + dv_rl_vlc[index].level;
318             vlc_len = TEX_VLC_BITS - vlc_len;
319         }
320         level = dv_rl_vlc[index].level;
321         run = dv_rl_vlc[index].run;
322         
323         /* gotta check if we're still within gb boundaries */
324         if (re_index + vlc_len > last_index) {
325             /* should be < 16 bits otherwise a codeword could have been parsed */
326             mb->partial_bit_count = last_index - re_index;
327             mb->partial_bit_buffer = NEG_USR32(re_cache, mb->partial_bit_count);
328             re_index = last_index;
329             break;
330         }
331         re_index += vlc_len;
332
333 #ifdef VLC_DEBUG
334         printf("run=%d level=%d\n", run, level);
335 #endif
336         pos += run;     
337         if (pos >= 64)
338             break;
339         
340         assert(level);
341         pos1 = scan_table[pos];
342         block[pos1] = level << shift_table[pos1];
343
344         UPDATE_CACHE(re, gb);
345     }
346     CLOSE_READER(re, gb);
347     mb->pos = pos;
348 }
349
350 static inline void bit_copy(PutBitContext *pb, GetBitContext *gb)
351 {
352     int bits_left = get_bits_left(gb);
353     while (bits_left >= MIN_CACHE_BITS) {
354         put_bits(pb, MIN_CACHE_BITS, get_bits(gb, MIN_CACHE_BITS));
355         bits_left -= MIN_CACHE_BITS;
356     }
357     if (bits_left > 0) {
358         put_bits(pb, bits_left, get_bits(gb, bits_left));
359     }
360 }
361
362 /* mb_x and mb_y are in units of 8 pixels */
363 static inline void dv_decode_video_segment(DVVideoContext *s, 
364                                            uint8_t *buf_ptr1, 
365                                            const uint16_t *mb_pos_ptr)
366 {
367     int quant, dc, dct_mode, class1, j;
368     int mb_index, mb_x, mb_y, v, last_index;
369     DCTELEM *block, *block1;
370     int c_offset;
371     uint8_t *y_ptr;
372     void (*idct_put)(uint8_t *dest, int line_size, DCTELEM *block);
373     uint8_t *buf_ptr;
374     PutBitContext pb, vs_pb;
375     GetBitContext gb;
376     BlockInfo mb_data[5 * 6], *mb, *mb1;
377     DCTELEM sblock[5*6][64] __align8;
378     uint8_t mb_bit_buffer[80 + 4] __align8; /* allow some slack */
379     uint8_t vs_bit_buffer[5 * 80 + 4] __align8; /* allow some slack */
380             
381     assert((((int)mb_bit_buffer)&7)==0);
382     assert((((int)vs_bit_buffer)&7)==0);
383     
384     memset(sblock, 0, sizeof(sblock));
385
386     /* pass 1 : read DC and AC coefficients in blocks */
387     buf_ptr = buf_ptr1;
388     block1 = &sblock[0][0];
389     mb1 = mb_data;
390     init_put_bits(&vs_pb, vs_bit_buffer, 5 * 80);
391     for(mb_index = 0; mb_index < 5; mb_index++, mb1 += 6, block1 += 6 * 64) {
392         /* skip header */
393         quant = buf_ptr[3] & 0x0f;
394         buf_ptr += 4;
395         init_put_bits(&pb, mb_bit_buffer, 80);
396         mb = mb1;
397         block = block1;
398         for(j = 0;j < 6; j++) {
399             last_index = block_sizes[j];
400             init_get_bits(&gb, buf_ptr, last_index);
401             
402             /* get the dc */
403             dc = get_sbits(&gb, 9);
404             dct_mode = get_bits1(&gb);
405             mb->dct_mode = dct_mode;
406             mb->scan_table = s->dv_zigzag[dct_mode];
407             class1 = get_bits(&gb, 2);
408             mb->shift_table = s->dv_idct_shift[class1 == 3][dct_mode]
409                 [quant + dv_quant_offset[class1]];
410             dc = dc << 2;
411             /* convert to unsigned because 128 is not added in the
412                standard IDCT */
413             dc += 1024;
414             block[0] = dc;
415             buf_ptr += last_index >> 3;
416             mb->pos = 0;
417             mb->partial_bit_count = 0;
418
419 #ifdef VLC_DEBUG
420             printf("MB block: %d, %d ", mb_index, j);
421 #endif
422             dv_decode_ac(&gb, mb, block);
423
424             /* write the remaining bits  in a new buffer only if the
425                block is finished */
426             if (mb->pos >= 64)
427                 bit_copy(&pb, &gb);
428             
429             block += 64;
430             mb++;
431         }
432         
433         /* pass 2 : we can do it just after */
434 #ifdef VLC_DEBUG
435         printf("***pass 2 size=%d MB#=%d\n", put_bits_count(&pb), mb_index);
436 #endif
437         block = block1;
438         mb = mb1;
439         init_get_bits(&gb, mb_bit_buffer, put_bits_count(&pb));
440         flush_put_bits(&pb);
441         for(j = 0;j < 6; j++, block += 64, mb++) {
442             if (mb->pos < 64 && get_bits_left(&gb) > 0) {
443                 dv_decode_ac(&gb, mb, block);
444                 /* if still not finished, no need to parse other blocks */
445                 if (mb->pos < 64)
446                     break;
447             }
448         }
449         /* all blocks are finished, so the extra bytes can be used at
450            the video segment level */
451         if (j >= 6)
452             bit_copy(&vs_pb, &gb);
453     }
454
455     /* we need a pass other the whole video segment */
456 #ifdef VLC_DEBUG
457     printf("***pass 3 size=%d\n", put_bits_count(&vs_pb));
458 #endif
459     block = &sblock[0][0];
460     mb = mb_data;
461     init_get_bits(&gb, vs_bit_buffer, put_bits_count(&vs_pb));
462     flush_put_bits(&vs_pb);
463     for(mb_index = 0; mb_index < 5; mb_index++) {
464         for(j = 0;j < 6; j++) {
465             if (mb->pos < 64) {
466 #ifdef VLC_DEBUG
467                 printf("start %d:%d\n", mb_index, j);
468 #endif
469                 dv_decode_ac(&gb, mb, block);
470             }
471             if (mb->pos >= 64 && mb->pos < 127)
472                 av_log(NULL, AV_LOG_ERROR, "AC EOB marker is absent pos=%d\n", mb->pos);
473             block += 64;
474             mb++;
475         }
476     }
477     
478     /* compute idct and place blocks */
479     block = &sblock[0][0];
480     mb = mb_data;
481     for(mb_index = 0; mb_index < 5; mb_index++) {
482         v = *mb_pos_ptr++;
483         mb_x = v & 0xff;
484         mb_y = v >> 8;
485         y_ptr = s->picture.data[0] + (mb_y * s->picture.linesize[0] * 8) + (mb_x * 8);
486         if (s->sys->pix_fmt == PIX_FMT_YUV411P)
487             c_offset = (mb_y * s->picture.linesize[1] * 8) + ((mb_x >> 2) * 8);
488         else
489             c_offset = ((mb_y >> 1) * s->picture.linesize[1] * 8) + ((mb_x >> 1) * 8);
490         for(j = 0;j < 6; j++) {
491             idct_put = s->idct_put[mb->dct_mode];
492             if (j < 4) {
493                 if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x < (704 / 8)) {
494                     /* NOTE: at end of line, the macroblock is handled as 420 */
495                     idct_put(y_ptr + (j * 8), s->picture.linesize[0], block);
496                 } else {
497                     idct_put(y_ptr + ((j & 1) * 8) + ((j >> 1) * 8 * s->picture.linesize[0]),
498                              s->picture.linesize[0], block);
499                 }
500             } else {
501                 if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8)) {
502                     uint64_t aligned_pixels[64/8];
503                     uint8_t *pixels= (uint8_t*)aligned_pixels;
504                     uint8_t *c_ptr, *c_ptr1, *ptr;
505                     int y, linesize;
506                     /* NOTE: at end of line, the macroblock is handled as 420 */
507                     idct_put(pixels, 8, block);
508                     linesize = s->picture.linesize[6 - j];
509                     c_ptr = s->picture.data[6 - j] + c_offset;
510                     ptr = pixels;
511                     for(y = 0;y < 8; y++) {
512                         /* convert to 411P */
513                         c_ptr1 = c_ptr + 8*linesize;
514                         c_ptr[0]= ptr[0]; c_ptr1[0]= ptr[4];
515                         c_ptr[1]= ptr[1]; c_ptr1[1]= ptr[5];
516                         c_ptr[2]= ptr[2]; c_ptr1[2]= ptr[6];
517                         c_ptr[3]= ptr[3]; c_ptr1[3]= ptr[7];
518                         c_ptr += linesize;
519                         ptr += 8;
520                     }
521                 } else {
522                     /* don't ask me why they inverted Cb and Cr ! */
523                     idct_put(s->picture.data[6 - j] + c_offset, 
524                              s->picture.linesize[6 - j], block);
525                 }
526             }
527             block += 64;
528             mb++;
529         }
530     }
531 }
532
533 #ifdef DV_CODEC_TINY_TARGET
534 /* Converts run and level (where level != 0) pair into vlc, returning bit size */
535 static always_inline int dv_rl2vlc(int run, int level, int sign, uint32_t* vlc)
536 {
537     int size;
538     if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {
539         *vlc = dv_vlc_map[run][level].vlc | sign;
540         size = dv_vlc_map[run][level].size;
541     }
542     else { 
543         if (level < DV_VLC_MAP_LEV_SIZE) {
544             *vlc = dv_vlc_map[0][level].vlc | sign;
545             size = dv_vlc_map[0][level].size;
546         } else {
547             *vlc = 0xfe00 | (level << 1) | sign;
548             size = 16;
549         }
550         if (run) {
551             *vlc |= ((run < 16) ? dv_vlc_map[run-1][0].vlc : 
552                                   (0x1f80 | (run - 1))) << size;
553             size += (run < 16) ? dv_vlc_map[run-1][0].size : 13;
554         }
555     }
556     
557     return size;
558 }
559
560 static always_inline int dv_rl2vlc_size(int run, int level)
561 {
562     int size;
563     
564     if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {
565         size = dv_vlc_map[run][level].size; 
566     }
567     else { 
568         size = (level < DV_VLC_MAP_LEV_SIZE) ? dv_vlc_map[0][level].size : 16;
569         if (run) {
570             size += (run < 16) ? dv_vlc_map[run-1][0].size : 13;
571         }
572     }
573     return size;
574 }
575 #else
576 static always_inline int dv_rl2vlc(int run, int l, int sign, uint32_t* vlc)
577 {
578     *vlc = dv_vlc_map[run][l].vlc | sign;
579     return dv_vlc_map[run][l].size;
580 }
581
582 static always_inline int dv_rl2vlc_size(int run, int l)
583 {
584     return dv_vlc_map[run][l].size;
585 }
586 #endif
587
588 typedef struct EncBlockInfo {
589     int area_q[4];
590     int bit_size[4];
591     int prev[5];
592     int cur_ac;
593     int cno;
594     int dct_mode;
595     DCTELEM mb[64];
596     uint8_t next[64];
597     uint8_t sign[64];
598     uint8_t partial_bit_count;
599     uint32_t partial_bit_buffer; /* we can't use uint16_t here */
600 } EncBlockInfo;
601
602 static always_inline PutBitContext* dv_encode_ac(EncBlockInfo* bi, PutBitContext* pb_pool, 
603                                        PutBitContext* pb_end)
604 {
605     int prev;
606     int bits_left;
607     PutBitContext* pb = pb_pool;
608     int size = bi->partial_bit_count;
609     uint32_t vlc = bi->partial_bit_buffer;
610
611     bi->partial_bit_count = bi->partial_bit_buffer = 0;
612     for(;;){
613        /* Find suitable storage space */
614        for (; size > (bits_left = put_bits_left(pb)); pb++) {
615           if (bits_left) {
616               size -= bits_left;
617               put_bits(pb, bits_left, vlc >> size);
618               vlc = vlc & ((1<<size)-1);
619           }
620           if (pb + 1 >= pb_end) {
621               bi->partial_bit_count = size;
622               bi->partial_bit_buffer = vlc;
623               return pb;
624           }
625        }
626        
627        /* Store VLC */
628        put_bits(pb, size, vlc);
629        
630        if(bi->cur_ac>=64)
631            break;
632        
633        /* Construct the next VLC */
634        prev= bi->cur_ac;
635        bi->cur_ac = bi->next[prev];
636        if(bi->cur_ac < 64){
637            size = dv_rl2vlc(bi->cur_ac - prev - 1, bi->mb[bi->cur_ac], bi->sign[bi->cur_ac], &vlc);
638        } else {
639            size = 4; vlc = 6; /* End Of Block stamp */
640        }
641     }
642     return pb;
643 }
644
645 static always_inline void dv_set_class_number(DCTELEM* blk, EncBlockInfo* bi, 
646                                               const uint8_t* zigzag_scan, int bias)
647 {
648     int i, area;
649     static const int classes[] = {12, 24, 36, 0xffff};
650     int max=12;
651     int prev=0;
652
653     bi->mb[0] = blk[0]; 
654     
655     for (area = 0; area < 4; area++) {
656        bi->prev[area] = prev;
657        bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
658        for (i=mb_area_start[area]; i<mb_area_start[area+1]; i++) {
659           int level = blk[zigzag_scan[i]];
660        
661           if (level+15 > 30U) {
662               bi->sign[i] = (level>>31)&1;
663               bi->mb[i] = level= ABS(level)>>4;
664               if(level>max) max= level;
665               bi->bit_size[area] += dv_rl2vlc_size(i - prev  - 1, level);
666               bi->next[prev]= i;
667               prev= i;
668           }
669        }
670     }
671     bi->next[prev]= i;
672     for(bi->cno = 0; max > classes[bi->cno]; bi->cno++);
673
674     bi->cno += bias;
675     
676     if (bi->cno >= 3) {
677         bi->cno = 3;
678         prev=0;
679         i= bi->next[prev];
680         for (area = 0; area < 4; area++) {
681             bi->prev[area] = prev;
682             bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
683             for (; i<mb_area_start[area+1]; i= bi->next[i]) {
684                 bi->mb[i] >>=1;
685             
686                 if (bi->mb[i]) {
687                     bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, bi->mb[i]);
688                     bi->next[prev]= i;
689                     prev= i;
690                 }
691             }
692         }
693         bi->next[prev]= i;
694     }
695 }
696
697 //FIXME replace this by dsputil
698 #define SC(x, y) ((s[x] - s[y]) ^ ((s[x] - s[y]) >> 7))
699 static always_inline int dv_guess_dct_mode(DCTELEM *blk) {
700     DCTELEM *s;
701     int score88 = 0;
702     int score248 = 0;
703     int i;
704     
705     /* Compute 8-8 score (small values give a better chance for 8-8 DCT) */
706     s = blk;
707     for(i=0; i<7; i++) {
708         score88 += SC(0,  8) + SC(1, 9) + SC(2, 10) + SC(3, 11) + 
709                    SC(4, 12) + SC(5,13) + SC(6, 14) + SC(7, 15);
710         s += 8;
711     }
712     /* Compute 2-4-8 score (small values give a better chance for 2-4-8 DCT) */
713     s = blk;
714     for(i=0; i<6; i++) {
715         score248 += SC(0, 16) + SC(1,17) + SC(2, 18) + SC(3, 19) +
716                     SC(4, 20) + SC(5,21) + SC(6, 22) + SC(7, 23);
717         s += 8;
718     }
719
720     return (score88 - score248 > -10);
721 }
722
723 static inline void dv_guess_qnos(EncBlockInfo* blks, int* qnos)
724 {
725     int size[5];
726     int i, j, k, a, prev;
727     EncBlockInfo* b;
728
729     do {
730        b = blks;
731        for (i=0; i<5; i++) {
732           if (!qnos[i])
733               continue;
734           
735           qnos[i]--;
736           size[i] = 0;
737           for (j=0; j<6; j++, b++) {
738              for (a=0; a<4; a++) {
739                 if (b->area_q[a] != dv_quant_shifts[qnos[i] + dv_quant_offset[b->cno]][a]) {
740                     b->bit_size[a] = 1; // 4 areas 4 bits for EOB :)
741                     b->area_q[a]++;
742                     prev= b->prev[a];
743                     for (k= b->next[prev] ; k<mb_area_start[a+1]; k= b->next[k]) {
744                        b->mb[k] >>= 1;
745                        if (b->mb[k]) {
746                            b->bit_size[a] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
747                            prev= k;
748                        } else {
749                            b->next[prev] = b->next[k];
750                        }
751                     }
752                     b->prev[a+1]= prev;
753                 }
754                 size[i] += b->bit_size[a];
755              }
756           }
757        }
758     } while ((vs_total_ac_bits < size[0] + size[1] + size[2] + size[3] + size[4]) && 
759              (qnos[0]|qnos[1]|qnos[2]|qnos[3]|qnos[4]));
760 }
761
762 /*
763  * This is a very rough initial implementaion. The performance is
764  * horrible and the weighting is missing. But it's missing from the 
765  * decoding step also -- so at least we're on the same page with decoder ;-)
766  */
767 static inline void dv_encode_video_segment(DVVideoContext *s, 
768                                            uint8_t *dif, 
769                                            const uint16_t *mb_pos_ptr)
770 {
771     int mb_index, i, j, v;
772     int mb_x, mb_y, c_offset, linesize; 
773     uint8_t*  y_ptr;
774     uint8_t*  data;
775     uint8_t*  ptr;
776     int       do_edge_wrap;
777     DCTELEM   block[64] __align8;
778     EncBlockInfo  enc_blks[5*6];
779     PutBitContext pbs[5*6];
780     PutBitContext* pb; 
781     EncBlockInfo* enc_blk;
782     int       vs_bit_size = 0;
783     int       qnos[5];
784     
785     assert((((int)block) & 7) == 0);
786    
787     enc_blk = &enc_blks[0];
788     pb = &pbs[0];
789     for(mb_index = 0; mb_index < 5; mb_index++) {
790         v = *mb_pos_ptr++;
791         mb_x = v & 0xff;
792         mb_y = v >> 8;
793         y_ptr = s->picture.data[0] + (mb_y * s->picture.linesize[0] * 8) + (mb_x * 8);
794         c_offset = (s->sys->pix_fmt == PIX_FMT_YUV411P) ?
795                    ((mb_y * s->picture.linesize[1] * 8) + ((mb_x >> 2) * 8)) :
796                    (((mb_y >> 1) * s->picture.linesize[1] * 8) + ((mb_x >> 1) * 8));
797         do_edge_wrap = 0;
798         qnos[mb_index] = 15; /* No quantization */
799         ptr = dif + mb_index*80 + 4;
800         for(j = 0;j < 6; j++) {
801             if (j < 4) {  /* Four Y blocks */
802                 /* NOTE: at end of line, the macroblock is handled as 420 */
803                 if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x < (704 / 8)) {
804                     data = y_ptr + (j * 8);
805                 } else {
806                     data = y_ptr + ((j & 1) * 8) + ((j >> 1) * 8 * s->picture.linesize[0]);
807                 }
808                 linesize = s->picture.linesize[0];
809             } else {      /* Cr and Cb blocks */
810                 /* don't ask Fabrice why they inverted Cb and Cr ! */
811                 data = s->picture.data[6 - j] + c_offset;
812                 linesize = s->picture.linesize[6 - j];
813                 if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8))
814                     do_edge_wrap = 1;
815             }   
816             
817             /* Everything is set up -- now just copy data -> DCT block */
818             if (do_edge_wrap) {  /* Edge wrap copy: 4x16 -> 8x8 */
819                 uint8_t* d;
820                 DCTELEM *b = block;
821                 for (i=0;i<8;i++) {
822                    d = data + 8 * linesize;
823                    b[0] = data[0]; b[1] = data[1]; b[2] = data[2]; b[3] = data[3];
824                    b[4] =    d[0]; b[5] =    d[1]; b[6] =    d[2]; b[7] =    d[3];
825                    data += linesize;
826                    b += 8;
827                 }
828             } else {             /* Simple copy: 8x8 -> 8x8 */
829                 s->get_pixels(block, data, linesize);
830             }
831           
832             if(s->avctx->flags & CODEC_FLAG_INTERLACED_DCT)
833                 enc_blk->dct_mode = dv_guess_dct_mode(block);
834             else
835                 enc_blk->dct_mode = 0;
836             enc_blk->area_q[0] = enc_blk->area_q[1] = enc_blk->area_q[2] = enc_blk->area_q[3] = 0;
837             enc_blk->partial_bit_count = 0;
838             enc_blk->partial_bit_buffer = 0;
839             enc_blk->cur_ac = 0;
840             
841             s->fdct[enc_blk->dct_mode](block);
842             
843             dv_set_class_number(block, enc_blk, 
844                                 enc_blk->dct_mode ? ff_zigzag248_direct : ff_zigzag_direct, j/4);
845            
846             init_put_bits(pb, ptr, block_sizes[j]/8);
847             put_bits(pb, 9, (uint16_t)(((enc_blk->mb[0] >> 3) - 1024 + 2) >> 2));
848             put_bits(pb, 1, enc_blk->dct_mode);
849             put_bits(pb, 2, enc_blk->cno);
850             
851             vs_bit_size += enc_blk->bit_size[0] + enc_blk->bit_size[1] +
852                            enc_blk->bit_size[2] + enc_blk->bit_size[3];
853             ++enc_blk;
854             ++pb;
855             ptr += block_sizes[j]/8;
856         }
857     }
858
859     if (vs_total_ac_bits < vs_bit_size)
860         dv_guess_qnos(&enc_blks[0], &qnos[0]);
861
862     for (i=0; i<5; i++) {
863        dif[i*80 + 3] = qnos[i];
864     }
865
866     /* First pass over individual cells only */
867     for (j=0; j<5*6; j++)
868        dv_encode_ac(&enc_blks[j], &pbs[j], &pbs[j+1]);
869
870     /* Second pass over each MB space */
871     for (j=0; j<5*6; j+=6) {
872         pb= &pbs[j];
873         for (i=0; i<6; i++) {
874             if (enc_blks[i+j].partial_bit_count)
875                 pb=dv_encode_ac(&enc_blks[i+j], pb, &pbs[j+6]);
876         }
877     }
878
879     /* Third and final pass over the whole vides segment space */
880     pb= &pbs[0];
881     for (j=0; j<5*6; j++) {
882        if (enc_blks[j].partial_bit_count)
883            pb=dv_encode_ac(&enc_blks[j], pb, &pbs[6*5]);
884     }
885
886     for (j=0; j<5*6; j++)
887        flush_put_bits(&pbs[j]);
888 }
889
890 static int dv_decode_mt(AVCodecContext *avctx, void* sl)
891 {
892     DVVideoContext *s = avctx->priv_data;
893     int slice = (size_t)sl;
894     dv_decode_video_segment(s, &s->buf[((slice/27)*6+(slice/3)+slice*5+7)*80],
895                             &s->sys->video_place[slice*5]);
896     return 0;
897 }
898
899 static int dv_encode_mt(AVCodecContext *avctx, void* sl)
900 {
901     DVVideoContext *s = avctx->priv_data;
902     int slice = (size_t)sl;
903     dv_encode_video_segment(s, &s->buf[((slice/27)*6+(slice/3)+slice*5+7)*80],
904                             &s->sys->video_place[slice*5]);
905     return 0;
906 }
907
908 /* NOTE: exactly one frame must be given (120000 bytes for NTSC,
909    144000 bytes for PAL) */
910 static int dvvideo_decode_frame(AVCodecContext *avctx, 
911                                  void *data, int *data_size,
912                                  uint8_t *buf, int buf_size)
913 {
914     DVVideoContext *s = avctx->priv_data;
915   
916     s->sys = dv_frame_profile(buf);
917     if (!s->sys || buf_size < s->sys->frame_size)
918         return -1; /* NOTE: we only accept several full frames */
919
920     if(s->picture.data[0])
921         avctx->release_buffer(avctx, &s->picture);
922     
923     s->picture.reference = 0;
924     s->picture.key_frame = 1;
925     s->picture.pict_type = FF_I_TYPE;
926     avctx->pix_fmt = s->sys->pix_fmt;
927     avctx->width = s->sys->width;
928     avctx->height = s->sys->height;
929     if(avctx->get_buffer(avctx, &s->picture) < 0) {
930         av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
931         return -1;
932     }
933     s->picture.interlaced_frame = 1;
934     s->picture.top_field_first = 0;
935
936     s->buf = buf;
937     avctx->execute(avctx, dv_decode_mt, (void**)&dv_anchor[0], NULL, 
938                    s->sys->difseg_size * 27);
939     
940     emms_c();
941
942     /* return image */
943     *data_size = sizeof(AVFrame);
944     *(AVFrame*)data= s->picture;
945     
946     return s->sys->frame_size;
947 }
948
949 static int dvvideo_encode_frame(AVCodecContext *c, uint8_t *buf, int buf_size, 
950                                 void *data)
951 {
952     DVVideoContext *s = c->priv_data;
953
954     s->sys = dv_codec_profile(c);
955     if (!s->sys)
956         return -1;
957     if(buf_size < s->sys->frame_size)
958         return -1;
959
960     c->pix_fmt = s->sys->pix_fmt;
961     s->picture = *((AVFrame *)data);
962     s->picture.key_frame = 1;
963     s->picture.pict_type = FF_I_TYPE;
964
965     s->buf = buf;
966     c->execute(c, dv_encode_mt, (void**)&dv_anchor[0], NULL, 
967                s->sys->difseg_size * 27);
968
969     emms_c();
970     return s->sys->frame_size;
971 }
972
973 #ifdef CONFIG_DVVIDEO_ENCODER
974 AVCodec dvvideo_encoder = {
975     "dvvideo",
976     CODEC_TYPE_VIDEO,
977     CODEC_ID_DVVIDEO,
978     sizeof(DVVideoContext),
979     dvvideo_init,
980     dvvideo_encode_frame,
981     NULL,
982     NULL,
983     CODEC_CAP_DR1,
984     NULL
985 };
986 #endif // CONFIG_DVVIDEO_ENCODER
987
988 AVCodec dvvideo_decoder = {
989     "dvvideo",
990     CODEC_TYPE_VIDEO,
991     CODEC_ID_DVVIDEO,
992     sizeof(DVVideoContext),
993     dvvideo_init,
994     NULL,
995     NULL,
996     dvvideo_decode_frame,
997     CODEC_CAP_DR1,
998     NULL
999 };