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