Statistics
| Branch: | Revision:

ffmpeg / libavcodec / dv.c @ 2912e87a

History | View | Annotate | Download (46.8 KB)

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