Statistics
| Branch: | Revision:

ffmpeg / libavcodec / dv.c @ 1449b722

History | View | Annotate | Download (38.1 KB)

1 5d2231ee Fabrice Bellard
/*
2
 * DV decoder
3
 * Copyright (c) 2002 Fabrice Bellard.
4 901ee2be Roman Shaposhnik
 * Copyright (c) 2004 Roman Shaposhnik.
5 5d2231ee Fabrice Bellard
 *
6 115329f1 Diego Biurrun
 * DV encoder
7 4fa1c4fa Roman Shaposhnik
 * Copyright (c) 2003 Roman Shaposhnik.
8
 *
9 0b297700 Daniel Maas
 * 50 Mbps (DVCPRO50) support
10
 * Copyright (c) 2006 Daniel Maas <dmaas@maasdigital.com>
11
 *
12 4fa1c4fa Roman Shaposhnik
 * Many thanks to Dan Dennedy <dan@dennedy.org> for providing wealth
13
 * of DV technical info.
14
 *
15 5d2231ee Fabrice Bellard
 * 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 5509bffa Diego Biurrun
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
28 5d2231ee Fabrice Bellard
 */
29 983e3246 Michael Niedermayer
30
/**
31
 * @file dv.c
32 4fa1c4fa Roman Shaposhnik
 * DV codec.
33 983e3246 Michael Niedermayer
 */
34 5d2231ee Fabrice Bellard
#include "avcodec.h"
35
#include "dsputil.h"
36
#include "mpegvideo.h"
37
#include "simple_idct.h"
38 7458ccbb Roman Shaposhnik
#include "dvdata.h"
39 5d2231ee Fabrice Bellard
40 c619ff6d Michael Niedermayer
//#undef NDEBUG
41
//#include <assert.h>
42
43 6faa4645 Roman Shaposhnik
typedef struct DVVideoContext {
44 7458ccbb Roman Shaposhnik
    const DVprofile* sys;
45 492cd3a9 Michael Niedermayer
    AVFrame picture;
46 c619ff6d Michael Niedermayer
    AVCodecContext *avctx;
47 6faa4645 Roman Shaposhnik
    uint8_t *buf;
48 115329f1 Diego Biurrun
49 0c1a9eda Zdenek Kabelac
    uint8_t dv_zigzag[2][64];
50 901ee2be Roman Shaposhnik
    uint8_t dv_idct_shift[2][2][22][64];
51 115329f1 Diego Biurrun
52 7458ccbb Roman Shaposhnik
    void (*get_pixels)(DCTELEM *block, const uint8_t *pixels, int line_size);
53 10acc479 Roman Shaposhnik
    void (*fdct[2])(DCTELEM *block);
54 0c1a9eda Zdenek Kabelac
    void (*idct_put[2])(uint8_t *dest, int line_size, DCTELEM *block);
55 6faa4645 Roman Shaposhnik
} DVVideoContext;
56 5d2231ee Fabrice Bellard
57 0b297700 Daniel Maas
/* 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 aa066582 Roman Shaposhnik
64 7458ccbb Roman Shaposhnik
#define TEX_VLC_BITS 9
65 e15c3302 Roman Shaposhnik
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 115329f1 Diego Biurrun
#define DV_VLC_MAP_RUN_SIZE  64
71 c619ff6d Michael Niedermayer
#define DV_VLC_MAP_LEV_SIZE 512 //FIXME sign was removed so this should be /2 but needs check
72 e15c3302 Roman Shaposhnik
#endif
73
74 5d2231ee Fabrice Bellard
/* XXX: also include quantization */
75 380fd6b1 Roman Shaposhnik
static RL_VLC_ELEM *dv_rl_vlc;
76 e15c3302 Roman Shaposhnik
/* 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 5d2231ee Fabrice Bellard
82 6faa4645 Roman Shaposhnik
static void dv_build_unquantize_tables(DVVideoContext *s, uint8_t* perm)
83 5d2231ee Fabrice Bellard
{
84 7be166e4 Fabrice Bellard
    int i, q, j;
85 5d2231ee Fabrice Bellard
86
    /* NOTE: max left shift is 6 */
87 7be166e4 Fabrice Bellard
    for(q = 0; q < 22; q++) {
88 10acc479 Roman Shaposhnik
        /* 88DCT */
89 7be166e4 Fabrice Bellard
        for(i = 1; i < 64; i++) {
90
            /* 88 table */
91 10acc479 Roman Shaposhnik
            j = perm[i];
92 901ee2be Roman Shaposhnik
            s->dv_idct_shift[0][0][q][j] =
93 7be166e4 Fabrice Bellard
                dv_quant_shifts[q][dv_88_areas[i]] + 1;
94 bb270c08 Diego Biurrun
            s->dv_idct_shift[1][0][q][j] = s->dv_idct_shift[0][0][q][j] + 1;
95 7be166e4 Fabrice Bellard
        }
96 115329f1 Diego Biurrun
97 10acc479 Roman Shaposhnik
        /* 248DCT */
98 7be166e4 Fabrice Bellard
        for(i = 1; i < 64; i++) {
99
            /* 248 table */
100 115329f1 Diego Biurrun
            s->dv_idct_shift[0][1][q][i] =
101 10acc479 Roman Shaposhnik
                dv_quant_shifts[q][dv_248_areas[i]] + 1;
102 bb270c08 Diego Biurrun
            s->dv_idct_shift[1][1][q][i] = s->dv_idct_shift[0][1][q][i] + 1;
103 5d2231ee Fabrice Bellard
        }
104
    }
105
}
106
107 4fa1c4fa Roman Shaposhnik
static int dvvideo_init(AVCodecContext *avctx)
108 5d2231ee Fabrice Bellard
{
109 6faa4645 Roman Shaposhnik
    DVVideoContext *s = avctx->priv_data;
110 10acc479 Roman Shaposhnik
    DSPContext dsp;
111 7604246d Wolfgang Hesseler
    static int done=0;
112 e15c3302 Roman Shaposhnik
    int i, j;
113 5d2231ee Fabrice Bellard
114
    if (!done) {
115 7458ccbb Roman Shaposhnik
        VLC dv_vlc;
116 901ee2be Roman Shaposhnik
        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 5d2231ee Fabrice Bellard
121
        done = 1;
122
123 5b2bf943 Burkhard Plaum
        dv_vlc_map = av_mallocz_static(DV_VLC_MAP_LEV_SIZE*DV_VLC_MAP_RUN_SIZE*sizeof(struct dv_vlc_pair));
124 bb270c08 Diego Biurrun
        if (!dv_vlc_map)
125
            return -ENOMEM;
126
127
        /* dv_anchor lets each thread know its Id */
128 0b297700 Daniel Maas
        for (i=0; i<DV_ANCHOR_SIZE; i++)
129 aa066582 Roman Shaposhnik
            dv_anchor[i] = (void*)(size_t)i;
130 bb270c08 Diego Biurrun
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 115329f1 Diego Biurrun
150 5d2231ee Fabrice Bellard
        /* NOTE: as a trick, we use the fact the no codes are unused
151
           to accelerate the parsing of partial codes */
152 115329f1 Diego Biurrun
        init_vlc(&dv_vlc, TEX_VLC_BITS, j,
153 073c2593 Burkhard Plaum
                 new_dv_vlc_len, 1, 1, new_dv_vlc_bits, 2, 2, 0);
154 5d2231ee Fabrice Bellard
155 c842aa37 Burkhard Plaum
        dv_rl_vlc = av_mallocz_static(dv_vlc.table_size * sizeof(RL_VLC_ELEM));
156 aa066582 Roman Shaposhnik
        if (!dv_rl_vlc)
157 bb270c08 Diego Biurrun
            return -ENOMEM;
158 aa066582 Roman Shaposhnik
159 5d2231ee Fabrice Bellard
        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 115329f1 Diego Biurrun
164 5d2231ee Fabrice Bellard
            if(len<0){ //more bits needed
165
                run= 0;
166
                level= code;
167
            } else {
168 901ee2be Roman Shaposhnik
                run=   new_dv_vlc_run[code] + 1;
169
                level= new_dv_vlc_level[code];
170 5d2231ee Fabrice Bellard
            }
171 380fd6b1 Roman Shaposhnik
            dv_rl_vlc[i].len = len;
172
            dv_rl_vlc[i].level = level;
173
            dv_rl_vlc[i].run = run;
174 5d2231ee Fabrice Bellard
        }
175 bb270c08 Diego Biurrun
        free_vlc(&dv_vlc);
176 7458ccbb Roman Shaposhnik
177 bb270c08 Diego Biurrun
        for (i = 0; i < NB_DV_VLC - 1; i++) {
178 5da42be1 Michael Niedermayer
           if (dv_vlc_run[i] >= DV_VLC_MAP_RUN_SIZE)
179 bb270c08 Diego Biurrun
               continue;
180 5da42be1 Michael Niedermayer
#ifdef DV_CODEC_TINY_TARGET
181
           if (dv_vlc_level[i] >= DV_VLC_MAP_LEV_SIZE)
182 bb270c08 Diego Biurrun
               continue;
183 5da42be1 Michael Niedermayer
#endif
184 115329f1 Diego Biurrun
185 bb270c08 Diego Biurrun
           if (dv_vlc_map[dv_vlc_run[i]][dv_vlc_level[i]].size != 0)
186
               continue;
187 115329f1 Diego Biurrun
188 bb270c08 Diego Biurrun
           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 e15c3302 Roman Shaposhnik
#ifdef DV_CODEC_TINY_TARGET
195 bb270c08 Diego Biurrun
           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 e15c3302 Roman Shaposhnik
#else
204 bb270c08 Diego Biurrun
           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 e15c3302 Roman Shaposhnik
#endif
217 bb270c08 Diego Biurrun
        }
218 5d2231ee Fabrice Bellard
    }
219 7be166e4 Fabrice Bellard
220 10acc479 Roman Shaposhnik
    /* Generic DSP setup */
221
    dsputil_init(&dsp, avctx);
222
    s->get_pixels = dsp.get_pixels;
223 7be166e4 Fabrice Bellard
224 10acc479 Roman Shaposhnik
    /* 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 7be166e4 Fabrice Bellard
230 10acc479 Roman Shaposhnik
    /* 248DCT setup */
231
    s->fdct[1] = dsp.fdct248;
232
    s->idct_put[1] = simple_idct248_put;  // FIXME: need to add it to DSP
233 4325ffd0 Michael Niedermayer
    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 7be166e4 Fabrice Bellard
241 5d2231ee Fabrice Bellard
    /* XXX: do it only for constant case */
242 10acc479 Roman Shaposhnik
    dv_build_unquantize_tables(s, dsp.idct_permutation);
243 7458ccbb Roman Shaposhnik
244 2744ca9a Roman Shaposhnik
    avctx->coded_frame = &s->picture;
245 c619ff6d Michael Niedermayer
    s->avctx= avctx;
246 115329f1 Diego Biurrun
247 5d2231ee Fabrice Bellard
    return 0;
248
}
249
250 7458ccbb Roman Shaposhnik
// #define VLC_DEBUG
251 901ee2be Roman Shaposhnik
// #define printf(...) av_log(NULL, AV_LOG_ERROR, __VA_ARGS__)
252 5d2231ee Fabrice Bellard
253 7be166e4 Fabrice Bellard
typedef struct BlockInfo {
254 0c1a9eda Zdenek Kabelac
    const uint8_t *shift_table;
255
    const uint8_t *scan_table;
256 2e52b44e Dan Maas
    const int *iweight_table;
257 0c1a9eda Zdenek Kabelac
    uint8_t pos; /* position in block */
258
    uint8_t dct_mode;
259
    uint8_t partial_bit_count;
260
    uint16_t partial_bit_buffer;
261 7be166e4 Fabrice Bellard
    int shift_offset;
262
} BlockInfo;
263 5d2231ee Fabrice Bellard
264
/* block size in bits */
265 0c1a9eda Zdenek Kabelac
static const uint16_t block_sizes[6] = {
266 5d2231ee Fabrice Bellard
    112, 112, 112, 112, 80, 80
267
};
268 e15c3302 Roman Shaposhnik
/* 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 115329f1 Diego Biurrun
static const int mb_area_start[5] = { 1, 6, 21, 43, 64 };
272 5d2231ee Fabrice Bellard
273
#ifndef ALT_BITSTREAM_READER
274 924311cd Michael Niedermayer
#warning only works with ALT_BITSTREAM_READER
275 5bb8a0da Michael Niedermayer
static int re_index; //Hack to make it compile
276 5d2231ee Fabrice Bellard
#endif
277
278 58254257 Roman Shaposhnik
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 5d2231ee Fabrice Bellard
/* decode ac coefs */
294 6faa4645 Roman Shaposhnik
static void dv_decode_ac(GetBitContext *gb, BlockInfo *mb, DCTELEM *block)
295 5d2231ee Fabrice Bellard
{
296 6faa4645 Roman Shaposhnik
    int last_index = get_bits_size(gb);
297 0c1a9eda Zdenek Kabelac
    const uint8_t *scan_table = mb->scan_table;
298
    const uint8_t *shift_table = mb->shift_table;
299 2e52b44e Dan Maas
    const int *iweight_table = mb->iweight_table;
300 7be166e4 Fabrice Bellard
    int pos = mb->pos;
301 901ee2be Roman Shaposhnik
    int partial_bit_count = mb->partial_bit_count;
302
    int level, pos1, run, vlc_len, index;
303 115329f1 Diego Biurrun
304 6faa4645 Roman Shaposhnik
    OPEN_READER(re, gb);
305 901ee2be Roman Shaposhnik
    UPDATE_CACHE(re, gb);
306 115329f1 Diego Biurrun
307 5d2231ee Fabrice Bellard
    /* if we must parse a partial vlc, we do it here */
308
    if (partial_bit_count > 0) {
309 901ee2be Roman Shaposhnik
        re_cache = ((unsigned)re_cache >> partial_bit_count) |
310 bb270c08 Diego Biurrun
                   (mb->partial_bit_buffer << (sizeof(re_cache)*8 - partial_bit_count));
311
        re_index -= partial_bit_count;
312
        mb->partial_bit_count = 0;
313 5d2231ee Fabrice Bellard
    }
314
315
    /* get the AC coefficients until last_index is reached */
316
    for(;;) {
317
#ifdef VLC_DEBUG
318 901ee2be Roman Shaposhnik
        printf("%2d: bits=%04x index=%d\n", pos, SHOW_UBITS(re, gb, 16), re_index);
319 5d2231ee Fabrice Bellard
#endif
320 901ee2be Roman Shaposhnik
        /* our own optimized GET_RL_VLC */
321
        index = NEG_USR32(re_cache, TEX_VLC_BITS);
322 bb270c08 Diego Biurrun
        vlc_len = dv_rl_vlc[index].len;
323 901ee2be Roman Shaposhnik
        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 bb270c08 Diego Biurrun
        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 901ee2be Roman Shaposhnik
340
#ifdef VLC_DEBUG
341 bb270c08 Diego Biurrun
        printf("run=%d level=%d\n", run, level);
342 901ee2be Roman Shaposhnik
#endif
343 bb270c08 Diego Biurrun
        pos += run;
344
        if (pos >= 64)
345
            break;
346 115329f1 Diego Biurrun
347 c619ff6d Michael Niedermayer
        pos1 = scan_table[pos];
348 2e52b44e Dan Maas
        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 901ee2be Roman Shaposhnik
355
        UPDATE_CACHE(re, gb);
356 5d2231ee Fabrice Bellard
    }
357 6faa4645 Roman Shaposhnik
    CLOSE_READER(re, gb);
358 7be166e4 Fabrice Bellard
    mb->pos = pos;
359 5d2231ee Fabrice Bellard
}
360
361 380fd6b1 Roman Shaposhnik
static inline void bit_copy(PutBitContext *pb, GetBitContext *gb)
362 5d2231ee Fabrice Bellard
{
363 380fd6b1 Roman Shaposhnik
    int bits_left = get_bits_left(gb);
364 c619ff6d Michael Niedermayer
    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 5d2231ee Fabrice Bellard
    }
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 115329f1 Diego Biurrun
static inline void dv_decode_video_segment(DVVideoContext *s,
375
                                           uint8_t *buf_ptr1,
376 0c1a9eda Zdenek Kabelac
                                           const uint16_t *mb_pos_ptr)
377 5d2231ee Fabrice Bellard
{
378
    int quant, dc, dct_mode, class1, j;
379
    int mb_index, mb_x, mb_y, v, last_index;
380
    DCTELEM *block, *block1;
381 380fd6b1 Roman Shaposhnik
    int c_offset;
382 0c1a9eda Zdenek Kabelac
    uint8_t *y_ptr;
383
    void (*idct_put)(uint8_t *dest, int line_size, DCTELEM *block);
384
    uint8_t *buf_ptr;
385 5d2231ee Fabrice Bellard
    PutBitContext pb, vs_pb;
386 6faa4645 Roman Shaposhnik
    GetBitContext gb;
387
    BlockInfo mb_data[5 * 6], *mb, *mb1;
388 68b51e58 Steve L'Homme
    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 4325ffd0 Michael Niedermayer
    const int log2_blocksize= 3-s->avctx->lowres;
392 115329f1 Diego Biurrun
393 c619ff6d Michael Niedermayer
    assert((((int)mb_bit_buffer)&7)==0);
394
    assert((((int)vs_bit_buffer)&7)==0);
395 115329f1 Diego Biurrun
396 6faa4645 Roman Shaposhnik
    memset(sblock, 0, sizeof(sblock));
397 5d2231ee Fabrice Bellard
398
    /* pass 1 : read DC and AC coefficients in blocks */
399
    buf_ptr = buf_ptr1;
400 6faa4645 Roman Shaposhnik
    block1 = &sblock[0][0];
401 7be166e4 Fabrice Bellard
    mb1 = mb_data;
402 ed7debda Alex Beregszaszi
    init_put_bits(&vs_pb, vs_bit_buffer, 5 * 80);
403 380fd6b1 Roman Shaposhnik
    for(mb_index = 0; mb_index < 5; mb_index++, mb1 += 6, block1 += 6 * 64) {
404 5d2231ee Fabrice Bellard
        /* skip header */
405
        quant = buf_ptr[3] & 0x0f;
406
        buf_ptr += 4;
407 ed7debda Alex Beregszaszi
        init_put_bits(&pb, mb_bit_buffer, 80);
408 7be166e4 Fabrice Bellard
        mb = mb1;
409 5d2231ee Fabrice Bellard
        block = block1;
410
        for(j = 0;j < 6; j++) {
411 380fd6b1 Roman Shaposhnik
            last_index = block_sizes[j];
412 bb270c08 Diego Biurrun
            init_get_bits(&gb, buf_ptr, last_index);
413 115329f1 Diego Biurrun
414 5d2231ee Fabrice Bellard
            /* get the dc */
415 21e19131 Jeff Muizelaar
            dc = get_sbits(&gb, 9);
416 6faa4645 Roman Shaposhnik
            dct_mode = get_bits1(&gb);
417 7be166e4 Fabrice Bellard
            mb->dct_mode = dct_mode;
418
            mb->scan_table = s->dv_zigzag[dct_mode];
419 2e52b44e Dan Maas
            mb->iweight_table = dct_mode ? dv_iweight_248 : dv_iweight_88;
420 6faa4645 Roman Shaposhnik
            class1 = get_bits(&gb, 2);
421 901ee2be Roman Shaposhnik
            mb->shift_table = s->dv_idct_shift[class1 == 3][dct_mode]
422 5d2231ee Fabrice Bellard
                [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 7be166e4 Fabrice Bellard
            mb->pos = 0;
430
            mb->partial_bit_count = 0;
431 5d2231ee Fabrice Bellard
432 4fa1c4fa Roman Shaposhnik
#ifdef VLC_DEBUG
433
            printf("MB block: %d, %d ", mb_index, j);
434
#endif
435 6faa4645 Roman Shaposhnik
            dv_decode_ac(&gb, mb, block);
436 5d2231ee Fabrice Bellard
437
            /* write the remaining bits  in a new buffer only if the
438
               block is finished */
439 380fd6b1 Roman Shaposhnik
            if (mb->pos >= 64)
440 6faa4645 Roman Shaposhnik
                bit_copy(&pb, &gb);
441 115329f1 Diego Biurrun
442 5d2231ee Fabrice Bellard
            block += 64;
443 7be166e4 Fabrice Bellard
            mb++;
444 5d2231ee Fabrice Bellard
        }
445 115329f1 Diego Biurrun
446 5d2231ee Fabrice Bellard
        /* pass 2 : we can do it just after */
447
#ifdef VLC_DEBUG
448 380fd6b1 Roman Shaposhnik
        printf("***pass 2 size=%d MB#=%d\n", put_bits_count(&pb), mb_index);
449 5d2231ee Fabrice Bellard
#endif
450
        block = block1;
451 7be166e4 Fabrice Bellard
        mb = mb1;
452 6faa4645 Roman Shaposhnik
        init_get_bits(&gb, mb_bit_buffer, put_bits_count(&pb));
453 bb270c08 Diego Biurrun
        flush_put_bits(&pb);
454 380fd6b1 Roman Shaposhnik
        for(j = 0;j < 6; j++, block += 64, mb++) {
455 6faa4645 Roman Shaposhnik
            if (mb->pos < 64 && get_bits_left(&gb) > 0) {
456
                dv_decode_ac(&gb, mb, block);
457 5d2231ee Fabrice Bellard
                /* if still not finished, no need to parse other blocks */
458 380fd6b1 Roman Shaposhnik
                if (mb->pos < 64)
459
                    break;
460 5d2231ee Fabrice Bellard
            }
461
        }
462
        /* all blocks are finished, so the extra bytes can be used at
463
           the video segment level */
464 380fd6b1 Roman Shaposhnik
        if (j >= 6)
465 bb270c08 Diego Biurrun
            bit_copy(&vs_pb, &gb);
466 5d2231ee Fabrice Bellard
    }
467
468
    /* we need a pass other the whole video segment */
469
#ifdef VLC_DEBUG
470 380fd6b1 Roman Shaposhnik
    printf("***pass 3 size=%d\n", put_bits_count(&vs_pb));
471 5d2231ee Fabrice Bellard
#endif
472 6faa4645 Roman Shaposhnik
    block = &sblock[0][0];
473 5d2231ee Fabrice Bellard
    mb = mb_data;
474 6faa4645 Roman Shaposhnik
    init_get_bits(&gb, vs_bit_buffer, put_bits_count(&vs_pb));
475 380fd6b1 Roman Shaposhnik
    flush_put_bits(&vs_pb);
476 5d2231ee Fabrice Bellard
    for(mb_index = 0; mb_index < 5; mb_index++) {
477
        for(j = 0;j < 6; j++) {
478 380fd6b1 Roman Shaposhnik
            if (mb->pos < 64) {
479 5d2231ee Fabrice Bellard
#ifdef VLC_DEBUG
480
                printf("start %d:%d\n", mb_index, j);
481
#endif
482 6faa4645 Roman Shaposhnik
                dv_decode_ac(&gb, mb, block);
483 5d2231ee Fabrice Bellard
            }
484 bb270c08 Diego Biurrun
            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 5d2231ee Fabrice Bellard
            block += 64;
487 7be166e4 Fabrice Bellard
            mb++;
488 5d2231ee Fabrice Bellard
        }
489
    }
490 115329f1 Diego Biurrun
491 5d2231ee Fabrice Bellard
    /* compute idct and place blocks */
492 6faa4645 Roman Shaposhnik
    block = &sblock[0][0];
493 5d2231ee Fabrice Bellard
    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 0b297700 Daniel Maas
        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 4325ffd0 Michael Niedermayer
            c_offset = ((mb_y * s->picture.linesize[1] + (mb_x >> 2))<<log2_blocksize);
501 0b297700 Daniel Maas
        } 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 5d2231ee Fabrice Bellard
        for(j = 0;j < 6; j++) {
509 4325ffd0 Michael Niedermayer
            idct_put = s->idct_put[mb->dct_mode && log2_blocksize==3];
510 0b297700 Daniel Maas
            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 7458ccbb Roman Shaposhnik
                             s->picture.linesize[0], block);
515 0b297700 Daniel Maas
                } 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 5d2231ee Fabrice Bellard
                }
520 0b297700 Daniel Maas
                /* 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 1c05e11d Fabrice Bellard
                    }
530
                } else {
531 0b297700 Daniel Maas
                    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 1c05e11d Fabrice Bellard
                }
556 5d2231ee Fabrice Bellard
            }
557
            block += 64;
558 7be166e4 Fabrice Bellard
            mb++;
559 5d2231ee Fabrice Bellard
        }
560
    }
561
}
562
563 e15c3302 Roman Shaposhnik
#ifdef DV_CODEC_TINY_TARGET
564 4fa1c4fa Roman Shaposhnik
/* Converts run and level (where level != 0) pair into vlc, returning bit size */
565 c619ff6d Michael Niedermayer
static always_inline int dv_rl2vlc(int run, int level, int sign, uint32_t* vlc)
566 4fa1c4fa Roman Shaposhnik
{
567
    int size;
568 e15c3302 Roman Shaposhnik
    if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {
569
        *vlc = dv_vlc_map[run][level].vlc | sign;
570 bb270c08 Diego Biurrun
        size = dv_vlc_map[run][level].size;
571 4fa1c4fa Roman Shaposhnik
    }
572 115329f1 Diego Biurrun
    else {
573 e15c3302 Roman Shaposhnik
        if (level < DV_VLC_MAP_LEV_SIZE) {
574 bb270c08 Diego Biurrun
            *vlc = dv_vlc_map[0][level].vlc | sign;
575
            size = dv_vlc_map[0][level].size;
576
        } else {
577 e15c3302 Roman Shaposhnik
            *vlc = 0xfe00 | (level << 1) | sign;
578 bb270c08 Diego Biurrun
            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 4fa1c4fa Roman Shaposhnik
    }
586 115329f1 Diego Biurrun
587 4fa1c4fa Roman Shaposhnik
    return size;
588
}
589
590 c619ff6d Michael Niedermayer
static always_inline int dv_rl2vlc_size(int run, int level)
591 e15c3302 Roman Shaposhnik
{
592
    int size;
593 115329f1 Diego Biurrun
594 e15c3302 Roman Shaposhnik
    if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {
595 bb270c08 Diego Biurrun
        size = dv_vlc_map[run][level].size;
596 e15c3302 Roman Shaposhnik
    }
597 115329f1 Diego Biurrun
    else {
598 bb270c08 Diego Biurrun
        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 e15c3302 Roman Shaposhnik
    }
603
    return size;
604
}
605
#else
606 c619ff6d Michael Niedermayer
static always_inline int dv_rl2vlc(int run, int l, int sign, uint32_t* vlc)
607 e15c3302 Roman Shaposhnik
{
608 c619ff6d Michael Niedermayer
    *vlc = dv_vlc_map[run][l].vlc | sign;
609
    return dv_vlc_map[run][l].size;
610 e15c3302 Roman Shaposhnik
}
611
612
static always_inline int dv_rl2vlc_size(int run, int l)
613
{
614 c619ff6d Michael Niedermayer
    return dv_vlc_map[run][l].size;
615 e15c3302 Roman Shaposhnik
}
616
#endif
617
618 4fa1c4fa Roman Shaposhnik
typedef struct EncBlockInfo {
619 e15c3302 Roman Shaposhnik
    int area_q[4];
620
    int bit_size[4];
621 c619ff6d Michael Niedermayer
    int prev[5];
622 e15c3302 Roman Shaposhnik
    int cur_ac;
623 4fa1c4fa Roman Shaposhnik
    int cno;
624
    int dct_mode;
625 c619ff6d Michael Niedermayer
    DCTELEM mb[64];
626
    uint8_t next[64];
627
    uint8_t sign[64];
628 e15c3302 Roman Shaposhnik
    uint8_t partial_bit_count;
629
    uint32_t partial_bit_buffer; /* we can't use uint16_t here */
630 4fa1c4fa Roman Shaposhnik
} EncBlockInfo;
631
632 115329f1 Diego Biurrun
static always_inline PutBitContext* dv_encode_ac(EncBlockInfo* bi, PutBitContext* pb_pool,
633 c619ff6d Michael Niedermayer
                                       PutBitContext* pb_end)
634 4fa1c4fa Roman Shaposhnik
{
635 c619ff6d Michael Niedermayer
    int prev;
636 e15c3302 Roman Shaposhnik
    int bits_left;
637
    PutBitContext* pb = pb_pool;
638
    int size = bi->partial_bit_count;
639
    uint32_t vlc = bi->partial_bit_buffer;
640 c619ff6d Michael Niedermayer
641 e15c3302 Roman Shaposhnik
    bi->partial_bit_count = bi->partial_bit_buffer = 0;
642 c619ff6d Michael Niedermayer
    for(;;){
643 e15c3302 Roman Shaposhnik
       /* Find suitable storage space */
644 e7a18d5d Roman Shaposhnik
       for (; size > (bits_left = put_bits_left(pb)); pb++) {
645 e15c3302 Roman Shaposhnik
          if (bits_left) {
646
              size -= bits_left;
647 bb270c08 Diego Biurrun
              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 e15c3302 Roman Shaposhnik
       }
656 115329f1 Diego Biurrun
657 e15c3302 Roman Shaposhnik
       /* Store VLC */
658
       put_bits(pb, size, vlc);
659 115329f1 Diego Biurrun
660 c619ff6d Michael Niedermayer
       if(bi->cur_ac>=64)
661
           break;
662 115329f1 Diego Biurrun
663 e15c3302 Roman Shaposhnik
       /* Construct the next VLC */
664 c619ff6d Michael Niedermayer
       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 e15c3302 Roman Shaposhnik
           size = 4; vlc = 6; /* End Of Block stamp */
670
       }
671 c619ff6d Michael Niedermayer
    }
672
    return pb;
673 4fa1c4fa Roman Shaposhnik
}
674
675 115329f1 Diego Biurrun
static always_inline void dv_set_class_number(DCTELEM* blk, EncBlockInfo* bi,
676 2e52b44e Dan Maas
                                              const uint8_t* zigzag_scan, const int *weight, int bias)
677 4fa1c4fa Roman Shaposhnik
{
678 e15c3302 Roman Shaposhnik
    int i, area;
679 40116978 Dan Maas
    /* 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 c619ff6d Michael Niedermayer
    static const int classes[] = {12, 24, 36, 0xffff};
691 40116978 Dan Maas
#else /* improved ffmpeg method */
692
    static const int classes[] = {-1, -1, 255, 0xffff};
693
#endif
694
    int max=classes[0];
695 c619ff6d Michael Niedermayer
    int prev=0;
696 e15c3302 Roman Shaposhnik
697 115329f1 Diego Biurrun
    bi->mb[0] = blk[0];
698
699 e15c3302 Roman Shaposhnik
    for (area = 0; area < 4; area++) {
700 c619ff6d Michael Niedermayer
       bi->prev[area] = prev;
701
       bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
702 e15c3302 Roman Shaposhnik
       for (i=mb_area_start[area]; i<mb_area_start[area+1]; i++) {
703 c619ff6d Michael Niedermayer
          int level = blk[zigzag_scan[i]];
704 115329f1 Diego Biurrun
705 c619ff6d Michael Niedermayer
          if (level+15 > 30U) {
706
              bi->sign[i] = (level>>31)&1;
707 2e52b44e Dan Maas
              /* 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 c619ff6d Michael Niedermayer
              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 e15c3302 Roman Shaposhnik
       }
718 4fa1c4fa Roman Shaposhnik
    }
719 c619ff6d Michael Niedermayer
    bi->next[prev]= i;
720
    for(bi->cno = 0; max > classes[bi->cno]; bi->cno++);
721
722 e15c3302 Roman Shaposhnik
    bi->cno += bias;
723 115329f1 Diego Biurrun
724 c619ff6d Michael Niedermayer
    if (bi->cno >= 3) {
725 4fa1c4fa Roman Shaposhnik
        bi->cno = 3;
726 c619ff6d Michael Niedermayer
        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 115329f1 Diego Biurrun
734 c619ff6d Michael Niedermayer
                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 e15c3302 Roman Shaposhnik
    }
743 4fa1c4fa Roman Shaposhnik
}
744
745 c619ff6d Michael Niedermayer
//FIXME replace this by dsputil
746 e15c3302 Roman Shaposhnik
#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 115329f1 Diego Biurrun
753 e15c3302 Roman Shaposhnik
    /* 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 115329f1 Diego Biurrun
        score88 += SC(0,  8) + SC(1, 9) + SC(2, 10) + SC(3, 11) +
757 bb270c08 Diego Biurrun
                   SC(4, 12) + SC(5,13) + SC(6, 14) + SC(7, 15);
758 e15c3302 Roman Shaposhnik
        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 bb270c08 Diego Biurrun
                    SC(4, 20) + SC(5,21) + SC(6, 22) + SC(7, 23);
765 e15c3302 Roman Shaposhnik
        s += 8;
766 10acc479 Roman Shaposhnik
    }
767 e15c3302 Roman Shaposhnik
768
    return (score88 - score248 > -10);
769
}
770
771
static inline void dv_guess_qnos(EncBlockInfo* blks, int* qnos)
772
{
773
    int size[5];
774 d2d230a7 Michael Niedermayer
    int i, j, k, a, prev, a2;
775 e15c3302 Roman Shaposhnik
    EncBlockInfo* b;
776 c619ff6d Michael Niedermayer
777 6df5f6ae Dan Maas
    size[0] = size[1] = size[2] = size[3] = size[4] = 1<<24;
778 e15c3302 Roman Shaposhnik
    do {
779
       b = blks;
780
       for (i=0; i<5; i++) {
781
          if (!qnos[i])
782 bb270c08 Diego Biurrun
              continue;
783 115329f1 Diego Biurrun
784 bb270c08 Diego Biurrun
          qnos[i]--;
785
          size[i] = 0;
786 e15c3302 Roman Shaposhnik
          for (j=0; j<6; j++, b++) {
787 bb270c08 Diego Biurrun
             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 c619ff6d Michael Niedermayer
                    prev= b->prev[a];
792 d676478c Michael Niedermayer
                    assert(b->next[prev] >= mb_area_start[a+1] || b->mb[prev]);
793 c619ff6d Michael Niedermayer
                    for (k= b->next[prev] ; k<mb_area_start[a+1]; k= b->next[k]) {
794 bb270c08 Diego Biurrun
                       b->mb[k] >>= 1;
795
                       if (b->mb[k]) {
796 c619ff6d Michael Niedermayer
                           b->bit_size[a] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
797 bb270c08 Diego Biurrun
                           prev= k;
798 c619ff6d Michael Niedermayer
                       } else {
799 d2d230a7 Michael Niedermayer
                           if(b->next[k] >= mb_area_start[a+1] && b->next[k]<64){
800 6df5f6ae Dan Maas
                                for(a2=a+1; b->next[k] >= mb_area_start[a2+1]; a2++)
801
                                    b->prev[a2] = prev;
802 d2d230a7 Michael Niedermayer
                                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 d676478c Michael Niedermayer
                                assert(b->prev[a2]==k && (a2+1 >= 4 || b->prev[a2+1]!=k));
807
                                b->prev[a2] = prev;
808 d2d230a7 Michael Niedermayer
                           }
809 c619ff6d Michael Niedermayer
                           b->next[prev] = b->next[k];
810
                       }
811 bb270c08 Diego Biurrun
                    }
812 c619ff6d Michael Niedermayer
                    b->prev[a+1]= prev;
813 bb270c08 Diego Biurrun
                }
814
                size[i] += b->bit_size[a];
815
             }
816
          }
817 6661b213 Michael Niedermayer
          if(vs_total_ac_bits >= size[0] + size[1] + size[2] + size[3] + size[4])
818
                return;
819 e15c3302 Roman Shaposhnik
       }
820 d2d230a7 Michael Niedermayer
    } 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 7bdb4f67 Michael Niedermayer
        size[0] = 5*6*4; //EOB
826 d2d230a7 Michael Niedermayer
        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 10acc479 Roman Shaposhnik
}
839
840 115329f1 Diego Biurrun
static inline void dv_encode_video_segment(DVVideoContext *s,
841
                                           uint8_t *dif,
842 4fa1c4fa Roman Shaposhnik
                                           const uint16_t *mb_pos_ptr)
843
{
844
    int mb_index, i, j, v;
845 115329f1 Diego Biurrun
    int mb_x, mb_y, c_offset, linesize;
846 4fa1c4fa Roman Shaposhnik
    uint8_t*  y_ptr;
847
    uint8_t*  data;
848 e15c3302 Roman Shaposhnik
    uint8_t*  ptr;
849 4fa1c4fa Roman Shaposhnik
    int       do_edge_wrap;
850 68b51e58 Steve L'Homme
    DECLARE_ALIGNED_8(DCTELEM, block[64]);
851 4fa1c4fa Roman Shaposhnik
    EncBlockInfo  enc_blks[5*6];
852 e15c3302 Roman Shaposhnik
    PutBitContext pbs[5*6];
853 115329f1 Diego Biurrun
    PutBitContext* pb;
854 4fa1c4fa Roman Shaposhnik
    EncBlockInfo* enc_blk;
855 e15c3302 Roman Shaposhnik
    int       vs_bit_size = 0;
856
    int       qnos[5];
857 115329f1 Diego Biurrun
858 c619ff6d Michael Niedermayer
    assert((((int)block) & 7) == 0);
859 115329f1 Diego Biurrun
860 10acc479 Roman Shaposhnik
    enc_blk = &enc_blks[0];
861 e15c3302 Roman Shaposhnik
    pb = &pbs[0];
862 4fa1c4fa Roman Shaposhnik
    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 0b297700 Daniel Maas
        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 bb270c08 Diego Biurrun
        do_edge_wrap = 0;
877
        qnos[mb_index] = 15; /* No quantization */
878 e15c3302 Roman Shaposhnik
        ptr = dif + mb_index*80 + 4;
879 4fa1c4fa Roman Shaposhnik
        for(j = 0;j < 6; j++) {
880 0b297700 Daniel Maas
            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 4fa1c4fa Roman Shaposhnik
                } else {
891 0b297700 Daniel Maas
                    /* 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 4fa1c4fa Roman Shaposhnik
                }
912 bb270c08 Diego Biurrun
            }
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 4fa1c4fa Roman Shaposhnik
                   b[4] =    d[0]; b[5] =    d[1]; b[6] =    d[2]; b[7] =    d[3];
922 bb270c08 Diego Biurrun
                   data += linesize;
923
                   b += 8;
924
                }
925
            } else {             /* Simple copy: 8x8 -> 8x8 */
926 0b297700 Daniel Maas
                if (!dummy)
927
                    s->get_pixels(block, data, linesize);
928 bb270c08 Diego Biurrun
            }
929 115329f1 Diego Biurrun
930 c619ff6d Michael Niedermayer
            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 bb270c08 Diego Biurrun
            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 115329f1 Diego Biurrun
939 0b297700 Daniel Maas
            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 115329f1 Diego Biurrun
947 bb270c08 Diego Biurrun
            dv_set_class_number(block, enc_blk,
948 2e52b44e Dan Maas
                                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 115329f1 Diego Biurrun
952 e15c3302 Roman Shaposhnik
            init_put_bits(pb, ptr, block_sizes[j]/8);
953 bb270c08 Diego Biurrun
            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 4fa1c4fa Roman Shaposhnik
        }
963
    }
964
965 e15c3302 Roman Shaposhnik
    if (vs_total_ac_bits < vs_bit_size)
966
        dv_guess_qnos(&enc_blks[0], &qnos[0]);
967 4fa1c4fa Roman Shaposhnik
968
    for (i=0; i<5; i++) {
969 e15c3302 Roman Shaposhnik
       dif[i*80 + 3] = qnos[i];
970
    }
971 4fa1c4fa Roman Shaposhnik
972 e15c3302 Roman Shaposhnik
    /* First pass over individual cells only */
973
    for (j=0; j<5*6; j++)
974 c619ff6d Michael Niedermayer
       dv_encode_ac(&enc_blks[j], &pbs[j], &pbs[j+1]);
975 4fa1c4fa Roman Shaposhnik
976 e15c3302 Roman Shaposhnik
    /* Second pass over each MB space */
977 c619ff6d Michael Niedermayer
    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 4fa1c4fa Roman Shaposhnik
    }
984
985 e15c3302 Roman Shaposhnik
    /* Third and final pass over the whole vides segment space */
986 c619ff6d Michael Niedermayer
    pb= &pbs[0];
987 e15c3302 Roman Shaposhnik
    for (j=0; j<5*6; j++) {
988 c619ff6d Michael Niedermayer
       if (enc_blks[j].partial_bit_count)
989
           pb=dv_encode_ac(&enc_blks[j], pb, &pbs[6*5]);
990 fe78f7cd Michael Niedermayer
       if (enc_blks[j].partial_bit_count)
991
            av_log(NULL, AV_LOG_ERROR, "ac bitstream overflow\n");
992 4fa1c4fa Roman Shaposhnik
    }
993 e15c3302 Roman Shaposhnik
994
    for (j=0; j<5*6; j++)
995
       flush_put_bits(&pbs[j]);
996 4fa1c4fa Roman Shaposhnik
}
997
998 6faa4645 Roman Shaposhnik
static int dv_decode_mt(AVCodecContext *avctx, void* sl)
999
{
1000
    DVVideoContext *s = avctx->priv_data;
1001 7906085f Falk Hüffner
    int slice = (size_t)sl;
1002 0b297700 Daniel Maas
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 bb270c08 Diego Biurrun
                            &s->sys->video_place[slice*5]);
1014 6faa4645 Roman Shaposhnik
    return 0;
1015
}
1016
1017
static int dv_encode_mt(AVCodecContext *avctx, void* sl)
1018
{
1019
    DVVideoContext *s = avctx->priv_data;
1020 7906085f Falk Hüffner
    int slice = (size_t)sl;
1021 0b297700 Daniel Maas
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 bb270c08 Diego Biurrun
                            &s->sys->video_place[slice*5]);
1033 6faa4645 Roman Shaposhnik
    return 0;
1034
}
1035
1036 5d2231ee Fabrice Bellard
/* NOTE: exactly one frame must be given (120000 bytes for NTSC,
1037 0b297700 Daniel Maas
   144000 bytes for PAL - or twice those for 50Mbps) */
1038 115329f1 Diego Biurrun
static int dvvideo_decode_frame(AVCodecContext *avctx,
1039 5d2231ee Fabrice Bellard
                                 void *data, int *data_size,
1040 0c1a9eda Zdenek Kabelac
                                 uint8_t *buf, int buf_size)
1041 5d2231ee Fabrice Bellard
{
1042 6faa4645 Roman Shaposhnik
    DVVideoContext *s = avctx->priv_data;
1043 115329f1 Diego Biurrun
1044 7458ccbb Roman Shaposhnik
    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 e9feea59 Arpi
1048 e20c4069 Michael Niedermayer
    if(s->picture.data[0])
1049
        avctx->release_buffer(avctx, &s->picture);
1050 115329f1 Diego Biurrun
1051 7458ccbb Roman Shaposhnik
    s->picture.reference = 0;
1052 856170f7 Edward Hervey
    s->picture.key_frame = 1;
1053
    s->picture.pict_type = FF_I_TYPE;
1054 7458ccbb Roman Shaposhnik
    avctx->pix_fmt = s->sys->pix_fmt;
1055 4325ffd0 Michael Niedermayer
    avcodec_set_dimensions(avctx, s->sys->width, s->sys->height);
1056 1e491e29 Michael Niedermayer
    if(avctx->get_buffer(avctx, &s->picture) < 0) {
1057 9b879566 Michel Bardiaux
        av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1058 1e491e29 Michael Niedermayer
        return -1;
1059 b0397e0e Zdenek Kabelac
    }
1060 2744ca9a Roman Shaposhnik
    s->picture.interlaced_frame = 1;
1061 9dad924e Michael Niedermayer
    s->picture.top_field_first = 0;
1062 b0397e0e Zdenek Kabelac
1063 6faa4645 Roman Shaposhnik
    s->buf = buf;
1064 aa066582 Roman Shaposhnik
    avctx->execute(avctx, dv_decode_mt, (void**)&dv_anchor[0], NULL,
1065 0b297700 Daniel Maas
                   s->sys->n_difchan * s->sys->difseg_size * 27);
1066 115329f1 Diego Biurrun
1067 9e398782 Arpi
    emms_c();
1068
1069 5d2231ee Fabrice Bellard
    /* return image */
1070 492cd3a9 Michael Niedermayer
    *data_size = sizeof(AVFrame);
1071
    *(AVFrame*)data= s->picture;
1072 115329f1 Diego Biurrun
1073 7458ccbb Roman Shaposhnik
    return s->sys->frame_size;
1074 5d2231ee Fabrice Bellard
}
1075
1076 115329f1 Diego Biurrun
static int dvvideo_encode_frame(AVCodecContext *c, uint8_t *buf, int buf_size,
1077 4fa1c4fa Roman Shaposhnik
                                void *data)
1078 5d2231ee Fabrice Bellard
{
1079 6faa4645 Roman Shaposhnik
    DVVideoContext *s = c->priv_data;
1080 4fa1c4fa Roman Shaposhnik
1081
    s->sys = dv_codec_profile(c);
1082
    if (!s->sys)
1083 bb270c08 Diego Biurrun
        return -1;
1084 0ecca7a4 Michael Niedermayer
    if(buf_size < s->sys->frame_size)
1085
        return -1;
1086
1087 4fa1c4fa Roman Shaposhnik
    c->pix_fmt = s->sys->pix_fmt;
1088
    s->picture = *((AVFrame *)data);
1089 856170f7 Edward Hervey
    s->picture.key_frame = 1;
1090
    s->picture.pict_type = FF_I_TYPE;
1091 4fa1c4fa Roman Shaposhnik
1092 6faa4645 Roman Shaposhnik
    s->buf = buf;
1093 aa066582 Roman Shaposhnik
    c->execute(c, dv_encode_mt, (void**)&dv_anchor[0], NULL,
1094 0b297700 Daniel Maas
               s->sys->n_difchan * s->sys->difseg_size * 27);
1095 5d2231ee Fabrice Bellard
1096 4fa1c4fa Roman Shaposhnik
    emms_c();
1097 0b297700 Daniel Maas
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 4fa1c4fa Roman Shaposhnik
    return s->sys->frame_size;
1112
}
1113
1114 c842aa37 Burkhard Plaum
static int dvvideo_close(AVCodecContext *c)
1115
{
1116
1117
    return 0;
1118
}
1119
1120
1121 983ea0bc Roine Gustafsson
#ifdef CONFIG_DVVIDEO_ENCODER
1122 6faa4645 Roman Shaposhnik
AVCodec dvvideo_encoder = {
1123
    "dvvideo",
1124
    CODEC_TYPE_VIDEO,
1125
    CODEC_ID_DVVIDEO,
1126
    sizeof(DVVideoContext),
1127
    dvvideo_init,
1128
    dvvideo_encode_frame,
1129 c842aa37 Burkhard Plaum
    dvvideo_close,
1130 6faa4645 Roman Shaposhnik
    NULL,
1131
    CODEC_CAP_DR1,
1132
    NULL
1133
};
1134 983ea0bc Roine Gustafsson
#endif // CONFIG_DVVIDEO_ENCODER
1135 5d2231ee Fabrice Bellard
1136
AVCodec dvvideo_decoder = {
1137
    "dvvideo",
1138
    CODEC_TYPE_VIDEO,
1139
    CODEC_ID_DVVIDEO,
1140 6faa4645 Roman Shaposhnik
    sizeof(DVVideoContext),
1141 4fa1c4fa Roman Shaposhnik
    dvvideo_init,
1142 6faa4645 Roman Shaposhnik
    NULL,
1143 c842aa37 Burkhard Plaum
    dvvideo_close,
1144 5d2231ee Fabrice Bellard
    dvvideo_decode_frame,
1145 b0397e0e Zdenek Kabelac
    CODEC_CAP_DR1,
1146 5d2231ee Fabrice Bellard
    NULL
1147
};