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

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

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

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

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

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

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

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

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

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

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

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

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

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