GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavcodec/dvenc.c Lines: 455 508 89.6 %
Date: 2021-04-20 15:25:36 Branches: 222 276 80.4 %

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^16
322
   (in DV100 the AC components are divided by the spec weights) */
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 * (1 << 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) * 8;
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] * (1 << (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) * 8;
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))) * 8;
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] * (1 << (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 * 8;
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
21330000
        flush_put_bits(&pbs[j]);
980
21330000
        memset(put_bits_ptr(&pbs[j]), 0xff, put_bytes_left(&pbs[j], 0));
981
    }
982
983
594000
    if (DV_PROFILE_IS_HD(s->sys))
984
351000
        dv_revise_cnos(dif, enc_blks, s->sys);
985
986
594000
    return 0;
987
}
988
989
304200
static inline int dv_write_pack(enum dv_pack_type pack_id, DVVideoContext *c,
990
                                uint8_t *buf)
991
{
992
    /*
993
     * Here's what SMPTE314M says about these two:
994
     *    (page 6) APTn, AP1n, AP2n, AP3n: These data shall be identical
995
     *             as track application IDs (APTn = 001, AP1n =
996
     *             001, AP2n = 001, AP3n = 001), if the source signal
997
     *             comes from a digital VCR. If the signal source is
998
     *             unknown, all bits for these data shall be set to 1.
999
     *    (page 12) STYPE: STYPE defines a signal type of video signal
1000
     *                     00000b = 4:1:1 compression
1001
     *                     00100b = 4:2:2 compression
1002
     *                     XXXXXX = Reserved
1003
     * Now, I've got two problems with these statements:
1004
     *   1. it looks like APT == 111b should be a safe bet, but it isn't.
1005
     *      It seems that for PAL as defined in IEC 61834 we have to set
1006
     *      APT to 000 and for SMPTE314M to 001.
1007
     *   2. It is not at all clear what STYPE is used for 4:2:0 PAL
1008
     *      compression scheme (if any).
1009
     */
1010
304200
    uint8_t aspect = 0;
1011
304200
    int apt = (c->sys->pix_fmt == AV_PIX_FMT_YUV420P ? 0 : 1);
1012
    int fs;
1013
1014
304200
    if (c->avctx->height >= 720)
1015

187200
        fs = c->avctx->height == 720 || c->frame->top_field_first ? 0x40 : 0x00;
1016
    else
1017
117000
        fs = c->frame->top_field_first ? 0x00 : 0x40;
1018
1019
304200
    if (DV_PROFILE_IS_HD(c->sys) ||
1020
117000
        (int)(av_q2d(c->avctx->sample_aspect_ratio) *
1021
117000
              c->avctx->width / c->avctx->height * 10) >= 17)
1022
        /* HD formats are always 16:9 */
1023
195000
        aspect = 0x02;
1024
1025
304200
    buf[0] = (uint8_t) pack_id;
1026

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

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

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