Statistics
| Branch: | Revision:

ffmpeg / libavcodec / dv.c @ 7a886063

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