GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavcodec/dvenc.c Lines: 458 513 89.3 %
Date: 2021-01-20 23:14:43 Branches: 223 278 80.2 %

Line Branch Exec Source
1
/*
2
 * DV encoder
3
 * Copyright (c) 2003 Roman Shaposhnik
4
 *
5
 * This file is part of FFmpeg.
6
 *
7
 * FFmpeg is free software; you can redistribute it and/or
8
 * modify it under the terms of the GNU Lesser General Public
9
 * License as published by the Free Software Foundation; either
10
 * version 2.1 of the License, or (at your option) any later version.
11
 *
12
 * FFmpeg is distributed in the hope that it will be useful,
13
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15
 * Lesser General Public License for more details.
16
 *
17
 * You should have received a copy of the GNU Lesser General Public
18
 * License along with FFmpeg; if not, write to the Free Software
19
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20
 *
21
 * quant_deadzone code and fixes sponsored by NOA GmbH
22
 */
23
24
/**
25
 * @file
26
 * DV encoder
27
 */
28
29
#include "config.h"
30
31
#include "libavutil/attributes.h"
32
#include "libavutil/internal.h"
33
#include "libavutil/mem_internal.h"
34
#include "libavutil/opt.h"
35
#include "libavutil/pixdesc.h"
36
37
#include "avcodec.h"
38
#include "dv.h"
39
#include "dv_profile_internal.h"
40
#include "dv_tablegen.h"
41
#include "fdctdsp.h"
42
#include "internal.h"
43
#include "mathops.h"
44
#include "me_cmp.h"
45
#include "pixblockdsp.h"
46
#include "put_bits.h"
47
48
22
static av_cold int dvvideo_encode_init(AVCodecContext *avctx)
49
{
50
22
    DVVideoContext *s = avctx->priv_data;
51
    FDCTDSPContext fdsp;
52
    MECmpContext mecc;
53
    PixblockDSPContext pdsp;
54
    int ret;
55
56
22
    s->sys = av_dv_codec_profile2(avctx->width, avctx->height, avctx->pix_fmt, avctx->time_base);
57
22
    if (!s->sys) {
58
        av_log(avctx, AV_LOG_ERROR, "Found no DV profile for %ix%i %s video. "
59
                                    "Valid DV profiles are:\n",
60
               avctx->width, avctx->height, av_get_pix_fmt_name(avctx->pix_fmt));
61
        ff_dv_print_profiles(avctx, AV_LOG_ERROR);
62
        return AVERROR(EINVAL);
63
    }
64
65
22
    ret = ff_dv_init_dynamic_tables(s, s->sys);
66
22
    if (ret < 0) {
67
        av_log(avctx, AV_LOG_ERROR, "Error initializing work tables.\n");
68
        return ret;
69
    }
70
71
22
    dv_vlc_map_tableinit();
72
73
22
    memset(&fdsp,0, sizeof(fdsp));
74
22
    memset(&mecc,0, sizeof(mecc));
75
22
    memset(&pdsp,0, sizeof(pdsp));
76
22
    ff_fdctdsp_init(&fdsp, avctx);
77
22
    ff_me_cmp_init(&mecc, avctx);
78
22
    ff_pixblockdsp_init(&pdsp, avctx);
79
22
    ff_set_cmp(&mecc, mecc.ildct_cmp, avctx->ildct_cmp);
80
81
22
    s->get_pixels = pdsp.get_pixels;
82
22
    s->ildct_cmp  = mecc.ildct_cmp[5];
83
84
22
    s->fdct[0]    = fdsp.fdct;
85
22
    s->fdct[1]    = fdsp.fdct248;
86
87
22
    return ff_dvvideo_init(avctx);
88
}
89
90
/* bit budget for AC only in 5 MBs */
91
static const int vs_total_ac_bits_hd = (68 * 6 + 52*2) * 5;
92
static const int vs_total_ac_bits = (100 * 4 + 68 * 2) * 5;
93
static const int mb_area_start[5] = { 1, 6, 21, 43, 64 };
94
95
#if CONFIG_SMALL
96
/* Convert run and level (where level != 0) pair into VLC, returning bit size */
97
static av_always_inline int dv_rl2vlc(int run, int level, int sign,
98
                                      uint32_t *vlc)
99
{
100
    int size;
101
    if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {
102
        *vlc = dv_vlc_map[run][level].vlc | sign;
103
        size = dv_vlc_map[run][level].size;
104
    } else {
105
        if (level < DV_VLC_MAP_LEV_SIZE) {
106
            *vlc = dv_vlc_map[0][level].vlc | sign;
107
            size = dv_vlc_map[0][level].size;
108
        } else {
109
            *vlc = 0xfe00 | (level << 1) | sign;
110
            size = 16;
111
        }
112
        if (run) {
113
            *vlc |= ((run < 16) ? dv_vlc_map[run - 1][0].vlc :
114
                     (0x1f80 | (run - 1))) << size;
115
            size +=  (run < 16) ? dv_vlc_map[run - 1][0].size : 13;
116
        }
117
    }
118
119
    return size;
120
}
121
122
static av_always_inline int dv_rl2vlc_size(int run, int level)
123
{
124
    int size;
125
126
    if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {
127
        size = dv_vlc_map[run][level].size;
128
    } else {
129
        size = (level < DV_VLC_MAP_LEV_SIZE) ? dv_vlc_map[0][level].size : 16;
130
        if (run)
131
            size += (run < 16) ? dv_vlc_map[run - 1][0].size : 13;
132
    }
133
    return size;
134
}
135
#else
136
195207865
static av_always_inline int dv_rl2vlc(int run, int l, int sign, uint32_t *vlc)
137
{
138
195207865
    *vlc = dv_vlc_map[run][l].vlc | sign;
139
195207865
    return dv_vlc_map[run][l].size;
140
}
141
142
620150551
static av_always_inline int dv_rl2vlc_size(int run, int l)
143
{
144
620150551
    return dv_vlc_map[run][l].size;
145
}
146
#endif
147
148
typedef struct EncBlockInfo {
149
    int      area_q[4];
150
    int      bit_size[4];
151
    int      prev[5];
152
    int      cur_ac;
153
    int      cno;
154
    int      dct_mode;
155
    int16_t  mb[64];
156
    uint8_t  next[64];
157
    uint8_t  sign[64];
158
    uint8_t  partial_bit_count;
159
    uint32_t partial_bit_buffer; /* we can't use uint16_t here */
160
    /* used by DV100 only: a copy of the weighted and classified but
161
       not-yet-quantized AC coefficients. This is necessary for
162
       re-quantizing at different steps. */
163
    int16_t  save[64];
164
    int      min_qlevel; /* DV100 only: minimum qlevel (for AC coefficients >255) */
165
} EncBlockInfo;
166
167
32303914
static av_always_inline PutBitContext *dv_encode_ac(EncBlockInfo *bi,
168
                                                    PutBitContext *pb_pool,
169
                                                    PutBitContext *pb_end)
170
{
171
    int prev, bits_left;
172
32303914
    PutBitContext *pb = pb_pool;
173
32303914
    int size          = bi->partial_bit_count;
174
32303914
    uint32_t vlc      = bi->partial_bit_buffer;
175
176
32303914
    bi->partial_bit_count  =
177
32303914
    bi->partial_bit_buffer = 0;
178
    for (;;) {
179
        /* Find suitable storage space */
180
269372466
        for (; size > (bits_left = put_bits_left(pb)); pb++) {
181
31504601
            if (bits_left) {
182
13321407
                size -= bits_left;
183
13321407
                put_bits(pb, bits_left, vlc >> size);
184
13321407
                vlc = av_mod_uintp2(vlc, size);
185
            }
186
31504601
            if (pb + 1 >= pb_end) {
187
10973914
                bi->partial_bit_count  = size;
188
10973914
                bi->partial_bit_buffer = vlc;
189
10973914
                return pb;
190
            }
191
        }
192
193
        /* Store VLC */
194
237867865
        put_bits(pb, size, vlc);
195
196
237867865
        if (bi->cur_ac >= 64)
197
21330000
            break;
198
199
        /* Construct the next VLC */
200
216537865
        prev       = bi->cur_ac;
201
216537865
        bi->cur_ac = bi->next[prev];
202
216537865
        if (bi->cur_ac < 64) {
203
195207865
            size = dv_rl2vlc(bi->cur_ac - prev - 1, bi->mb[bi->cur_ac],
204
195207865
                             bi->sign[bi->cur_ac], &vlc);
205
        } else {
206
21330000
            size = 4;
207
21330000
            vlc  = 6; /* End Of Block stamp */
208
        }
209
    }
210
21330000
    return pb;
211
}
212
213
7362000
static av_always_inline int dv_guess_dct_mode(DVVideoContext *s, uint8_t *data,
214
                                              ptrdiff_t linesize)
215
{
216
7362000
    if (s->avctx->flags & AV_CODEC_FLAG_INTERLACED_DCT) {
217
        int ps = s->ildct_cmp(NULL, data, NULL, linesize, 8) - 400;
218
        if (ps > 0) {
219
            int is = s->ildct_cmp(NULL, data,            NULL, linesize * 2, 4) +
220
                     s->ildct_cmp(NULL, data + linesize, NULL, linesize * 2, 4);
221
            return ps > is;
222
        }
223
    }
224
225
7362000
    return 0;
226
}
227
228
static const int dv_weight_bits = 18;
229
static const int dv_weight_88[64] = {
230
    131072, 257107, 257107, 242189, 252167, 242189, 235923, 237536,
231
    237536, 235923, 229376, 231390, 223754, 231390, 229376, 222935,
232
    224969, 217965, 217965, 224969, 222935, 200636, 218652, 211916,
233
    212325, 211916, 218652, 200636, 188995, 196781, 205965, 206433,
234
    206433, 205965, 196781, 188995, 185364, 185364, 200636, 200704,
235
    200636, 185364, 185364, 174609, 180568, 195068, 195068, 180568,
236
    174609, 170091, 175557, 189591, 175557, 170091, 165371, 170627,
237
    170627, 165371, 160727, 153560, 160727, 144651, 144651, 136258,
238
};
239
static const int dv_weight_248[64] = {
240
    131072, 262144, 257107, 257107, 242189, 242189, 242189, 242189,
241
    237536, 237536, 229376, 229376, 200636, 200636, 224973, 224973,
242
    223754, 223754, 235923, 235923, 229376, 229376, 217965, 217965,
243
    211916, 211916, 196781, 196781, 185364, 185364, 206433, 206433,
244
    211916, 211916, 222935, 222935, 200636, 200636, 205964, 205964,
245
    200704, 200704, 180568, 180568, 175557, 175557, 195068, 195068,
246
    185364, 185364, 188995, 188995, 174606, 174606, 175557, 175557,
247
    170627, 170627, 153560, 153560, 165371, 165371, 144651, 144651,
248
};
249
250
/* setting this to 1 results in a faster codec but
251
 * somewhat lower image quality */
252
#define DV100_SACRIFICE_QUALITY_FOR_SPEED 1
253
#define DV100_ENABLE_FINER 1
254
255
/* pack combination of QNO and CNO into a single 8-bit value */
256
#define DV100_MAKE_QLEVEL(qno,cno) ((qno<<2) | (cno))
257
#define DV100_QLEVEL_QNO(qlevel) (qlevel>>2)
258
#define DV100_QLEVEL_CNO(qlevel) (qlevel&0x3)
259
260
#define DV100_NUM_QLEVELS 31
261
262
/* The quantization step is determined by a combination of QNO and
263
   CNO. We refer to these combinations as "qlevels" (this term is our
264
   own, it's not mentioned in the spec). We use CNO, a multiplier on
265
   the quantization step, to "fill in the gaps" between quantization
266
   steps associated with successive values of QNO. e.g. there is no
267
   QNO for a quantization step of 10, but we can use QNO=5 CNO=1 to
268
   get the same result. The table below encodes combinations of QNO
269
   and CNO in order of increasing quantization coarseness. */
270
static const uint8_t dv100_qlevels[DV100_NUM_QLEVELS] = {
271
    DV100_MAKE_QLEVEL( 1,0), //  1*1= 1
272
    DV100_MAKE_QLEVEL( 1,0), //  1*1= 1
273
    DV100_MAKE_QLEVEL( 2,0), //  2*1= 2
274
    DV100_MAKE_QLEVEL( 3,0), //  3*1= 3
275
    DV100_MAKE_QLEVEL( 4,0), //  4*1= 4
276
    DV100_MAKE_QLEVEL( 5,0), //  5*1= 5
277
    DV100_MAKE_QLEVEL( 6,0), //  6*1= 6
278
    DV100_MAKE_QLEVEL( 7,0), //  7*1= 7
279
    DV100_MAKE_QLEVEL( 8,0), //  8*1= 8
280
    DV100_MAKE_QLEVEL( 5,1), //  5*2=10
281
    DV100_MAKE_QLEVEL( 6,1), //  6*2=12
282
    DV100_MAKE_QLEVEL( 7,1), //  7*2=14
283
    DV100_MAKE_QLEVEL( 9,0), // 16*1=16
284
    DV100_MAKE_QLEVEL(10,0), // 18*1=18
285
    DV100_MAKE_QLEVEL(11,0), // 20*1=20
286
    DV100_MAKE_QLEVEL(12,0), // 22*1=22
287
    DV100_MAKE_QLEVEL(13,0), // 24*1=24
288
    DV100_MAKE_QLEVEL(14,0), // 28*1=28
289
    DV100_MAKE_QLEVEL( 9,1), // 16*2=32
290
    DV100_MAKE_QLEVEL(10,1), // 18*2=36
291
    DV100_MAKE_QLEVEL(11,1), // 20*2=40
292
    DV100_MAKE_QLEVEL(12,1), // 22*2=44
293
    DV100_MAKE_QLEVEL(13,1), // 24*2=48
294
    DV100_MAKE_QLEVEL(15,0), // 52*1=52
295
    DV100_MAKE_QLEVEL(14,1), // 28*2=56
296
    DV100_MAKE_QLEVEL( 9,2), // 16*4=64
297
    DV100_MAKE_QLEVEL(10,2), // 18*4=72
298
    DV100_MAKE_QLEVEL(11,2), // 20*4=80
299
    DV100_MAKE_QLEVEL(12,2), // 22*4=88
300
    DV100_MAKE_QLEVEL(13,2), // 24*4=96
301
    // ...
302
    DV100_MAKE_QLEVEL(15,3), // 52*8=416
303
};
304
305
static const int dv100_min_bias = 0;
306
static const int dv100_chroma_bias = 0;
307
static const int dv100_starting_qno = 1;
308
309
#if DV100_SACRIFICE_QUALITY_FOR_SPEED
310
static const int dv100_qlevel_inc = 4;
311
#else
312
static const int dv100_qlevel_inc = 1;
313
#endif
314
315
// 1/qstep, shifted up by 16 bits
316
static const int dv100_qstep_bits = 16;
317
static const int dv100_qstep_inv[16] = {
318
        65536,  65536,  32768,  21845,  16384,  13107,  10923,  9362,  8192,  4096,  3641,  3277,  2979,  2731,  2341,  1260,
319
};
320
321
/* DV100 weights are pre-zigzagged, inverted and multiplied by 2^(dv100_weight_shift)
322
   (in DV100 the AC components are divided by the spec weights) */
323
static const int dv100_weight_shift = 16;
324
static const int dv_weight_1080[2][64] = {
325
    { 8192, 65536, 65536, 61681, 61681, 61681, 58254, 58254,
326
      58254, 58254, 58254, 58254, 55188, 58254, 58254, 55188,
327
      55188, 55188, 55188, 55188, 55188, 24966, 27594, 26214,
328
      26214, 26214, 27594, 24966, 23831, 24385, 25575, 25575,
329
      25575, 25575, 24385, 23831, 23302, 23302, 24966, 24966,
330
      24966, 23302, 23302, 21845, 22795, 24385, 24385, 22795,
331
      21845, 21400, 21845, 23831, 21845, 21400, 10382, 10700,
332
      10700, 10382, 10082, 9620, 10082, 9039, 9039, 8525, },
333
    { 8192, 65536, 65536, 61681, 61681, 61681, 41943, 41943,
334
      41943, 41943, 40330, 41943, 40330, 41943, 40330, 40330,
335
      40330, 38836, 38836, 40330, 40330, 24966, 27594, 26214,
336
      26214, 26214, 27594, 24966, 23831, 24385, 25575, 25575,
337
      25575, 25575, 24385, 23831, 11523, 11523, 12483, 12483,
338
      12483, 11523, 11523, 10923, 11275, 12193, 12193, 11275,
339
      10923, 5323, 5490, 5924, 5490, 5323, 5165, 5323,
340
      5323, 5165, 5017, 4788, 5017, 4520, 4520, 4263, }
341
};
342
343
static const int dv_weight_720[2][64] = {
344
    { 8192, 65536, 65536, 61681, 61681, 61681, 58254, 58254,
345
      58254, 58254, 58254, 58254, 55188, 58254, 58254, 55188,
346
      55188, 55188, 55188, 55188, 55188, 24966, 27594, 26214,
347
      26214, 26214, 27594, 24966, 23831, 24385, 25575, 25575,
348
      25575, 25575, 24385, 23831, 15420, 15420, 16644, 16644,
349
      16644, 15420, 15420, 10923, 11398, 12193, 12193, 11398,
350
      10923, 10700, 10923, 11916, 10923, 10700, 5191, 5350,
351
      5350, 5191, 5041, 4810, 5041, 4520, 4520, 4263, },
352
    { 8192, 43691, 43691, 40330, 40330, 40330, 29127, 29127,
353
      29127, 29127, 29127, 29127, 27594, 29127, 29127, 27594,
354
      27594, 27594, 27594, 27594, 27594, 12483, 13797, 13107,
355
      13107, 13107, 13797, 12483, 11916, 12193, 12788, 12788,
356
      12788, 12788, 12193, 11916, 5761, 5761, 6242, 6242,
357
      6242, 5761, 5761, 5461, 5638, 5461, 6096, 5638,
358
      5461, 2661, 2745, 2962, 2745, 2661, 2583, 2661,
359
      2661, 2583, 2509, 2394, 2509, 2260, 2260, 2131, }
360
};
361
362
7290000
static av_always_inline int dv_set_class_number_sd(DVVideoContext *s,
363
                                                   int16_t *blk, EncBlockInfo *bi,
364
                                                   const uint8_t *zigzag_scan,
365
                                                   const int *weight, int bias)
366
{
367
    int i, area;
368
    /* We offer two different methods for class number assignment: the
369
     * method suggested in SMPTE 314M Table 22, and an improved
370
     * method. The SMPTE method is very conservative; it assigns class
371
     * 3 (i.e. severe quantization) to any block where the largest AC
372
     * component is greater than 36. FFmpeg's DV encoder tracks AC bit
373
     * consumption precisely, so there is no need to bias most blocks
374
     * towards strongly lossy compression. Instead, we assign class 2
375
     * to most blocks, and use class 3 only when strictly necessary
376
     * (for blocks whose largest AC component exceeds 255). */
377
378
#if 0 /* SMPTE spec method */
379
    static const int classes[] = { 12, 24, 36, 0xffff };
380
#else /* improved FFmpeg method */
381
    static const int classes[] = { -1, -1, 255, 0xffff };
382
#endif
383
7290000
    int max  = classes[0];
384
7290000
    int prev = 0;
385
7290000
    const unsigned deadzone = s->quant_deadzone;
386
7290000
    const unsigned threshold = 2 * deadzone;
387
388
7290000
    bi->mb[0] = blk[0];
389
390
36450000
    for (area = 0; area < 4; area++) {
391
29160000
        bi->prev[area]     = prev;
392
29160000
        bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
393
488430000
        for (i = mb_area_start[area]; i < mb_area_start[area + 1]; i++) {
394
459270000
            int level = blk[zigzag_scan[i]];
395
396
459270000
            if (level + deadzone > threshold) {
397
140566792
                bi->sign[i] = (level >> 31) & 1;
398
                /* Weight it and shift down into range, adding for rounding.
399
                 * The extra division by a factor of 2^4 reverses the 8x
400
                 * expansion of the DCT AND the 2x doubling of the weights. */
401
140566792
                level     = (FFABS(level) * weight[i] + (1 << (dv_weight_bits + 3))) >>
402
140566792
                            (dv_weight_bits + 4);
403
140566792
                if (!level)
404
16556689
                    continue;
405
124010103
                bi->mb[i] = level;
406
124010103
                if (level > max)
407
10763673
                    max = level;
408
124010103
                bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, level);
409
124010103
                bi->next[prev]      = i;
410
124010103
                prev                = i;
411
            }
412
        }
413
    }
414
7290000
    bi->next[prev] = i;
415
19585219
    for (bi->cno = 0; max > classes[bi->cno]; bi->cno++)
416
        ;
417
418
7290000
    bi->cno += bias;
419
420
7290000
    if (bi->cno >= 3) {
421
2431630
        bi->cno = 3;
422
2431630
        prev    = 0;
423
2431630
        i       = bi->next[prev];
424
12158150
        for (area = 0; area < 4; area++) {
425
9726520
            bi->prev[area]     = prev;
426
9726520
            bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
427
52713966
            for (; i < mb_area_start[area + 1]; i = bi->next[i]) {
428
42987446
                bi->mb[i] >>= 1;
429
430
42987446
                if (bi->mb[i]) {
431
25006098
                    bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, bi->mb[i]);
432
25006098
                    bi->next[prev]      = i;
433
25006098
                    prev                = i;
434
                }
435
            }
436
        }
437
2431630
        bi->next[prev] = i;
438
    }
439
440
7290000
    return bi->bit_size[0] + bi->bit_size[1] +
441
7290000
           bi->bit_size[2] + bi->bit_size[3];
442
}
443
444
/* this function just copies the DCT coefficients and performs
445
   the initial (non-)quantization. */
446
14040000
static inline void dv_set_class_number_hd(DVVideoContext *s,
447
                                          int16_t *blk, EncBlockInfo *bi,
448
                                          const uint8_t *zigzag_scan,
449
                                          const int *weight, int bias)
450
{
451
14040000
    int i, max = 0;
452
453
    /* the first quantization (none at all) */
454
14040000
    bi->area_q[0] = 1;
455
456
    /* weigh AC components and store to save[] */
457
    /* (i=0 is the DC component; we only include it to make the
458
       number of loop iterations even, for future possible SIMD optimization) */
459
463320000
    for (i = 0; i < 64; i += 2) {
460
        int level0, level1;
461
462
        /* get the AC component (in zig-zag order) */
463
449280000
        level0 = blk[zigzag_scan[i+0]];
464
449280000
        level1 = blk[zigzag_scan[i+1]];
465
466
        /* extract sign and make it the lowest bit */
467
449280000
        bi->sign[i+0] = (level0>>31)&1;
468
449280000
        bi->sign[i+1] = (level1>>31)&1;
469
470
        /* take absolute value of the level */
471
449280000
        level0 = FFABS(level0);
472
449280000
        level1 = FFABS(level1);
473
474
        /* weigh it */
475
449280000
        level0 = (level0*weight[i+0] + 4096 + (1<<17)) >> 18;
476
449280000
        level1 = (level1*weight[i+1] + 4096 + (1<<17)) >> 18;
477
478
        /* save unquantized value */
479
449280000
        bi->save[i+0] = level0;
480
449280000
        bi->save[i+1] = level1;
481
482
         /* find max component */
483
449280000
        if (bi->save[i+0] > max)
484
14666809
            max = bi->save[i+0];
485
449280000
        if (bi->save[i+1] > max)
486
752557
            max = bi->save[i+1];
487
    }
488
489
    /* copy DC component */
490
14040000
    bi->mb[0] = blk[0];
491
492
    /* the EOB code is 4 bits */
493
14040000
    bi->bit_size[0] = 4;
494
14040000
    bi->bit_size[1] = bi->bit_size[2] = bi->bit_size[3] = 0;
495
496
    /* ensure that no AC coefficients are cut off */
497
14040000
    bi->min_qlevel = ((max+256) >> 8);
498
499
14040000
    bi->area_q[0] = 25; /* set to an "impossible" value */
500
14040000
    bi->cno = 0;
501
14040000
}
502
503
21330000
static av_always_inline int dv_init_enc_block(EncBlockInfo* bi, uint8_t *data, int linesize,
504
                                              DVVideoContext *s, int chroma)
505
{
506
21330000
    LOCAL_ALIGNED_16(int16_t, blk, [64]);
507
508
21330000
    bi->area_q[0] = bi->area_q[1] = bi->area_q[2] = bi->area_q[3] = 0;
509
21330000
    bi->partial_bit_count = 0;
510
21330000
    bi->partial_bit_buffer = 0;
511
21330000
    bi->cur_ac = 0;
512
513
21330000
    if (data) {
514
20196000
        if (DV_PROFILE_IS_HD(s->sys)) {
515
14040000
            s->get_pixels(blk, data, linesize * (1 << bi->dct_mode));
516
14040000
            s->fdct[0](blk);
517
        } else {
518
6156000
            bi->dct_mode = dv_guess_dct_mode(s, data, linesize);
519
6156000
            s->get_pixels(blk, data, linesize);
520
6156000
            s->fdct[bi->dct_mode](blk);
521
        }
522
    } else {
523
        /* We rely on the fact that encoding all zeros leads to an immediate EOB,
524
           which is precisely what the spec calls for in the "dummy" blocks. */
525
1134000
        memset(blk, 0, 64*sizeof(*blk));
526
1134000
        bi->dct_mode = 0;
527
    }
528
529
21330000
    if (DV_PROFILE_IS_HD(s->sys)) {
530
        const int *weights;
531
14040000
        if (s->sys->height == 1080) {
532
9720000
            weights = dv_weight_1080[chroma];
533
        } else { /* 720p */
534
4320000
            weights = dv_weight_720[chroma];
535
        }
536
14040000
        dv_set_class_number_hd(s, blk, bi,
537
                               ff_zigzag_direct,
538
                               weights,
539
14040000
                               dv100_min_bias+chroma*dv100_chroma_bias);
540
    } else {
541
14580000
        dv_set_class_number_sd(s, blk, bi,
542
7290000
                               bi->dct_mode ? ff_dv_zigzag248_direct : ff_zigzag_direct,
543
7290000
                               bi->dct_mode ? dv_weight_248 : dv_weight_88,
544
                               chroma);
545
    }
546
547
21330000
    return bi->bit_size[0] + bi->bit_size[1] + bi->bit_size[2] + bi->bit_size[3];
548
}
549
550
/* DV100 quantize
551
   Perform quantization by divinding the AC component by the qstep.
552
   As an optimization we use a fixed-point integer multiply instead
553
   of a divide. */
554
1903366584
static av_always_inline int dv100_quantize(int level, int qsinv)
555
{
556
    /* this code is equivalent to */
557
    /* return (level + qs/2) / qs; */
558
559
1903366584
    return (level * qsinv + 1024 + (1<<(dv100_qstep_bits-1))) >> dv100_qstep_bits;
560
561
    /* the extra +1024 is needed to make the rounding come out right. */
562
563
    /* I (DJM) have verified that the results are exactly the same as
564
       division for level 0-2048 at all QNOs. */
565
}
566
567
44252168
static int dv100_actual_quantize(EncBlockInfo *b, int qlevel)
568
{
569
    int prev, k, qsinv;
570
571
44252168
    int qno = DV100_QLEVEL_QNO(dv100_qlevels[qlevel]);
572
44252168
    int cno = DV100_QLEVEL_CNO(dv100_qlevels[qlevel]);
573
574

44252168
    if (b->area_q[0] == qno && b->cno == cno)
575
14040000
        return b->bit_size[0];
576
577
30212168
    qsinv = dv100_qstep_inv[qno];
578
579
    /* record the new qstep */
580
30212168
    b->area_q[0] = qno;
581
30212168
    b->cno = cno;
582
583
    /* reset encoded size (EOB = 4 bits) */
584
30212168
    b->bit_size[0] = 4;
585
586
    /* visit nonzero components and quantize */
587
30212168
    prev = 0;
588
1933578752
    for (k = 1; k < 64; k++) {
589
        /* quantize */
590
1903366584
        int ac = dv100_quantize(b->save[k], qsinv) >> cno;
591
1903366584
        if (ac) {
592
431284010
            if (ac > 255)
593
770
                ac = 255;
594
431284010
            b->mb[k] = ac;
595
431284010
            b->bit_size[0] += dv_rl2vlc_size(k - prev - 1, ac);
596
431284010
            b->next[prev] = k;
597
431284010
            prev = k;
598
        }
599
    }
600
30212168
    b->next[prev] = k;
601
602
30212168
    return b->bit_size[0];
603
}
604
605
351000
static inline void dv_guess_qnos_hd(EncBlockInfo *blks, int *qnos)
606
{
607
    EncBlockInfo *b;
608
    int min_qlevel[5];
609
    int qlevels[5];
610
    int size[5];
611
    int i, j;
612
    /* cache block sizes at hypothetical qlevels */
613
351000
    uint16_t size_cache[5*8][DV100_NUM_QLEVELS] = {{0}};
614
615
    /* get minimum qlevels */
616
2106000
    for (i = 0; i < 5; i++) {
617
1755000
        min_qlevel[i] = 1;
618
15795000
        for (j = 0; j < 8; j++) {
619
14040000
            if (blks[8*i+j].min_qlevel > min_qlevel[i])
620
1834839
                min_qlevel[i] = blks[8*i+j].min_qlevel;
621
        }
622
    }
623
624
    /* initialize sizes */
625
2106000
    for (i = 0; i < 5; i++) {
626
1755000
        qlevels[i] = dv100_starting_qno;
627
1755000
        if (qlevels[i] < min_qlevel[i])
628
1724635
            qlevels[i] = min_qlevel[i];
629
630
1755000
        qnos[i] = DV100_QLEVEL_QNO(dv100_qlevels[qlevels[i]]);
631
1755000
        size[i] = 0;
632
15795000
        for (j = 0; j < 8; j++) {
633
14040000
            size_cache[8*i+j][qlevels[i]] = dv100_actual_quantize(&blks[8*i+j], qlevels[i]);
634
14040000
            size[i] += size_cache[8*i+j][qlevels[i]];
635
        }
636
    }
637
638
    /* must we go coarser? */
639
351000
    if (size[0]+size[1]+size[2]+size[3]+size[4] > vs_total_ac_bits_hd) {
640
264654
        int largest = size[0] % 5; /* 'random' number */
641
264654
        int qlevels_done = 0;
642
643
        do {
644
            /* find the macroblock with the lowest qlevel */
645
12129126
            for (i = 0; i < 5; i++) {
646
10107605
                if (qlevels[i] < qlevels[largest])
647
321513
                    largest = i;
648
            }
649
650
2021521
            i = largest;
651
            /* ensure that we don't enter infinite loop */
652
2021521
            largest = (largest+1) % 5;
653
654
            /* quantize a little bit more */
655
2021521
            qlevels[i] += dv100_qlevel_inc;
656
2021521
            if (qlevels[i] > DV100_NUM_QLEVELS-1) {
657
                qlevels[i] = DV100_NUM_QLEVELS-1;
658
                qlevels_done++;
659
            }
660
661
2021521
            qnos[i] = DV100_QLEVEL_QNO(dv100_qlevels[qlevels[i]]);
662
2021521
            size[i] = 0;
663
664
            /* for each block */
665
2021521
            b = &blks[8*i];
666
18193689
            for (j = 0; j < 8; j++, b++) {
667
                /* accumulate block size into macroblock */
668
16172168
                if(size_cache[8*i+j][qlevels[i]] == 0) {
669
                    /* it is safe to use actual_quantize() here because we only go from finer to coarser,
670
                       and it saves the final actual_quantize() down below */
671
16172168
                    size_cache[8*i+j][qlevels[i]] = dv100_actual_quantize(b, qlevels[i]);
672
                }
673
16172168
                size[i] += size_cache[8*i+j][qlevels[i]];
674
            } /* for each block */
675
676

2021521
        } while (vs_total_ac_bits_hd < size[0] + size[1] + size[2] + size[3] + size[4] && qlevels_done < 5);
677
678
        // can we go finer?
679
86346
    } else if (DV100_ENABLE_FINER &&
680
86346
               size[0]+size[1]+size[2]+size[3]+size[4] < vs_total_ac_bits_hd) {
681
        int save_qlevel;
682
86340
        int largest = size[0] % 5; /* 'random' number */
683
684
86340
        while (qlevels[0] > min_qlevel[0] ||
685
86340
               qlevels[1] > min_qlevel[1] ||
686
86340
               qlevels[2] > min_qlevel[2] ||
687
86340
               qlevels[3] > min_qlevel[3] ||
688
86340
               qlevels[4] > min_qlevel[4]) {
689
690
            /* find the macroblock with the highest qlevel */
691
            for (i = 0; i < 5; i++) {
692
                if (qlevels[i] > min_qlevel[i] && qlevels[i] > qlevels[largest])
693
                    largest = i;
694
            }
695
696
            i = largest;
697
698
            /* ensure that we don't enter infinite loop */
699
            largest = (largest+1) % 5;
700
701
            if (qlevels[i] <= min_qlevel[i]) {
702
                /* can't unquantize any more */
703
                continue;
704
            }
705
            /* quantize a little bit less */
706
            save_qlevel = qlevels[i];
707
            qlevels[i] -= dv100_qlevel_inc;
708
            if (qlevels[i] < min_qlevel[i])
709
                qlevels[i] = min_qlevel[i];
710
711
            qnos[i] = DV100_QLEVEL_QNO(dv100_qlevels[qlevels[i]]);
712
713
            size[i] = 0;
714
715
            /* for each block */
716
            b = &blks[8*i];
717
            for (j = 0; j < 8; j++, b++) {
718
                /* accumulate block size into macroblock */
719
                if(size_cache[8*i+j][qlevels[i]] == 0) {
720
                    size_cache[8*i+j][qlevels[i]] = dv100_actual_quantize(b, qlevels[i]);
721
                }
722
                size[i] += size_cache[8*i+j][qlevels[i]];
723
            } /* for each block */
724
725
            /* did we bust the limit? */
726
            if (vs_total_ac_bits_hd < size[0] + size[1] + size[2] + size[3] + size[4]) {
727
                /* go back down and exit */
728
                qlevels[i] = save_qlevel;
729
                qnos[i] = DV100_QLEVEL_QNO(dv100_qlevels[qlevels[i]]);
730
                break;
731
            }
732
        }
733
    }
734
735
    /* now do the actual quantization */
736
2106000
    for (i = 0; i < 5; i++) {
737
        /* for each block */
738
1755000
        b = &blks[8*i];
739
1755000
        size[i] = 0;
740
15795000
        for (j = 0; j < 8; j++, b++) {
741
            /* accumulate block size into macroblock */
742
14040000
            size[i] += dv100_actual_quantize(b, qlevels[i]);
743
        } /* for each block */
744
    }
745
351000
}
746
747
134212
static inline void dv_guess_qnos(EncBlockInfo *blks, int *qnos)
748
{
749
    int size[5];
750
    int i, j, k, a, prev, a2;
751
    EncBlockInfo *b;
752
753
134212
    size[0] =
754
134212
    size[1] =
755
134212
    size[2] =
756
134212
    size[3] =
757
134212
    size[4] = 1 << 24;
758
    do {
759
664729
        b = blks;
760
3589287
        for (i = 0; i < 5; i++) {
761
3058770
            if (!qnos[i])
762
                continue;
763
764
3058770
            qnos[i]--;
765
3058770
            size[i] = 0;
766
21411390
            for (j = 0; j < 6; j++, b++) {
767
91763100
                for (a = 0; a < 4; a++) {
768
73410480
                    if (b->area_q[a] != ff_dv_quant_shifts[qnos[i] + ff_dv_quant_offset[b->cno]][a]) {
769
14357792
                        b->bit_size[a] = 1; // 4 areas 4 bits for EOB :)
770
14357792
                        b->area_q[a]++;
771
14357792
                        prev = b->prev[a];
772
                        av_assert2(b->next[prev] >= mb_area_start[a + 1] || b->mb[prev]);
773
75596456
                        for (k = b->next[prev]; k < mb_area_start[a + 1]; k = b->next[k]) {
774
61238664
                            b->mb[k] >>= 1;
775
61238664
                            if (b->mb[k]) {
776
37590212
                                b->bit_size[a] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
777
37590212
                                prev            = k;
778
                            } else {
779

23648452
                                if (b->next[k] >= mb_area_start[a + 1] && b->next[k] < 64) {
780
1130140
                                    for (a2 = a + 1; b->next[k] >= mb_area_start[a2 + 1]; a2++)
781
76
                                        b->prev[a2] = prev;
782
                                    av_assert2(a2 < 4);
783
                                    av_assert2(b->mb[b->next[k]]);
784
1130064
                                    b->bit_size[a2] += dv_rl2vlc_size(b->next[k] - prev - 1, b->mb[b->next[k]]) -
785
1130064
                                                       dv_rl2vlc_size(b->next[k] - k    - 1, b->mb[b->next[k]]);
786
                                    av_assert2(b->prev[a2] == k && (a2 + 1 >= 4 || b->prev[a2 + 1] != k));
787
1130064
                                    b->prev[a2] = prev;
788
                                }
789
23648452
                                b->next[prev] = b->next[k];
790
                            }
791
                        }
792
14357792
                        b->prev[a + 1] = prev;
793
                    }
794
73410480
                    size[i] += b->bit_size[a];
795
                }
796
            }
797
3058770
            if (vs_total_ac_bits >= size[0] + size[1] + size[2] + size[3] + size[4])
798
134212
                return;
799
        }
800
530517
    } while (qnos[0] | qnos[1] | qnos[2] | qnos[3] | qnos[4]);
801
802
    for (a = 2; a == 2 || vs_total_ac_bits < size[0]; a += a) {
803
        b       = blks;
804
        size[0] = 5 * 6 * 4; // EOB
805
        for (j = 0; j < 6 * 5; j++, b++) {
806
            prev = b->prev[0];
807
            for (k = b->next[prev]; k < 64; k = b->next[k]) {
808
                if (b->mb[k] < a && b->mb[k] > -a) {
809
                    b->next[prev] = b->next[k];
810
                } else {
811
                    size[0] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
812
                    prev     = k;
813
                }
814
            }
815
        }
816
    }
817
}
818
819
/* update all cno values into the blocks, over-writing the old values without
820
   touching anything else. (only used for DV100) */
821
351000
static inline void dv_revise_cnos(uint8_t *dif, EncBlockInfo *blk, const AVDVProfile *profile)
822
{
823
    uint8_t *data;
824
    int mb_index, i;
825
826
2106000
    for (mb_index = 0; mb_index < 5; mb_index++) {
827
1755000
        data = dif + mb_index*80 + 4;
828
15795000
        for (i = 0; i < profile->bpm; i++) {
829
            /* zero out the class number */
830
14040000
            data[1] &= 0xCF;
831
            /* add the new one */
832
14040000
            data[1] |= blk[profile->bpm*mb_index+i].cno << 4;
833
834
14040000
            data += profile->block_sizes[i] >> 3;
835
        }
836
    }
837
351000
}
838
839
594000
static int dv_encode_video_segment(AVCodecContext *avctx, void *arg)
840
{
841
594000
    DVVideoContext *s = avctx->priv_data;
842
594000
    DVwork_chunk *work_chunk = arg;
843
    int mb_index, i, j;
844
    int mb_x, mb_y, c_offset;
845
    ptrdiff_t linesize, y_stride;
846
    uint8_t *y_ptr;
847
    uint8_t *dif, *p;
848
594000
    LOCAL_ALIGNED_8(uint8_t, scratch, [128]);
849
    EncBlockInfo enc_blks[5 * DV_MAX_BPM];
850
    PutBitContext pbs[5 * DV_MAX_BPM];
851
    PutBitContext *pb;
852
    EncBlockInfo *enc_blk;
853
594000
    int vs_bit_size = 0;
854
    int qnos[5];
855
594000
    int *qnosp = &qnos[0];
856
857
594000
    p = dif = &s->buf[work_chunk->buf_offset * 80];
858
594000
    enc_blk = &enc_blks[0];
859
3564000
    for (mb_index = 0; mb_index < 5; mb_index++) {
860
2970000
        dv_calculate_mb_xy(s, work_chunk, mb_index, &mb_x, &mb_y);
861
862
2970000
        qnos[mb_index] = DV_PROFILE_IS_HD(s->sys) ? 1 : 15;
863
864
2970000
        y_ptr    = s->frame->data[0] + (mb_y * s->frame->linesize[0] + mb_x) * 8;
865
2970000
        linesize = s->frame->linesize[0];
866
867

2970000
        if (s->sys->height == 1080 && mb_y < 134)
868
1206000
            enc_blk->dct_mode = dv_guess_dct_mode(s, y_ptr, linesize);
869
        else
870
1764000
            enc_blk->dct_mode = 0;
871
23760000
        for (i = 1; i < 8; i++)
872
20790000
            enc_blk[i].dct_mode = enc_blk->dct_mode;
873
874
        /* initializing luminance blocks */
875
2970000
        if ((s->sys->pix_fmt == AV_PIX_FMT_YUV420P)                      ||
876

2605500
            (s->sys->pix_fmt == AV_PIX_FMT_YUV411P && mb_x >= (704 / 8)) ||
877

2599200
            (s->sys->height >= 720 && mb_y != 134)) {
878
2116800
            y_stride = s->frame->linesize[0] * (1 << (3*!enc_blk->dct_mode));
879
        } else {
880
853200
            y_stride = 16;
881
        }
882
2970000
        y_ptr    = s->frame->data[0] +
883
2970000
                   (mb_y * s->frame->linesize[0] + mb_x) * 8;
884
2970000
        linesize = s->frame->linesize[0];
885
886
2970000
        if (s->sys->video_stype == 4) { /* SD 422 */
887
567000
            vs_bit_size +=
888
567000
                dv_init_enc_block(enc_blk + 0, y_ptr,                linesize, s, 0) +
889
567000
                dv_init_enc_block(enc_blk + 1, NULL,                 linesize, s, 0) +
890
1134000
                dv_init_enc_block(enc_blk + 2, y_ptr + 8,            linesize, s, 0) +
891
567000
                dv_init_enc_block(enc_blk + 3, NULL,                 linesize, s, 0);
892
        } else {
893
2403000
            vs_bit_size +=
894
2403000
                dv_init_enc_block(enc_blk + 0, y_ptr,                linesize, s, 0) +
895
2403000
                dv_init_enc_block(enc_blk + 1, y_ptr + 8,            linesize, s, 0) +
896
4806000
                dv_init_enc_block(enc_blk + 2, y_ptr +     y_stride, linesize, s, 0) +
897
2403000
                dv_init_enc_block(enc_blk + 3, y_ptr + 8 + y_stride, linesize, s, 0);
898
        }
899
2970000
        enc_blk += 4;
900
901
        /* initializing chrominance blocks */
902
5940000
        c_offset = ((mb_y >>  (s->sys->pix_fmt == AV_PIX_FMT_YUV420P)) * s->frame->linesize[1] +
903
2970000
                    (mb_x >> ((s->sys->pix_fmt == AV_PIX_FMT_YUV411P) ? 2 : 1))) * 8;
904
8910000
        for (j = 2; j; j--) {
905
5940000
            uint8_t *c_ptr = s->frame->data[j] + c_offset;
906
5940000
            linesize = s->frame->linesize[j];
907

5940000
            y_stride = (mb_y == 134) ? 8 : (s->frame->linesize[j] * (1 << (3*!enc_blk->dct_mode)));
908

5940000
            if (s->sys->pix_fmt == AV_PIX_FMT_YUV411P && mb_x >= (704 / 8)) {
909
                uint8_t *d;
910
12600
                uint8_t *b = scratch;
911
113400
                for (i = 0; i < 8; i++) {
912
100800
                    d      = c_ptr + linesize * 8;
913
100800
                    b[0]   = c_ptr[0];
914
100800
                    b[1]   = c_ptr[1];
915
100800
                    b[2]   = c_ptr[2];
916
100800
                    b[3]   = c_ptr[3];
917
100800
                    b[4]   = d[0];
918
100800
                    b[5]   = d[1];
919
100800
                    b[6]   = d[2];
920
100800
                    b[7]   = d[3];
921
100800
                    c_ptr += linesize;
922
100800
                    b     += 16;
923
                }
924
12600
                c_ptr    = scratch;
925
12600
                linesize = 16;
926
            }
927
928
5940000
            vs_bit_size += dv_init_enc_block(enc_blk++, c_ptr, linesize, s, 1);
929
5940000
            if (s->sys->bpm == 8)
930
3510000
                vs_bit_size += dv_init_enc_block(enc_blk++, c_ptr + y_stride,
931
                                                 linesize, s, 1);
932
        }
933
    }
934
935
594000
    if (DV_PROFILE_IS_HD(s->sys)) {
936
        /* unconditional */
937
351000
        dv_guess_qnos_hd(&enc_blks[0], qnosp);
938
243000
    } else if (vs_total_ac_bits < vs_bit_size) {
939
134212
        dv_guess_qnos(&enc_blks[0], qnosp);
940
    }
941
942
    /* DIF encoding process */
943
3564000
    for (j = 0; j < 5 * s->sys->bpm;) {
944
2970000
        int start_mb = j;
945
946
2970000
        p[3] = *qnosp++;
947
2970000
        p += 4;
948
949
        /* First pass over individual cells only */
950
24300000
        for (i = 0; i < s->sys->bpm; i++, j++) {
951
21330000
            int sz = s->sys->block_sizes[i] >> 3;
952
953
21330000
            init_put_bits(&pbs[j], p, sz);
954
21330000
            put_sbits(&pbs[j], 9, ((enc_blks[j].mb[0] >> 3) - 1024 + 2) >> 2);
955

21330000
            put_bits(&pbs[j], 1, DV_PROFILE_IS_HD(s->sys) && i ? 1 : enc_blks[j].dct_mode);
956
21330000
            put_bits(&pbs[j], 2, enc_blks[j].cno);
957
958
21330000
            dv_encode_ac(&enc_blks[j], &pbs[j], &pbs[j + 1]);
959
21330000
            p += sz;
960
        }
961
962
        /* Second pass over each MB space */
963
2970000
        pb = &pbs[start_mb];
964
24300000
        for (i = 0; i < s->sys->bpm; i++)
965
21330000
            if (enc_blks[start_mb + i].partial_bit_count)
966
7190425
                pb = dv_encode_ac(&enc_blks[start_mb + i], pb,
967
7190425
                                  &pbs[start_mb + s->sys->bpm]);
968
    }
969
970
    /* Third and final pass over the whole video segment space */
971
594000
    pb = &pbs[0];
972
21924000
    for (j = 0; j < 5 * s->sys->bpm; j++) {
973
21330000
        if (enc_blks[j].partial_bit_count)
974
3783489
            pb = dv_encode_ac(&enc_blks[j], pb, &pbs[s->sys->bpm * 5]);
975
21330000
        if (enc_blks[j].partial_bit_count)
976
            av_log(avctx, AV_LOG_ERROR, "ac bitstream overflow\n");
977
    }
978
979
21924000
    for (j = 0; j < 5 * s->sys->bpm; j++) {
980
        int pos;
981
21330000
        int size = pbs[j].size_in_bits >> 3;
982
21330000
        flush_put_bits(&pbs[j]);
983
21330000
        pos = put_bits_count(&pbs[j]) >> 3;
984
21330000
        if (pos > size) {
985
            av_log(avctx, AV_LOG_ERROR,
986
                   "bitstream written beyond buffer size\n");
987
            return -1;
988
        }
989
21330000
        memset(pbs[j].buf + pos, 0xff, size - pos);
990
    }
991
992
594000
    if (DV_PROFILE_IS_HD(s->sys))
993
351000
        dv_revise_cnos(dif, enc_blks, s->sys);
994
995
594000
    return 0;
996
}
997
998
304200
static inline int dv_write_pack(enum dv_pack_type pack_id, DVVideoContext *c,
999
                                uint8_t *buf)
1000
{
1001
    /*
1002
     * Here's what SMPTE314M says about these two:
1003
     *    (page 6) APTn, AP1n, AP2n, AP3n: These data shall be identical
1004
     *             as track application IDs (APTn = 001, AP1n =
1005
     *             001, AP2n = 001, AP3n = 001), if the source signal
1006
     *             comes from a digital VCR. If the signal source is
1007
     *             unknown, all bits for these data shall be set to 1.
1008
     *    (page 12) STYPE: STYPE defines a signal type of video signal
1009
     *                     00000b = 4:1:1 compression
1010
     *                     00100b = 4:2:2 compression
1011
     *                     XXXXXX = Reserved
1012
     * Now, I've got two problems with these statements:
1013
     *   1. it looks like APT == 111b should be a safe bet, but it isn't.
1014
     *      It seems that for PAL as defined in IEC 61834 we have to set
1015
     *      APT to 000 and for SMPTE314M to 001.
1016
     *   2. It is not at all clear what STYPE is used for 4:2:0 PAL
1017
     *      compression scheme (if any).
1018
     */
1019
304200
    uint8_t aspect = 0;
1020
304200
    int apt = (c->sys->pix_fmt == AV_PIX_FMT_YUV420P ? 0 : 1);
1021
    int fs;
1022
1023
304200
    if (c->avctx->height >= 720)
1024

187200
        fs = c->avctx->height == 720 || c->frame->top_field_first ? 0x40 : 0x00;
1025
    else
1026
117000
        fs = c->frame->top_field_first ? 0x00 : 0x40;
1027
1028
304200
    if (DV_PROFILE_IS_HD(c->sys) ||
1029
117000
        (int)(av_q2d(c->avctx->sample_aspect_ratio) *
1030
117000
              c->avctx->width / c->avctx->height * 10) >= 17)
1031
        /* HD formats are always 16:9 */
1032
195000
        aspect = 0x02;
1033
1034
304200
    buf[0] = (uint8_t) pack_id;
1035

304200
    switch (pack_id) {
1036
23400
    case dv_header525: /* I can't imagine why these two weren't defined as real */
1037
    case dv_header625: /* packs in SMPTE314M -- they definitely look like ones */
1038
23400
        buf[1] =  0xf8       | /* reserved -- always 1 */
1039
                 (apt & 0x07); /* APT: Track application ID */
1040
23400
        buf[2] = (0    << 7) | /* TF1: audio data is 0 - valid; 1 - invalid */
1041
23400
                 (0x0f << 3) | /* reserved -- always 1 */
1042
23400
                 (apt & 0x07); /* AP1: Audio application ID */
1043
23400
        buf[3] = (0    << 7) | /* TF2: video data is 0 - valid; 1 - invalid */
1044
23400
                 (0x0f << 3) | /* reserved -- always 1 */
1045
23400
                 (apt & 0x07); /* AP2: Video application ID */
1046
23400
        buf[4] = (0    << 7) | /* TF3: subcode(SSYB) is 0 - valid; 1 - invalid */
1047
23400
                 (0x0f << 3) | /* reserved -- always 1 */
1048
23400
                 (apt & 0x07); /* AP3: Subcode application ID */
1049
23400
        break;
1050
140400
    case dv_video_source:
1051
140400
        buf[1] = 0xff;         /* reserved -- always 1 */
1052
140400
        buf[2] = (1 << 7) |    /* B/W: 0 - b/w, 1 - color */
1053
                 (1 << 6) |    /* following CLF is valid - 0, invalid - 1 */
1054
                 (3 << 4) |    /* CLF: color frames ID (see ITU-R BT.470-4) */
1055
                 0xf;          /* reserved -- always 1 */
1056
140400
        buf[3] = (3 << 6)           | /* reserved -- always 1 */
1057
140400
                 (c->sys->dsf << 5) | /*  system: 60fields/50fields */
1058
140400
                 c->sys->video_stype; /* signal type video compression */
1059
140400
        buf[4] = 0xff;         /* VISC: 0xff -- no information */
1060
140400
        break;
1061
140400
    case dv_video_control:
1062
140400
        buf[1] = (0 << 6) |    /* Copy generation management (CGMS) 0 -- free */
1063
                 0x3f;         /* reserved -- always 1 */
1064
140400
        buf[2] = 0xc8 |        /* reserved -- always b11001xxx */
1065
                 aspect;
1066
140400
        buf[3] = (1 << 7) |    /* frame/field flag 1 -- frame, 0 -- field */
1067
                 fs       |    /* first/second field flag 0 -- field 2, 1 -- field 1 */
1068
                 (1 << 5) |    /* frame change flag 0 -- same picture as before, 1 -- different */
1069
140400
                 (1 << 4) |    /* 1 - interlaced, 0 - noninterlaced */
1070
                 0xc;          /* reserved -- always b1100 */
1071
140400
        buf[4] = 0xff;         /* reserved -- always 1 */
1072
140400
        break;
1073
    default:
1074
        buf[1] =
1075
        buf[2] =
1076
        buf[3] =
1077
        buf[4] = 0xff;
1078
    }
1079
304200
    return 5;
1080
}
1081
1082
3510000
static inline int dv_write_dif_id(enum dv_section_type t, uint8_t chan_num,
1083
                                  uint8_t seq_num, uint8_t dif_num,
1084
                                  uint8_t *buf)
1085
{
1086
3510000
    int fsc = chan_num & 1;
1087
3510000
    int fsp = 1 - (chan_num >> 1);
1088
1089
3510000
    buf[0] = (uint8_t) t;      /* Section type */
1090
3510000
    buf[1] = (seq_num  << 4) | /* DIF seq number 0-9 for 525/60; 0-11 for 625/50 */
1091
3510000
             (fsc << 3) |      /* FSC: for 50 and 100Mb/s 0 - first channel; 1 - second */
1092
3510000
             (fsp << 2) |      /* FSP: for 100Mb/s 1 - channels 0-1; 0 - channels 2-3 */
1093
             3;                /* reserved -- always 1 */
1094
3510000
    buf[2] = dif_num;          /* DIF block number Video: 0-134, Audio: 0-8 */
1095
3510000
    return 3;
1096
}
1097
1098
280800
static inline int dv_write_ssyb_id(uint8_t syb_num, uint8_t fr, uint8_t *buf)
1099
{
1100

280800
    if (syb_num == 0 || syb_num == 6) {
1101
46800
        buf[0] = (fr << 7) | /* FR ID 1 - first half of each channel; 0 - second */
1102
46800
                 (0  << 4) | /* AP3 (Subcode application ID) */
1103
                 0x0f;       /* reserved -- always 1 */
1104
234000
    } else if (syb_num == 11) {
1105
        buf[0] = (fr << 7) | /* FR ID 1 - first half of each channel; 0 - second */
1106
                 0x7f;       /* reserved -- always 1 */
1107
    } else {
1108
234000
        buf[0] = (fr << 7) | /* FR ID 1 - first half of each channel; 0 - second */
1109
234000
                 (0  << 4) | /* APT (Track application ID) */
1110
                 0x0f;       /* reserved -- always 1 */
1111
    }
1112
280800
    buf[1] = 0xf0 |            /* reserved -- always 1 */
1113
             (syb_num & 0x0f); /* SSYB number 0 - 11   */
1114
280800
    buf[2] = 0xff;             /* reserved -- always 1 */
1115
280800
    return 3;
1116
}
1117
1118
980
static void dv_format_frame(DVVideoContext *c, uint8_t *buf)
1119
{
1120
    int chan, i, j, k;
1121
    /* We work with 720p frames split in half. The odd half-frame is chan 2,3 */
1122

980
    int chan_offset = 2*(c->sys->height == 720 && c->avctx->frame_number & 1);
1123
1124
2935
    for (chan = 0; chan < c->sys->n_difchan; chan++) {
1125
25355
        for (i = 0; i < c->sys->difseg_size; i++) {
1126
23400
            memset(buf, 0xff, 80 * 6); /* first 6 DIF blocks are for control data */
1127
1128
            /* DV header: 1DIF */
1129
23400
            buf += dv_write_dif_id(dv_sect_header, chan+chan_offset, i, 0, buf);
1130
23400
            buf += dv_write_pack((c->sys->dsf ? dv_header625 : dv_header525),
1131
                                 c, buf);
1132
23400
            buf += 72; /* unused bytes */
1133
1134
            /* DV subcode: 2DIFs */
1135
70200
            for (j = 0; j < 2; j++) {
1136
46800
                buf += dv_write_dif_id(dv_sect_subcode, chan+chan_offset, i, j, buf);
1137
327600
                for (k = 0; k < 6; k++)
1138
280800
                    buf += dv_write_ssyb_id(k, (i < c->sys->difseg_size / 2), buf) + 5;
1139
46800
                buf += 29; /* unused bytes */
1140
            }
1141
1142
            /* DV VAUX: 3DIFS */
1143
93600
            for (j = 0; j < 3; j++) {
1144
70200
                buf += dv_write_dif_id(dv_sect_vaux, chan+chan_offset, i, j, buf);
1145
70200
                buf += dv_write_pack(dv_video_source,  c, buf);
1146
70200
                buf += dv_write_pack(dv_video_control, c, buf);
1147
70200
                buf += 7 * 5;
1148
70200
                buf += dv_write_pack(dv_video_source,  c, buf);
1149
70200
                buf += dv_write_pack(dv_video_control, c, buf);
1150
70200
                buf += 4 * 5 + 2; /* unused bytes */
1151
            }
1152
1153
            /* DV Audio/Video: 135 Video DIFs + 9 Audio DIFs */
1154
3182400
            for (j = 0; j < 135; j++) {
1155
3159000
                if (j % 15 == 0) {
1156
210600
                    memset(buf, 0xff, 80);
1157
210600
                    buf += dv_write_dif_id(dv_sect_audio, chan+chan_offset, i, j/15, buf);
1158
210600
                    buf += 77; /* audio control & shuffled PCM audio */
1159
                }
1160
3159000
                buf += dv_write_dif_id(dv_sect_video, chan+chan_offset, i, j, buf);
1161
3159000
                buf += 77; /* 1 video macroblock: 1 bytes control
1162
                            * 4 * 14 bytes Y 8x8 data
1163
                            * 10 bytes Cr 8x8 data
1164
                            * 10 bytes Cb 8x8 data */
1165
            }
1166
        }
1167
    }
1168
980
}
1169
1170
980
static int dvvideo_encode_frame(AVCodecContext *c, AVPacket *pkt,
1171
                                const AVFrame *frame, int *got_packet)
1172
{
1173
980
    DVVideoContext *s = c->priv_data;
1174
    int ret;
1175
1176
980
    if ((ret = ff_alloc_packet2(c, pkt, s->sys->frame_size, 0)) < 0)
1177
        return ret;
1178
1179
980
    c->pix_fmt                = s->sys->pix_fmt;
1180
980
    s->frame                  = frame;
1181
#if FF_API_CODED_FRAME
1182
FF_DISABLE_DEPRECATION_WARNINGS
1183
980
    c->coded_frame->key_frame = 1;
1184
980
    c->coded_frame->pict_type = AV_PICTURE_TYPE_I;
1185
FF_ENABLE_DEPRECATION_WARNINGS
1186
#endif
1187
980
    s->buf = pkt->data;
1188
1189
980
    dv_format_frame(s, pkt->data);
1190
1191
980
    c->execute(c, dv_encode_video_segment, s->work_chunks, NULL,
1192
               dv_work_pool_size(s->sys), sizeof(DVwork_chunk));
1193
1194
980
    emms_c();
1195
1196
980
    pkt->flags |= AV_PKT_FLAG_KEY;
1197
980
    *got_packet = 1;
1198
1199
980
    return 0;
1200
}
1201
1202
#define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
1203
#define OFFSET(x) offsetof(DVVideoContext, x)
1204
static const AVOption dv_options[] = {
1205
    { "quant_deadzone",        "Quantizer dead zone",    OFFSET(quant_deadzone),       AV_OPT_TYPE_INT, { .i64 = 7 }, 0, 1024, VE },
1206
    { NULL },
1207
};
1208
1209
static const AVClass dvvideo_encode_class = {
1210
    .class_name = "dvvideo encoder",
1211
    .item_name  = av_default_item_name,
1212
    .option     = dv_options,
1213
    .version    = LIBAVUTIL_VERSION_INT,
1214
};
1215
1216
AVCodec ff_dvvideo_encoder = {
1217
    .name           = "dvvideo",
1218
    .long_name      = NULL_IF_CONFIG_SMALL("DV (Digital Video)"),
1219
    .type           = AVMEDIA_TYPE_VIDEO,
1220
    .id             = AV_CODEC_ID_DVVIDEO,
1221
    .priv_data_size = sizeof(DVVideoContext),
1222
    .init           = dvvideo_encode_init,
1223
    .encode2        = dvvideo_encode_frame,
1224
    .capabilities   = AV_CODEC_CAP_SLICE_THREADS | AV_CODEC_CAP_FRAME_THREADS,
1225
    .pix_fmts       = (const enum AVPixelFormat[]) {
1226
        AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV422P,
1227
        AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE
1228
    },
1229
    .priv_class     = &dvvideo_encode_class,
1230
};