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