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