GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavcodec/ffv1enc.c Lines: 390 706 55.2 %
Date: 2021-04-18 10:33:33 Branches: 239 552 43.3 %

Line Branch Exec Source
1
/*
2
 * FFV1 encoder
3
 *
4
 * Copyright (c) 2003-2013 Michael Niedermayer <michaelni@gmx.at>
5
 *
6
 * This file is part of FFmpeg.
7
 *
8
 * FFmpeg is free software; you can redistribute it and/or
9
 * modify it under the terms of the GNU Lesser General Public
10
 * License as published by the Free Software Foundation; either
11
 * version 2.1 of the License, or (at your option) any later version.
12
 *
13
 * FFmpeg is distributed in the hope that it will be useful,
14
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16
 * Lesser General Public License for more details.
17
 *
18
 * You should have received a copy of the GNU Lesser General Public
19
 * License along with FFmpeg; if not, write to the Free Software
20
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21
 */
22
23
/**
24
 * @file
25
 * FF Video Codec 1 (a lossless codec) encoder
26
 */
27
28
#include "libavutil/attributes.h"
29
#include "libavutil/avassert.h"
30
#include "libavutil/crc.h"
31
#include "libavutil/opt.h"
32
#include "libavutil/imgutils.h"
33
#include "libavutil/pixdesc.h"
34
35
#include "avcodec.h"
36
#include "internal.h"
37
#include "put_bits.h"
38
#include "rangecoder.h"
39
#include "golomb.h"
40
#include "mathops.h"
41
#include "ffv1.h"
42
43
static const int8_t quant5_10bit[256] = {
44
     0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  1,  1,  1,  1,  1,
45
     1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,
46
     1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,
47
     1,  1,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,
48
     2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,
49
     2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,
50
     2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,
51
     2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,
52
    -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
53
    -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
54
    -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
55
    -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
56
    -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -1,
57
    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
58
    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
59
    -1, -1, -1, -1, -1, -1, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0,
60
};
61
62
static const int8_t quant5[256] = {
63
     0,  1,  1,  1,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,
64
     2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,
65
     2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,
66
     2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,
67
     2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,
68
     2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,
69
     2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,
70
     2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,
71
    -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
72
    -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
73
    -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
74
    -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
75
    -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
76
    -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
77
    -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
78
    -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -1, -1, -1,
79
};
80
81
static const int8_t quant9_10bit[256] = {
82
     0,  0,  0,  0,  0,  1,  1,  1,  1,  1,  1,  1,  1,  2,  2,  2,
83
     2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  3,  3,  3,  3,  3,
84
     3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,
85
     3,  3,  3,  3,  3,  3,  3,  3,  4,  4,  4,  4,  4,  4,  4,  4,
86
     4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,
87
     4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,
88
     4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,
89
     4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,
90
    -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4,
91
    -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4,
92
    -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4,
93
    -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4,
94
    -4, -4, -4, -4, -4, -4, -4, -4, -4, -3, -3, -3, -3, -3, -3, -3,
95
    -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3,
96
    -3, -3, -3, -3, -3, -3, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
97
    -2, -2, -2, -2, -1, -1, -1, -1, -1, -1, -1, -1, -0, -0, -0, -0,
98
};
99
100
static const int8_t quant11[256] = {
101
     0,  1,  2,  2,  2,  3,  3,  3,  3,  3,  3,  3,  4,  4,  4,  4,
102
     4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,
103
     4,  4,  4,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,
104
     5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,
105
     5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,
106
     5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,
107
     5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,
108
     5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,
109
    -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5,
110
    -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5,
111
    -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5,
112
    -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5,
113
    -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5,
114
    -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -4, -4,
115
    -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4,
116
    -4, -4, -4, -4, -4, -3, -3, -3, -3, -3, -3, -3, -2, -2, -2, -1,
117
};
118
119
static const uint8_t ver2_state[256] = {
120
      0,  10,  10,  10,  10,  16,  16,  16, 28,   16,  16,  29,  42,  49,  20,  49,
121
     59,  25,  26,  26,  27,  31,  33,  33, 33,   34,  34,  37,  67,  38,  39,  39,
122
     40,  40,  41,  79,  43,  44,  45,  45, 48,   48,  64,  50,  51,  52,  88,  52,
123
     53,  74,  55,  57,  58,  58,  74,  60, 101,  61,  62,  84,  66,  66,  68,  69,
124
     87,  82,  71,  97,  73,  73,  82,  75, 111,  77,  94,  78,  87,  81,  83,  97,
125
     85,  83,  94,  86,  99,  89,  90,  99, 111,  92,  93,  134, 95,  98, 105,  98,
126
    105, 110, 102, 108, 102, 118, 103, 106, 106, 113, 109, 112, 114, 112, 116, 125,
127
    115, 116, 117, 117, 126, 119, 125, 121, 121, 123, 145, 124, 126, 131, 127, 129,
128
    165, 130, 132, 138, 133, 135, 145, 136, 137, 139, 146, 141, 143, 142, 144, 148,
129
    147, 155, 151, 149, 151, 150, 152, 157, 153, 154, 156, 168, 158, 162, 161, 160,
130
    172, 163, 169, 164, 166, 184, 167, 170, 177, 174, 171, 173, 182, 176, 180, 178,
131
    175, 189, 179, 181, 186, 183, 192, 185, 200, 187, 191, 188, 190, 197, 193, 196,
132
    197, 194, 195, 196, 198, 202, 199, 201, 210, 203, 207, 204, 205, 206, 208, 214,
133
    209, 211, 221, 212, 213, 215, 224, 216, 217, 218, 219, 220, 222, 228, 223, 225,
134
    226, 224, 227, 229, 240, 230, 231, 232, 233, 234, 235, 236, 238, 239, 237, 242,
135
    241, 243, 242, 244, 245, 246, 247, 248, 249, 250, 251, 252, 252, 253, 254, 255,
136
};
137
138
static void find_best_state(uint8_t best_state[256][256],
139
                            const uint8_t one_state[256])
140
{
141
    int i, j, k, m;
142
    double l2tab[256];
143
144
    for (i = 1; i < 256; i++)
145
        l2tab[i] = log2(i / 256.0);
146
147
    for (i = 0; i < 256; i++) {
148
        double best_len[256];
149
        double p = i / 256.0;
150
151
        for (j = 0; j < 256; j++)
152
            best_len[j] = 1 << 30;
153
154
        for (j = FFMAX(i - 10, 1); j < FFMIN(i + 11, 256); j++) {
155
            double occ[256] = { 0 };
156
            double len      = 0;
157
            occ[j] = 1.0;
158
159
            if (!one_state[j])
160
                continue;
161
162
            for (k = 0; k < 256; k++) {
163
                double newocc[256] = { 0 };
164
                for (m = 1; m < 256; m++)
165
                    if (occ[m]) {
166
                        len -=occ[m]*(     p *l2tab[    m]
167
                                      + (1-p)*l2tab[256-m]);
168
                    }
169
                if (len < best_len[k]) {
170
                    best_len[k]      = len;
171
                    best_state[i][k] = j;
172
                }
173
                for (m = 1; m < 256; m++)
174
                    if (occ[m]) {
175
                        newocc[      one_state[      m]] += occ[m] * p;
176
                        newocc[256 - one_state[256 - m]] += occ[m] * (1 - p);
177
                    }
178
                memcpy(occ, newocc, sizeof(occ));
179
            }
180
        }
181
    }
182
}
183
184
131381455
static av_always_inline av_flatten void put_symbol_inline(RangeCoder *c,
185
                                                          uint8_t *state, int v,
186
                                                          int is_signed,
187
                                                          uint64_t rc_stat[256][2],
188
                                                          uint64_t rc_stat2[32][2])
189
{
190
    int i;
191
192
#define put_rac(C, S, B)                        \
193
    do {                                        \
194
        if (rc_stat) {                          \
195
            rc_stat[*(S)][B]++;                 \
196
            rc_stat2[(S) - state][B]++;         \
197
        }                                       \
198
        put_rac(C, S, B);                       \
199
    } while (0)
200
201
131381455
    if (v) {
202
72654127
        const int a = FFABS(v);
203
72654127
        const int e = av_log2(a);
204
72654127
        put_rac(c, state + 0, 0);
205
72654127
        if (e <= 9) {
206
276055329
            for (i = 0; i < e; i++)
207
228363380
                put_rac(c, state + 1 + i, 1);  // 1..10
208
47691949
            put_rac(c, state + 1 + i, 0);
209
210
276055329
            for (i = e - 1; i >= 0; i--)
211
228363380
                put_rac(c, state + 22 + i, (a >> i) & 1);  // 22..31
212
213
47691949
            if (is_signed)
214
47676128
                put_rac(c, state + 11 + e, v < 0);  // 11..21
215
        } else {
216
294732467
            for (i = 0; i < e; i++)
217


269770289
                put_rac(c, state + 1 + FFMIN(i, 9), 1);  // 1..10
218
24962178
            put_rac(c, state + 1 + 9, 0);
219
220
294732467
            for (i = e - 1; i >= 0; i--)
221


269770289
                put_rac(c, state + 22 + FFMIN(i, 9), (a >> i) & 1);  // 22..31
222
223
24962178
            if (is_signed)
224
24962178
                put_rac(c, state + 11 + 10, v < 0);  // 11..21
225
        }
226
    } else {
227
58727328
        put_rac(c, state + 0, 1);
228
    }
229
#undef put_rac
230
131381455
}
231
232
48455
static av_noinline void put_symbol(RangeCoder *c, uint8_t *state,
233
                                   int v, int is_signed)
234
{
235
48455
    put_symbol_inline(c, state, v, is_signed, NULL, NULL);
236
48455
}
237
238
239
110987686
static inline void put_vlc_symbol(PutBitContext *pb, VlcState *const state,
240
                                  int v, int bits)
241
{
242
    int i, k, code;
243
110987686
    v = fold(v - state->bias, bits);
244
245
110987686
    i = state->count;
246
110987686
    k = 0;
247
295603054
    while (i < state->error_sum) { // FIXME: optimize
248
184615368
        k++;
249
184615368
        i += i;
250
    }
251
252
    av_assert2(k <= 13);
253
254
110987686
    code = v ^ ((2 * state->drift + state->count) >> 31);
255
256
    ff_dlog(NULL, "v:%d/%d bias:%d error:%d drift:%d count:%d k:%d\n", v, code,
257
            state->bias, state->error_sum, state->drift, state->count, k);
258
110987686
    set_sr_golomb(pb, code, k, 12, bits);
259
260
110987686
    update_vlc_state(state, v);
261
110987686
}
262
263
#define TYPE int16_t
264
#define RENAME(name) name
265
#include "ffv1enc_template.c"
266
#undef TYPE
267
#undef RENAME
268
269
#define TYPE int32_t
270
#define RENAME(name) name ## 32
271
#include "ffv1enc_template.c"
272
273
10260
static int encode_plane(FFV1Context *s, uint8_t *src, int w, int h,
274
                         int stride, int plane_index, int pixel_stride)
275
{
276
    int x, y, i, ret;
277
10260
    const int ring_size = s->context_model ? 3 : 2;
278
    int16_t *sample[3];
279
10260
    s->run_index = 0;
280
281
10260
    memset(s->sample_buffer, 0, ring_size * (w + 6) * sizeof(*s->sample_buffer));
282
283
1020060
    for (y = 0; y < h; y++) {
284
3029400
        for (i = 0; i < ring_size; i++)
285
2019600
            sample[i] = s->sample_buffer + (w + 6) * ((h + i - y) % ring_size) + 3;
286
287
1009800
        sample[0][-1]= sample[1][0  ];
288
1009800
        sample[1][ w]= sample[1][w-1];
289
1009800
        if (s->bits_per_raw_sample <= 8) {
290
69145300
            for (x = 0; x < w; x++)
291
68695900
                sample[0][x] = src[x * pixel_stride + stride * y];
292
449400
            if((ret = encode_line(s, w, sample, plane_index, 8)) < 0)
293
                return ret;
294
        } else {
295
560400
            if (s->packed_at_lsb) {
296
40038800
                for (x = 0; x < w; x++) {
297
39747800
                    sample[0][x] = ((uint16_t*)(src + stride*y))[x];
298
                }
299
            } else {
300
46062000
                for (x = 0; x < w; x++) {
301
45792600
                    sample[0][x] = ((uint16_t*)(src + stride*y))[x] >> (16 - s->bits_per_raw_sample);
302
                }
303
            }
304
560400
            if((ret = encode_line(s, w, sample, plane_index, s->bits_per_raw_sample)) < 0)
305
                return ret;
306
        }
307
    }
308
10260
    return 0;
309
}
310
311
350
static void write_quant_table(RangeCoder *c, int16_t *quant_table)
312
{
313
350
    int last = 0;
314
    int i;
315
    uint8_t state[CONTEXT_SIZE];
316
350
    memset(state, 128, sizeof(state));
317
318
44800
    for (i = 1; i < 128; i++)
319
44450
        if (quant_table[i] != quant_table[i - 1]) {
320
1010
            put_symbol(c, state, i - last - 1, 0);
321
1010
            last = i;
322
        }
323
350
    put_symbol(c, state, i - last - 1, 0);
324
350
}
325
326
70
static void write_quant_tables(RangeCoder *c,
327
                               int16_t quant_table[MAX_CONTEXT_INPUTS][256])
328
{
329
    int i;
330
420
    for (i = 0; i < 5; i++)
331
350
        write_quant_table(c, quant_table[i]);
332
70
}
333
334
50
static int contains_non_128(uint8_t (*initial_state)[CONTEXT_SIZE],
335
                            int nb_contexts)
336
{
337
50
    if (!initial_state)
338
        return 0;
339
205775
    for (int i = 0; i < nb_contexts; i++)
340
6788925
        for (int j = 0; j < CONTEXT_SIZE; j++)
341
6583200
            if (initial_state[i][j] != 128)
342
                return 1;
343
50
    return 0;
344
}
345
346
141
static void write_header(FFV1Context *f)
347
{
348
    uint8_t state[CONTEXT_SIZE];
349
    int i, j;
350
141
    RangeCoder *const c = &f->slice_context[0]->c;
351
352
141
    memset(state, 128, sizeof(state));
353
354
141
    if (f->version < 2) {
355
20
        put_symbol(c, state, f->version, 0);
356
20
        put_symbol(c, state, f->ac, 0);
357
20
        if (f->ac == AC_RANGE_CUSTOM_TAB) {
358
            for (i = 1; i < 256; i++)
359
                put_symbol(c, state,
360
                           f->state_transition[i] - c->one_state[i], 1);
361
        }
362
20
        put_symbol(c, state, f->colorspace, 0); //YUV cs type
363
20
        if (f->version > 0)
364
            put_symbol(c, state, f->bits_per_raw_sample, 0);
365
20
        put_rac(c, state, f->chroma_planes);
366
20
        put_symbol(c, state, f->chroma_h_shift, 0);
367
20
        put_symbol(c, state, f->chroma_v_shift, 0);
368
20
        put_rac(c, state, f->transparency);
369
370
20
        write_quant_tables(c, f->quant_table);
371
121
    } else if (f->version < 3) {
372
        put_symbol(c, state, f->slice_count, 0);
373
        for (i = 0; i < f->slice_count; i++) {
374
            FFV1Context *fs = f->slice_context[i];
375
            put_symbol(c, state,
376
                       (fs->slice_x      + 1) * f->num_h_slices / f->width, 0);
377
            put_symbol(c, state,
378
                       (fs->slice_y      + 1) * f->num_v_slices / f->height, 0);
379
            put_symbol(c, state,
380
                       (fs->slice_width  + 1) * f->num_h_slices / f->width - 1,
381
                       0);
382
            put_symbol(c, state,
383
                       (fs->slice_height + 1) * f->num_v_slices / f->height - 1,
384
                       0);
385
            for (j = 0; j < f->plane_count; j++) {
386
                put_symbol(c, state, f->plane[j].quant_table_index, 0);
387
                av_assert0(f->plane[j].quant_table_index == f->context_model);
388
            }
389
        }
390
    }
391
141
}
392
393
25
static int write_extradata(FFV1Context *f)
394
{
395
25
    RangeCoder *const c = &f->c;
396
    uint8_t state[CONTEXT_SIZE];
397
    int i, j, k;
398
    uint8_t state2[32][CONTEXT_SIZE];
399
    unsigned v;
400
401
25
    memset(state2, 128, sizeof(state2));
402
25
    memset(state, 128, sizeof(state));
403
404
25
    f->avctx->extradata_size = 10000 + 4 +
405
                                    (11 * 11 * 5 * 5 * 5 + 11 * 11 * 11) * 32;
406
25
    f->avctx->extradata = av_malloc(f->avctx->extradata_size + AV_INPUT_BUFFER_PADDING_SIZE);
407
25
    if (!f->avctx->extradata)
408
        return AVERROR(ENOMEM);
409
25
    ff_init_range_encoder(c, f->avctx->extradata, f->avctx->extradata_size);
410
25
    ff_build_rac_states(c, 0.05 * (1LL << 32), 256 - 8);
411
412
25
    put_symbol(c, state, f->version, 0);
413
25
    if (f->version > 2) {
414
25
        if (f->version == 3) {
415
25
            f->micro_version = 4;
416
        } else if (f->version == 4)
417
            f->micro_version = 2;
418
25
        put_symbol(c, state, f->micro_version, 0);
419
    }
420
421
25
    put_symbol(c, state, f->ac, 0);
422
25
    if (f->ac == AC_RANGE_CUSTOM_TAB)
423
3328
        for (i = 1; i < 256; i++)
424
3315
            put_symbol(c, state, f->state_transition[i] - c->one_state[i], 1);
425
426
25
    put_symbol(c, state, f->colorspace, 0); // YUV cs type
427
25
    put_symbol(c, state, f->bits_per_raw_sample, 0);
428
25
    put_rac(c, state, f->chroma_planes);
429
25
    put_symbol(c, state, f->chroma_h_shift, 0);
430
25
    put_symbol(c, state, f->chroma_v_shift, 0);
431
25
    put_rac(c, state, f->transparency);
432
25
    put_symbol(c, state, f->num_h_slices - 1, 0);
433
25
    put_symbol(c, state, f->num_v_slices - 1, 0);
434
435
25
    put_symbol(c, state, f->quant_table_count, 0);
436
75
    for (i = 0; i < f->quant_table_count; i++)
437
50
        write_quant_tables(c, f->quant_tables[i]);
438
439
75
    for (i = 0; i < f->quant_table_count; i++) {
440
50
        if (contains_non_128(f->initial_states[i], f->context_count[i])) {
441
            put_rac(c, state, 1);
442
            for (j = 0; j < f->context_count[i]; j++)
443
                for (k = 0; k < CONTEXT_SIZE; k++) {
444
                    int pred = j ? f->initial_states[i][j - 1][k] : 128;
445
                    put_symbol(c, state2[k],
446
                               (int8_t)(f->initial_states[i][j][k] - pred), 1);
447
                }
448
        } else {
449
50
            put_rac(c, state, 0);
450
        }
451
    }
452
453
25
    if (f->version > 2) {
454
25
        put_symbol(c, state, f->ec, 0);
455
25
        put_symbol(c, state, f->intra = (f->avctx->gop_size < 2), 0);
456
    }
457
458
25
    f->avctx->extradata_size = ff_rac_terminate(c, 0);
459
25
    v = av_crc(av_crc_get_table(AV_CRC_32_IEEE), 0, f->avctx->extradata, f->avctx->extradata_size);
460
25
    AV_WL32(f->avctx->extradata + f->avctx->extradata_size, v);
461
25
    f->avctx->extradata_size += 4;
462
463
25
    return 0;
464
}
465
466
static int sort_stt(FFV1Context *s, uint8_t stt[256])
467
{
468
    int i, i2, changed, print = 0;
469
470
    do {
471
        changed = 0;
472
        for (i = 12; i < 244; i++) {
473
            for (i2 = i + 1; i2 < 245 && i2 < i + 4; i2++) {
474
475
#define COST(old, new)                                      \
476
    s->rc_stat[old][0] * -log2((256 - (new)) / 256.0) +     \
477
    s->rc_stat[old][1] * -log2((new)         / 256.0)
478
479
#define COST2(old, new)                         \
480
    COST(old, new) + COST(256 - (old), 256 - (new))
481
482
                double size0 = COST2(i,  i) + COST2(i2, i2);
483
                double sizeX = COST2(i, i2) + COST2(i2, i);
484
                if (size0 - sizeX > size0*(1e-14) && i != 128 && i2 != 128) {
485
                    int j;
486
                    FFSWAP(int, stt[i], stt[i2]);
487
                    FFSWAP(int, s->rc_stat[i][0], s->rc_stat[i2][0]);
488
                    FFSWAP(int, s->rc_stat[i][1], s->rc_stat[i2][1]);
489
                    if (i != 256 - i2) {
490
                        FFSWAP(int, stt[256 - i], stt[256 - i2]);
491
                        FFSWAP(int, s->rc_stat[256 - i][0], s->rc_stat[256 - i2][0]);
492
                        FFSWAP(int, s->rc_stat[256 - i][1], s->rc_stat[256 - i2][1]);
493
                    }
494
                    for (j = 1; j < 256; j++) {
495
                        if (stt[j] == i)
496
                            stt[j] = i2;
497
                        else if (stt[j] == i2)
498
                            stt[j] = i;
499
                        if (i != 256 - i2) {
500
                            if (stt[256 - j] == 256 - i)
501
                                stt[256 - j] = 256 - i2;
502
                            else if (stt[256 - j] == 256 - i2)
503
                                stt[256 - j] = 256 - i;
504
                        }
505
                    }
506
                    print = changed = 1;
507
                }
508
            }
509
        }
510
    } while (changed);
511
    return print;
512
}
513
514
29
static av_cold int encode_init(AVCodecContext *avctx)
515
{
516
29
    FFV1Context *s = avctx->priv_data;
517
29
    const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(avctx->pix_fmt);
518
    int i, j, k, m, ret;
519
520
29
    if ((ret = ff_ffv1_common_init(avctx)) < 0)
521
        return ret;
522
523
29
    s->version = 0;
524
525
29
    if ((avctx->flags & (AV_CODEC_FLAG_PASS1 | AV_CODEC_FLAG_PASS2)) ||
526
29
        avctx->slices > 1)
527
4
        s->version = FFMAX(s->version, 2);
528
529
    // Unspecified level & slices, we choose version 1.2+ to ensure multithreaded decodability
530

29
    if (avctx->slices == 0 && avctx->level < 0 && avctx->width * avctx->height > 720*576)
531
1
        s->version = FFMAX(s->version, 2);
532
533

29
    if (avctx->level <= 0 && s->version == 2) {
534
5
        s->version = 3;
535
    }
536

29
    if (avctx->level >= 0 && avctx->level <= 4) {
537
20
        if (avctx->level < s->version) {
538
            av_log(avctx, AV_LOG_ERROR, "Version %d needed for requested features but %d requested\n", s->version, avctx->level);
539
            return AVERROR(EINVAL);
540
        }
541
20
        s->version = avctx->level;
542
    }
543
544
29
    if (s->ec < 0) {
545
29
        s->ec = (s->version >= 3);
546
    }
547
548
    // CRC requires version 3+
549
29
    if (s->ec)
550
25
        s->version = FFMAX(s->version, 3);
551
552

29
    if ((s->version == 2 || s->version>3) && avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
553
        av_log(avctx, AV_LOG_ERROR, "Version 2 needed for requested features but version 2 is experimental and not enabled\n");
554
        return AVERROR_INVALIDDATA;
555
    }
556
557
#if FF_API_CODER_TYPE
558
FF_DISABLE_DEPRECATION_WARNINGS
559
29
    if (avctx->coder_type != -1)
560
        s->ac = avctx->coder_type > 0 ? AC_RANGE_CUSTOM_TAB : AC_GOLOMB_RICE;
561
    else
562
FF_ENABLE_DEPRECATION_WARNINGS
563
#endif
564
29
    if (s->ac == 1) // Compatbility with common command line usage
565
        s->ac = AC_RANGE_CUSTOM_TAB;
566
29
    else if (s->ac == AC_RANGE_DEFAULT_TAB_FORCE)
567
        s->ac = AC_RANGE_DEFAULT_TAB;
568
569
29
    s->plane_count = 3;
570




29
    switch(avctx->pix_fmt) {
571
    case AV_PIX_FMT_GRAY9:
572
    case AV_PIX_FMT_YUV444P9:
573
    case AV_PIX_FMT_YUV422P9:
574
    case AV_PIX_FMT_YUV420P9:
575
    case AV_PIX_FMT_YUVA444P9:
576
    case AV_PIX_FMT_YUVA422P9:
577
    case AV_PIX_FMT_YUVA420P9:
578
        if (!avctx->bits_per_raw_sample)
579
            s->bits_per_raw_sample = 9;
580
    case AV_PIX_FMT_GRAY10:
581
    case AV_PIX_FMT_YUV444P10:
582
    case AV_PIX_FMT_YUV440P10:
583
    case AV_PIX_FMT_YUV420P10:
584
    case AV_PIX_FMT_YUV422P10:
585
    case AV_PIX_FMT_YUVA444P10:
586
    case AV_PIX_FMT_YUVA422P10:
587
    case AV_PIX_FMT_YUVA420P10:
588

5
        if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
589
4
            s->bits_per_raw_sample = 10;
590
    case AV_PIX_FMT_GRAY12:
591
    case AV_PIX_FMT_YUV444P12:
592
    case AV_PIX_FMT_YUV440P12:
593
    case AV_PIX_FMT_YUV420P12:
594
    case AV_PIX_FMT_YUV422P12:
595

5
        if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
596
            s->bits_per_raw_sample = 12;
597
    case AV_PIX_FMT_YUV444P14:
598
    case AV_PIX_FMT_YUV420P14:
599
    case AV_PIX_FMT_YUV422P14:
600

5
        if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
601
            s->bits_per_raw_sample = 14;
602
5
        s->packed_at_lsb = 1;
603
9
    case AV_PIX_FMT_GRAY16:
604
    case AV_PIX_FMT_YUV444P16:
605
    case AV_PIX_FMT_YUV422P16:
606
    case AV_PIX_FMT_YUV420P16:
607
    case AV_PIX_FMT_YUVA444P16:
608
    case AV_PIX_FMT_YUVA422P16:
609
    case AV_PIX_FMT_YUVA420P16:
610

9
        if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample) {
611
4
            s->bits_per_raw_sample = 16;
612
5
        } else if (!s->bits_per_raw_sample) {
613
1
            s->bits_per_raw_sample = avctx->bits_per_raw_sample;
614
        }
615
9
        if (s->bits_per_raw_sample <= 8) {
616
            av_log(avctx, AV_LOG_ERROR, "bits_per_raw_sample invalid\n");
617
            return AVERROR_INVALIDDATA;
618
        }
619
9
        s->version = FFMAX(s->version, 1);
620
21
    case AV_PIX_FMT_GRAY8:
621
    case AV_PIX_FMT_YA8:
622
    case AV_PIX_FMT_YUV444P:
623
    case AV_PIX_FMT_YUV440P:
624
    case AV_PIX_FMT_YUV422P:
625
    case AV_PIX_FMT_YUV420P:
626
    case AV_PIX_FMT_YUV411P:
627
    case AV_PIX_FMT_YUV410P:
628
    case AV_PIX_FMT_YUVA444P:
629
    case AV_PIX_FMT_YUVA422P:
630
    case AV_PIX_FMT_YUVA420P:
631
21
        s->chroma_planes = desc->nb_components < 3 ? 0 : 1;
632
21
        s->colorspace = 0;
633
21
        s->transparency = !!(desc->flags & AV_PIX_FMT_FLAG_ALPHA);
634

21
        if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
635
12
            s->bits_per_raw_sample = 8;
636
9
        else if (!s->bits_per_raw_sample)
637
            s->bits_per_raw_sample = 8;
638
21
        break;
639
    case AV_PIX_FMT_RGB32:
640
        s->colorspace = 1;
641
        s->transparency = 1;
642
        s->chroma_planes = 1;
643
        s->bits_per_raw_sample = 8;
644
        break;
645
    case AV_PIX_FMT_RGBA64:
646
        s->colorspace = 1;
647
        s->transparency = 1;
648
        s->chroma_planes = 1;
649
        s->bits_per_raw_sample = 16;
650
        s->use32bit = 1;
651
        s->version = FFMAX(s->version, 1);
652
        break;
653
4
    case AV_PIX_FMT_RGB48:
654
4
        s->colorspace = 1;
655
4
        s->chroma_planes = 1;
656
4
        s->bits_per_raw_sample = 16;
657
4
        s->use32bit = 1;
658
4
        s->version = FFMAX(s->version, 1);
659
4
        break;
660
4
    case AV_PIX_FMT_0RGB32:
661
4
        s->colorspace = 1;
662
4
        s->chroma_planes = 1;
663
4
        s->bits_per_raw_sample = 8;
664
4
        break;
665
    case AV_PIX_FMT_GBRP9:
666
        if (!avctx->bits_per_raw_sample)
667
            s->bits_per_raw_sample = 9;
668
    case AV_PIX_FMT_GBRP10:
669
    case AV_PIX_FMT_GBRAP10:
670
        if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
671
            s->bits_per_raw_sample = 10;
672
    case AV_PIX_FMT_GBRP12:
673
    case AV_PIX_FMT_GBRAP12:
674
        if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
675
            s->bits_per_raw_sample = 12;
676
    case AV_PIX_FMT_GBRP14:
677
        if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
678
            s->bits_per_raw_sample = 14;
679
    case AV_PIX_FMT_GBRP16:
680
    case AV_PIX_FMT_GBRAP16:
681
        if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
682
            s->bits_per_raw_sample = 16;
683
        else if (!s->bits_per_raw_sample)
684
            s->bits_per_raw_sample = avctx->bits_per_raw_sample;
685
        s->transparency = !!(desc->flags & AV_PIX_FMT_FLAG_ALPHA);
686
        s->colorspace = 1;
687
        s->chroma_planes = 1;
688
        if (s->bits_per_raw_sample >= 16) {
689
            s->use32bit = 1;
690
        }
691
        s->version = FFMAX(s->version, 1);
692
        break;
693
    default:
694
        av_log(avctx, AV_LOG_ERROR, "format not supported\n");
695
        return AVERROR(ENOSYS);
696
    }
697
29
    av_assert0(s->bits_per_raw_sample >= 8);
698
699
29
    if (s->bits_per_raw_sample > 8) {
700
13
        if (s->ac == AC_GOLOMB_RICE) {
701
13
            av_log(avctx, AV_LOG_INFO,
702
                    "bits_per_raw_sample > 8, forcing range coder\n");
703
13
            s->ac = AC_RANGE_CUSTOM_TAB;
704
        }
705
    }
706
#if FF_API_PRIVATE_OPT
707
FF_DISABLE_DEPRECATION_WARNINGS
708
29
    if (avctx->context_model)
709
        s->context_model = avctx->context_model;
710
29
    if (avctx->context_model > 1U) {
711
        av_log(avctx, AV_LOG_ERROR, "Invalid context model %d, valid values are 0 and 1\n", avctx->context_model);
712
        return AVERROR(EINVAL);
713
    }
714
FF_ENABLE_DEPRECATION_WARNINGS
715
#endif
716
717
29
    if (s->ac == AC_RANGE_CUSTOM_TAB) {
718
3328
        for (i = 1; i < 256; i++)
719
3315
            s->state_transition[i] = ver2_state[i];
720
    } else {
721
        RangeCoder c;
722
16
        ff_build_rac_states(&c, 0.05 * (1LL << 32), 256 - 8);
723
4096
        for (i = 1; i < 256; i++)
724
4080
            s->state_transition[i] = c.one_state[i];
725
    }
726
727
7453
    for (i = 0; i < 256; i++) {
728
7424
        s->quant_table_count = 2;
729
7424
        if (s->bits_per_raw_sample <= 8) {
730
4096
            s->quant_tables[0][0][i]=           quant11[i];
731
4096
            s->quant_tables[0][1][i]=        11*quant11[i];
732
4096
            s->quant_tables[0][2][i]=     11*11*quant11[i];
733
4096
            s->quant_tables[1][0][i]=           quant11[i];
734
4096
            s->quant_tables[1][1][i]=        11*quant11[i];
735
4096
            s->quant_tables[1][2][i]=     11*11*quant5 [i];
736
4096
            s->quant_tables[1][3][i]=   5*11*11*quant5 [i];
737
4096
            s->quant_tables[1][4][i]= 5*5*11*11*quant5 [i];
738
        } else {
739
3328
            s->quant_tables[0][0][i]=           quant9_10bit[i];
740
3328
            s->quant_tables[0][1][i]=        11*quant9_10bit[i];
741
3328
            s->quant_tables[0][2][i]=     11*11*quant9_10bit[i];
742
3328
            s->quant_tables[1][0][i]=           quant9_10bit[i];
743
3328
            s->quant_tables[1][1][i]=        11*quant9_10bit[i];
744
3328
            s->quant_tables[1][2][i]=     11*11*quant5_10bit[i];
745
3328
            s->quant_tables[1][3][i]=   5*11*11*quant5_10bit[i];
746
3328
            s->quant_tables[1][4][i]= 5*5*11*11*quant5_10bit[i];
747
        }
748
    }
749
29
    s->context_count[0] = (11 * 11 * 11        + 1) / 2;
750
29
    s->context_count[1] = (11 * 11 * 5 * 5 * 5 + 1) / 2;
751
29
    memcpy(s->quant_table, s->quant_tables[s->context_model],
752
           sizeof(s->quant_table));
753
754
116
    for (i = 0; i < s->plane_count; i++) {
755
87
        PlaneContext *const p = &s->plane[i];
756
757
87
        memcpy(p->quant_table, s->quant_table, sizeof(p->quant_table));
758
87
        p->quant_table_index = s->context_model;
759
87
        p->context_count     = s->context_count[p->quant_table_index];
760
    }
761
762
29
    if ((ret = ff_ffv1_allocate_initial_states(s)) < 0)
763
        return ret;
764
765
#if FF_API_CODED_FRAME
766
FF_DISABLE_DEPRECATION_WARNINGS
767
29
    avctx->coded_frame->pict_type = AV_PICTURE_TYPE_I;
768
FF_ENABLE_DEPRECATION_WARNINGS
769
#endif
770
771
29
    if (!s->transparency)
772
29
        s->plane_count = 2;
773

29
    if (!s->chroma_planes && s->version > 3)
774
        s->plane_count--;
775
776
29
    ret = av_pix_fmt_get_chroma_sub_sample (avctx->pix_fmt, &s->chroma_h_shift, &s->chroma_v_shift);
777
29
    if (ret)
778
        return ret;
779
780
29
    s->picture_number = 0;
781
782
29
    if (avctx->flags & (AV_CODEC_FLAG_PASS1 | AV_CODEC_FLAG_PASS2)) {
783
        for (i = 0; i < s->quant_table_count; i++) {
784
            s->rc_stat2[i] = av_mallocz(s->context_count[i] *
785
                                        sizeof(*s->rc_stat2[i]));
786
            if (!s->rc_stat2[i])
787
                return AVERROR(ENOMEM);
788
        }
789
    }
790
29
    if (avctx->stats_in) {
791
        char *p = avctx->stats_in;
792
        uint8_t (*best_state)[256] = av_malloc_array(256, 256);
793
        int gob_count = 0;
794
        char *next;
795
        if (!best_state)
796
            return AVERROR(ENOMEM);
797
798
        av_assert0(s->version >= 2);
799
800
        for (;;) {
801
            for (j = 0; j < 256; j++)
802
                for (i = 0; i < 2; i++) {
803
                    s->rc_stat[j][i] = strtol(p, &next, 0);
804
                    if (next == p) {
805
                        av_log(avctx, AV_LOG_ERROR,
806
                               "2Pass file invalid at %d %d [%s]\n", j, i, p);
807
                        av_freep(&best_state);
808
                        return AVERROR_INVALIDDATA;
809
                    }
810
                    p = next;
811
                }
812
            for (i = 0; i < s->quant_table_count; i++)
813
                for (j = 0; j < s->context_count[i]; j++) {
814
                    for (k = 0; k < 32; k++)
815
                        for (m = 0; m < 2; m++) {
816
                            s->rc_stat2[i][j][k][m] = strtol(p, &next, 0);
817
                            if (next == p) {
818
                                av_log(avctx, AV_LOG_ERROR,
819
                                       "2Pass file invalid at %d %d %d %d [%s]\n",
820
                                       i, j, k, m, p);
821
                                av_freep(&best_state);
822
                                return AVERROR_INVALIDDATA;
823
                            }
824
                            p = next;
825
                        }
826
                }
827
            gob_count = strtol(p, &next, 0);
828
            if (next == p || gob_count <= 0) {
829
                av_log(avctx, AV_LOG_ERROR, "2Pass file invalid\n");
830
                av_freep(&best_state);
831
                return AVERROR_INVALIDDATA;
832
            }
833
            p = next;
834
            while (*p == '\n' || *p == ' ')
835
                p++;
836
            if (p[0] == 0)
837
                break;
838
        }
839
        if (s->ac == AC_RANGE_CUSTOM_TAB)
840
            sort_stt(s, s->state_transition);
841
842
        find_best_state(best_state, s->state_transition);
843
844
        for (i = 0; i < s->quant_table_count; i++) {
845
            for (k = 0; k < 32; k++) {
846
                double a=0, b=0;
847
                int jp = 0;
848
                for (j = 0; j < s->context_count[i]; j++) {
849
                    double p = 128;
850
                    if (s->rc_stat2[i][j][k][0] + s->rc_stat2[i][j][k][1] > 200 && j || a+b > 200) {
851
                        if (a+b)
852
                            p = 256.0 * b / (a + b);
853
                        s->initial_states[i][jp][k] =
854
                            best_state[av_clip(round(p), 1, 255)][av_clip_uint8((a + b) / gob_count)];
855
                        for(jp++; jp<j; jp++)
856
                            s->initial_states[i][jp][k] = s->initial_states[i][jp-1][k];
857
                        a=b=0;
858
                    }
859
                    a += s->rc_stat2[i][j][k][0];
860
                    b += s->rc_stat2[i][j][k][1];
861
                    if (a+b) {
862
                        p = 256.0 * b / (a + b);
863
                    }
864
                    s->initial_states[i][j][k] =
865
                        best_state[av_clip(round(p), 1, 255)][av_clip_uint8((a + b) / gob_count)];
866
                }
867
            }
868
        }
869
        av_freep(&best_state);
870
    }
871
872
29
    if (s->version > 1) {
873
25
        int plane_count = 1 + 2*s->chroma_planes + s->transparency;
874
25
        int max_h_slices = AV_CEIL_RSHIFT(avctx->width , s->chroma_h_shift);
875
25
        int max_v_slices = AV_CEIL_RSHIFT(avctx->height, s->chroma_v_shift);
876

25
        s->num_v_slices = (avctx->width > 352 || avctx->height > 288 || !avctx->slices) ? 2 : 1;
877
878
25
        s->num_v_slices = FFMIN(s->num_v_slices, max_v_slices);
879
880
29
        for (; s->num_v_slices < 32; s->num_v_slices++) {
881
33
            for (s->num_h_slices = s->num_v_slices; s->num_h_slices < 2*s->num_v_slices; s->num_h_slices++) {
882
29
                int maxw = (avctx->width  + s->num_h_slices - 1) / s->num_h_slices;
883
29
                int maxh = (avctx->height + s->num_v_slices - 1) / s->num_v_slices;
884

29
                if (s->num_h_slices > max_h_slices || s->num_v_slices > max_v_slices)
885
                    continue;
886
29
                if (maxw * maxh * (int64_t)(s->bits_per_raw_sample+1) * plane_count > 8<<24)
887
                    continue;
888

29
                if (avctx->slices == s->num_h_slices * s->num_v_slices && avctx->slices <= MAX_SLICES || !avctx->slices)
889
25
                    goto slices_ok;
890
            }
891
        }
892
        av_log(avctx, AV_LOG_ERROR,
893
               "Unsupported number %d of slices requested, please specify a "
894
               "supported number with -slices (ex:4,6,9,12,16, ...)\n",
895
               avctx->slices);
896
        return AVERROR(ENOSYS);
897
25
slices_ok:
898
25
        if ((ret = write_extradata(s)) < 0)
899
            return ret;
900
    }
901
902
29
    if ((ret = ff_ffv1_init_slice_contexts(s)) < 0)
903
        return ret;
904
29
    s->slice_count = s->max_slice_count;
905
29
    if ((ret = ff_ffv1_init_slices_state(s)) < 0)
906
        return ret;
907
908
#define STATS_OUT_SIZE 1024 * 1024 * 6
909
29
    if (avctx->flags & AV_CODEC_FLAG_PASS1) {
910
        avctx->stats_out = av_mallocz(STATS_OUT_SIZE);
911
        if (!avctx->stats_out)
912
            return AVERROR(ENOMEM);
913
        for (i = 0; i < s->quant_table_count; i++)
914
            for (j = 0; j < s->max_slice_count; j++) {
915
                FFV1Context *sf = s->slice_context[j];
916
                av_assert0(!sf->rc_stat2[i]);
917
                sf->rc_stat2[i] = av_mallocz(s->context_count[i] *
918
                                             sizeof(*sf->rc_stat2[i]));
919
                if (!sf->rc_stat2[i])
920
                    return AVERROR(ENOMEM);
921
            }
922
    }
923
924
29
    return 0;
925
}
926
927
4820
static void encode_slice_header(FFV1Context *f, FFV1Context *fs)
928
{
929
4820
    RangeCoder *c = &fs->c;
930
    uint8_t state[CONTEXT_SIZE];
931
    int j;
932
4820
    memset(state, 128, sizeof(state));
933
934
4820
    put_symbol(c, state, (fs->slice_x     +1)*f->num_h_slices / f->width   , 0);
935
4820
    put_symbol(c, state, (fs->slice_y     +1)*f->num_v_slices / f->height  , 0);
936
4820
    put_symbol(c, state, (fs->slice_width +1)*f->num_h_slices / f->width -1, 0);
937
4820
    put_symbol(c, state, (fs->slice_height+1)*f->num_v_slices / f->height-1, 0);
938
14460
    for (j=0; j<f->plane_count; j++) {
939
9640
        put_symbol(c, state, f->plane[j].quant_table_index, 0);
940
9640
        av_assert0(f->plane[j].quant_table_index == f->context_model);
941
    }
942
4820
    if (!f->picture.f->interlaced_frame)
943
4820
        put_symbol(c, state, 3, 0);
944
    else
945
        put_symbol(c, state, 1 + !f->picture.f->top_field_first, 0);
946
4820
    put_symbol(c, state, f->picture.f->sample_aspect_ratio.num, 0);
947
4820
    put_symbol(c, state, f->picture.f->sample_aspect_ratio.den, 0);
948
4820
    if (f->version > 3) {
949
        put_rac(c, state, fs->slice_coding_mode == 1);
950
        if (fs->slice_coding_mode == 1)
951
            ff_ffv1_clear_slice_state(f, fs);
952
        put_symbol(c, state, fs->slice_coding_mode, 0);
953
        if (fs->slice_coding_mode != 1) {
954
            put_symbol(c, state, fs->slice_rct_by_coef, 0);
955
            put_symbol(c, state, fs->slice_rct_ry_coef, 0);
956
        }
957
    }
958
4820
}
959
960
static void choose_rct_params(FFV1Context *fs, const uint8_t *src[3], const int stride[3], int w, int h)
961
{
962
#define NB_Y_COEFF 15
963
    static const int rct_y_coeff[15][2] = {
964
        {0, 0}, //      4G
965
        {1, 1}, //  R + 2G + B
966
        {2, 2}, // 2R      + 2B
967
        {0, 2}, //      2G + 2B
968
        {2, 0}, // 2R + 2G
969
        {4, 0}, // 4R
970
        {0, 4}, //           4B
971
972
        {0, 3}, //      1G + 3B
973
        {3, 0}, // 3R + 1G
974
        {3, 1}, // 3R      +  B
975
        {1, 3}, //  R      + 3B
976
        {1, 2}, //  R +  G + 2B
977
        {2, 1}, // 2R +  G +  B
978
        {0, 1}, //      3G +  B
979
        {1, 0}, //  R + 3G
980
    };
981
982
    int stat[NB_Y_COEFF] = {0};
983
    int x, y, i, p, best;
984
    int16_t *sample[3];
985
    int lbd = fs->bits_per_raw_sample <= 8;
986
987
    for (y = 0; y < h; y++) {
988
        int lastr=0, lastg=0, lastb=0;
989
        for (p = 0; p < 3; p++)
990
            sample[p] = fs->sample_buffer + p*w;
991
992
        for (x = 0; x < w; x++) {
993
            int b, g, r;
994
            int ab, ag, ar;
995
            if (lbd) {
996
                unsigned v = *((const uint32_t*)(src[0] + x*4 + stride[0]*y));
997
                b =  v        & 0xFF;
998
                g = (v >>  8) & 0xFF;
999
                r = (v >> 16) & 0xFF;
1000
            } else {
1001
                b = *((const uint16_t*)(src[0] + x*2 + stride[0]*y));
1002
                g = *((const uint16_t*)(src[1] + x*2 + stride[1]*y));
1003
                r = *((const uint16_t*)(src[2] + x*2 + stride[2]*y));
1004
            }
1005
1006
            ar = r - lastr;
1007
            ag = g - lastg;
1008
            ab = b - lastb;
1009
            if (x && y) {
1010
                int bg = ag - sample[0][x];
1011
                int bb = ab - sample[1][x];
1012
                int br = ar - sample[2][x];
1013
1014
                br -= bg;
1015
                bb -= bg;
1016
1017
                for (i = 0; i<NB_Y_COEFF; i++) {
1018
                    stat[i] += FFABS(bg + ((br*rct_y_coeff[i][0] + bb*rct_y_coeff[i][1])>>2));
1019
                }
1020
1021
            }
1022
            sample[0][x] = ag;
1023
            sample[1][x] = ab;
1024
            sample[2][x] = ar;
1025
1026
            lastr = r;
1027
            lastg = g;
1028
            lastb = b;
1029
        }
1030
    }
1031
1032
    best = 0;
1033
    for (i=1; i<NB_Y_COEFF; i++) {
1034
        if (stat[i] < stat[best])
1035
            best = i;
1036
    }
1037
1038
    fs->slice_rct_by_coef = rct_y_coeff[best][1];
1039
    fs->slice_rct_ry_coef = rct_y_coeff[best][0];
1040
}
1041
1042
5020
static int encode_slice(AVCodecContext *c, void *arg)
1043
{
1044
5020
    FFV1Context *fs  = *(void **)arg;
1045
5020
    FFV1Context *f   = fs->avctx->priv_data;
1046
5020
    int width        = fs->slice_width;
1047
5020
    int height       = fs->slice_height;
1048
5020
    int x            = fs->slice_x;
1049
5020
    int y            = fs->slice_y;
1050
5020
    const AVFrame *const p = f->picture.f;
1051
5020
    const int ps     = av_pix_fmt_desc_get(c->pix_fmt)->comp[0].step;
1052
    int ret;
1053
5020
    RangeCoder c_bak = fs->c;
1054
20080
    const uint8_t *planes[4] = {p->data[0] + ps*x + y*p->linesize[0],
1055
5020
                                p->data[1] ? p->data[1] + ps*x + y*p->linesize[1] : NULL,
1056
5020
                                p->data[2] ? p->data[2] + ps*x + y*p->linesize[2] : NULL,
1057
5020
                                p->data[3] ? p->data[3] + ps*x + y*p->linesize[3] : NULL};
1058
1059
5020
    fs->slice_coding_mode = 0;
1060
5020
    if (f->version > 3) {
1061
        choose_rct_params(fs, planes, p->linesize, width, height);
1062
    } else {
1063
5020
        fs->slice_rct_by_coef = 1;
1064
5020
        fs->slice_rct_ry_coef = 1;
1065
    }
1066
1067
5020
retry:
1068
5020
    if (f->key_frame)
1069
504
        ff_ffv1_clear_slice_state(f, fs);
1070
5020
    if (f->version > 2) {
1071
4820
        encode_slice_header(f, fs);
1072
    }
1073
5020
    if (fs->ac == AC_GOLOMB_RICE) {
1074

2600
        fs->ac_byte_count = f->version > 2 || (!x && !y) ? ff_rac_terminate(&fs->c, f->version > 2) : 0;
1075
2600
        init_put_bits(&fs->pb,
1076
2600
                      fs->c.bytestream_start + fs->ac_byte_count,
1077
2600
                      fs->c.bytestream_end - fs->c.bytestream_start - fs->ac_byte_count);
1078
    }
1079
1080

8440
    if (f->colorspace == 0 && c->pix_fmt != AV_PIX_FMT_YA8) {
1081
3420
        const int chroma_width  = AV_CEIL_RSHIFT(width,  f->chroma_h_shift);
1082
3420
        const int chroma_height = AV_CEIL_RSHIFT(height, f->chroma_v_shift);
1083
3420
        const int cx            = x >> f->chroma_h_shift;
1084
3420
        const int cy            = y >> f->chroma_v_shift;
1085
1086
3420
        ret = encode_plane(fs, p->data[0] + ps*x + y*p->linesize[0], width, height, p->linesize[0], 0, 1);
1087
1088
3420
        if (f->chroma_planes) {
1089
3420
            ret |= encode_plane(fs, p->data[1] + ps*cx+cy*p->linesize[1], chroma_width, chroma_height, p->linesize[1], 1, 1);
1090
3420
            ret |= encode_plane(fs, p->data[2] + ps*cx+cy*p->linesize[2], chroma_width, chroma_height, p->linesize[2], 1, 1);
1091
        }
1092
3420
        if (fs->transparency)
1093
            ret |= encode_plane(fs, p->data[3] + ps*x + y*p->linesize[3], width, height, p->linesize[3], 2, 1);
1094
1600
    } else if (c->pix_fmt == AV_PIX_FMT_YA8) {
1095
        ret  = encode_plane(fs, p->data[0] +     ps*x + y*p->linesize[0], width, height, p->linesize[0], 0, 2);
1096
        ret |= encode_plane(fs, p->data[0] + 1 + ps*x + y*p->linesize[0], width, height, p->linesize[0], 1, 2);
1097
1600
    } else if (f->use32bit) {
1098
800
        ret = encode_rgb_frame32(fs, planes, width, height, p->linesize);
1099
    } else {
1100
800
        ret = encode_rgb_frame(fs, planes, width, height, p->linesize);
1101
    }
1102
5020
    emms_c();
1103
1104
5020
    if (ret < 0) {
1105
        av_assert0(fs->slice_coding_mode == 0);
1106
        if (fs->version < 4 || !fs->ac) {
1107
            av_log(c, AV_LOG_ERROR, "Buffer too small\n");
1108
            return ret;
1109
        }
1110
        av_log(c, AV_LOG_DEBUG, "Coding slice as PCM\n");
1111
        fs->slice_coding_mode = 1;
1112
        fs->c = c_bak;
1113
        goto retry;
1114
    }
1115
1116
5020
    return 0;
1117
}
1118
1119
1434
static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
1120
                        const AVFrame *pict, int *got_packet)
1121
{
1122
1434
    FFV1Context *f      = avctx->priv_data;
1123
1434
    RangeCoder *const c = &f->slice_context[0]->c;
1124
1434
    AVFrame *const p    = f->picture.f;
1125
1434
    uint8_t keystate    = 128;
1126
    uint8_t *buf_p;
1127
    int i, ret;
1128
1434
    int64_t maxsize =   AV_INPUT_BUFFER_MIN_SIZE
1129
1434
                      + avctx->width*avctx->height*37LL*4;
1130
1131
1434
    if(!pict) {
1132
29
        if (avctx->flags & AV_CODEC_FLAG_PASS1) {
1133
            int j, k, m;
1134
            char *p   = avctx->stats_out;
1135
            char *end = p + STATS_OUT_SIZE;
1136
1137
            memset(f->rc_stat, 0, sizeof(f->rc_stat));
1138
            for (i = 0; i < f->quant_table_count; i++)
1139
                memset(f->rc_stat2[i], 0, f->context_count[i] * sizeof(*f->rc_stat2[i]));
1140
1141
            av_assert0(f->slice_count == f->max_slice_count);
1142
            for (j = 0; j < f->slice_count; j++) {
1143
                FFV1Context *fs = f->slice_context[j];
1144
                for (i = 0; i < 256; i++) {
1145
                    f->rc_stat[i][0] += fs->rc_stat[i][0];
1146
                    f->rc_stat[i][1] += fs->rc_stat[i][1];
1147
                }
1148
                for (i = 0; i < f->quant_table_count; i++) {
1149
                    for (k = 0; k < f->context_count[i]; k++)
1150
                        for (m = 0; m < 32; m++) {
1151
                            f->rc_stat2[i][k][m][0] += fs->rc_stat2[i][k][m][0];
1152
                            f->rc_stat2[i][k][m][1] += fs->rc_stat2[i][k][m][1];
1153
                        }
1154
                }
1155
            }
1156
1157
            for (j = 0; j < 256; j++) {
1158
                snprintf(p, end - p, "%" PRIu64 " %" PRIu64 " ",
1159
                        f->rc_stat[j][0], f->rc_stat[j][1]);
1160
                p += strlen(p);
1161
            }
1162
            snprintf(p, end - p, "\n");
1163
1164
            for (i = 0; i < f->quant_table_count; i++) {
1165
                for (j = 0; j < f->context_count[i]; j++)
1166
                    for (m = 0; m < 32; m++) {
1167
                        snprintf(p, end - p, "%" PRIu64 " %" PRIu64 " ",
1168
                                f->rc_stat2[i][j][m][0], f->rc_stat2[i][j][m][1]);
1169
                        p += strlen(p);
1170
                    }
1171
            }
1172
            snprintf(p, end - p, "%d\n", f->gob_count);
1173
        }
1174
29
        return 0;
1175
    }
1176
1177
1405
    if (f->version > 3)
1178
        maxsize = AV_INPUT_BUFFER_MIN_SIZE + avctx->width*avctx->height*3LL*4;
1179
1180
1405
    if (maxsize > INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE - 32) {
1181
        av_log(avctx, AV_LOG_WARNING, "Cannot allocate worst case packet size, the encoding could fail\n");
1182
        maxsize = INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE - 32;
1183
    }
1184
1185
1405
    if ((ret = ff_alloc_packet2(avctx, pkt, maxsize, 0)) < 0)
1186
        return ret;
1187
1188
1405
    ff_init_range_encoder(c, pkt->data, pkt->size);
1189
1405
    ff_build_rac_states(c, 0.05 * (1LL << 32), 256 - 8);
1190
1191
1405
    av_frame_unref(p);
1192
1405
    if ((ret = av_frame_ref(p, pict)) < 0)
1193
        return ret;
1194
#if FF_API_CODED_FRAME
1195
FF_DISABLE_DEPRECATION_WARNINGS
1196
1405
    avctx->coded_frame->pict_type = AV_PICTURE_TYPE_I;
1197
FF_ENABLE_DEPRECATION_WARNINGS
1198
#endif
1199
1200

1405
    if (avctx->gop_size == 0 || f->picture_number % avctx->gop_size == 0) {
1201
141
        put_rac(c, &keystate, 1);
1202
141
        f->key_frame = 1;
1203
141
        f->gob_count++;
1204
141
        write_header(f);
1205
    } else {
1206
1264
        put_rac(c, &keystate, 0);
1207
1264
        f->key_frame = 0;
1208
    }
1209
1210
1405
    if (f->ac == AC_RANGE_CUSTOM_TAB) {
1211
        int i;
1212
154880
        for (i = 1; i < 256; i++) {
1213
154275
            c->one_state[i]        = f->state_transition[i];
1214
154275
            c->zero_state[256 - i] = 256 - c->one_state[i];
1215
        }
1216
    }
1217
1218
6425
    for (i = 0; i < f->slice_count; i++) {
1219
5020
        FFV1Context *fs = f->slice_context[i];
1220
5020
        uint8_t *start  = pkt->data + pkt->size * (int64_t)i / f->slice_count;
1221
5020
        int len         = pkt->size / f->slice_count;
1222
5020
        if (i) {
1223
3615
            ff_init_range_encoder(&fs->c, start, len);
1224
        } else {
1225
1405
            av_assert0(fs->c.bytestream_end >= fs->c.bytestream_start + len);
1226
1405
            av_assert0(fs->c.bytestream < fs->c.bytestream_start + len);
1227
1405
            fs->c.bytestream_end = fs->c.bytestream_start + len;
1228
        }
1229
    }
1230
1405
    avctx->execute(avctx, encode_slice, &f->slice_context[0], NULL,
1231
                   f->slice_count, sizeof(void *));
1232
1233
1405
    buf_p = pkt->data;
1234
6425
    for (i = 0; i < f->slice_count; i++) {
1235
5020
        FFV1Context *fs = f->slice_context[i];
1236
        int bytes;
1237
1238
5020
        if (fs->ac != AC_GOLOMB_RICE) {
1239
2420
            bytes = ff_rac_terminate(&fs->c, 1);
1240
        } else {
1241
2600
            flush_put_bits(&fs->pb); // FIXME: nicer padding
1242
2600
            bytes = fs->ac_byte_count + put_bytes_output(&fs->pb);
1243
        }
1244

5020
        if (i > 0 || f->version > 2) {
1245
4820
            av_assert0(bytes < pkt->size / f->slice_count);
1246
4820
            memmove(buf_p, fs->c.bytestream_start, bytes);
1247
4820
            av_assert0(bytes < (1 << 24));
1248
4820
            AV_WB24(buf_p + bytes, bytes);
1249
4820
            bytes += 3;
1250
        }
1251
5020
        if (f->ec) {
1252
            unsigned v;
1253
4820
            buf_p[bytes++] = 0;
1254
4820
            v = av_crc(av_crc_get_table(AV_CRC_32_IEEE), 0, buf_p, bytes);
1255
4820
            AV_WL32(buf_p + bytes, v);
1256
4820
            bytes += 4;
1257
        }
1258
5020
        buf_p += bytes;
1259
    }
1260
1261
1405
    if (avctx->flags & AV_CODEC_FLAG_PASS1)
1262
        avctx->stats_out[0] = '\0';
1263
1264
#if FF_API_CODED_FRAME
1265
FF_DISABLE_DEPRECATION_WARNINGS
1266
1405
    avctx->coded_frame->key_frame = f->key_frame;
1267
FF_ENABLE_DEPRECATION_WARNINGS
1268
#endif
1269
1270
1405
    f->picture_number++;
1271
1405
    pkt->size   = buf_p - pkt->data;
1272
1405
    pkt->pts    =
1273
1405
    pkt->dts    = pict->pts;
1274
1405
    pkt->flags |= AV_PKT_FLAG_KEY * f->key_frame;
1275
1405
    *got_packet = 1;
1276
1277
1405
    return 0;
1278
}
1279
1280
29
static av_cold int encode_close(AVCodecContext *avctx)
1281
{
1282
29
    ff_ffv1_close(avctx);
1283
29
    return 0;
1284
}
1285
1286
#define OFFSET(x) offsetof(FFV1Context, x)
1287
#define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
1288
static const AVOption options[] = {
1289
    { "slicecrc", "Protect slices with CRCs", OFFSET(ec), AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, VE },
1290
    { "coder", "Coder type", OFFSET(ac), AV_OPT_TYPE_INT,
1291
            { .i64 = 0 }, -2, 2, VE, "coder" },
1292
        { "rice", "Golomb rice", 0, AV_OPT_TYPE_CONST,
1293
            { .i64 = AC_GOLOMB_RICE }, INT_MIN, INT_MAX, VE, "coder" },
1294
        { "range_def", "Range with default table", 0, AV_OPT_TYPE_CONST,
1295
            { .i64 = AC_RANGE_DEFAULT_TAB_FORCE }, INT_MIN, INT_MAX, VE, "coder" },
1296
        { "range_tab", "Range with custom table", 0, AV_OPT_TYPE_CONST,
1297
            { .i64 = AC_RANGE_CUSTOM_TAB }, INT_MIN, INT_MAX, VE, "coder" },
1298
        { "ac", "Range with custom table (the ac option exists for compatibility and is deprecated)", 0, AV_OPT_TYPE_CONST,
1299
            { .i64 = 1 }, INT_MIN, INT_MAX, VE, "coder" },
1300
    { "context", "Context model", OFFSET(context_model), AV_OPT_TYPE_INT,
1301
            { .i64 = 0 }, 0, 1, VE },
1302
1303
    { NULL }
1304
};
1305
1306
static const AVClass ffv1_class = {
1307
    .class_name = "ffv1 encoder",
1308
    .item_name  = av_default_item_name,
1309
    .option     = options,
1310
    .version    = LIBAVUTIL_VERSION_INT,
1311
};
1312
1313
#if FF_API_CODER_TYPE
1314
static const AVCodecDefault ffv1_defaults[] = {
1315
    { "coder", "-1" },
1316
    { NULL },
1317
};
1318
#endif
1319
1320
AVCodec ff_ffv1_encoder = {
1321
    .name           = "ffv1",
1322
    .long_name      = NULL_IF_CONFIG_SMALL("FFmpeg video codec #1"),
1323
    .type           = AVMEDIA_TYPE_VIDEO,
1324
    .id             = AV_CODEC_ID_FFV1,
1325
    .priv_data_size = sizeof(FFV1Context),
1326
    .init           = encode_init,
1327
    .encode2        = encode_frame,
1328
    .close          = encode_close,
1329
    .capabilities   = AV_CODEC_CAP_SLICE_THREADS | AV_CODEC_CAP_DELAY,
1330
    .pix_fmts       = (const enum AVPixelFormat[]) {
1331
        AV_PIX_FMT_YUV420P,   AV_PIX_FMT_YUVA420P,  AV_PIX_FMT_YUVA422P,  AV_PIX_FMT_YUV444P,
1332
        AV_PIX_FMT_YUVA444P,  AV_PIX_FMT_YUV440P,   AV_PIX_FMT_YUV422P,   AV_PIX_FMT_YUV411P,
1333
        AV_PIX_FMT_YUV410P,   AV_PIX_FMT_0RGB32,    AV_PIX_FMT_RGB32,     AV_PIX_FMT_YUV420P16,
1334
        AV_PIX_FMT_YUV422P16, AV_PIX_FMT_YUV444P16, AV_PIX_FMT_YUV444P9,  AV_PIX_FMT_YUV422P9,
1335
        AV_PIX_FMT_YUV420P9,  AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10,
1336
        AV_PIX_FMT_YUV420P12, AV_PIX_FMT_YUV422P12, AV_PIX_FMT_YUV444P12,
1337
        AV_PIX_FMT_YUVA444P16, AV_PIX_FMT_YUVA422P16, AV_PIX_FMT_YUVA420P16,
1338
        AV_PIX_FMT_YUVA444P10, AV_PIX_FMT_YUVA422P10, AV_PIX_FMT_YUVA420P10,
1339
        AV_PIX_FMT_YUVA444P9, AV_PIX_FMT_YUVA422P9, AV_PIX_FMT_YUVA420P9,
1340
        AV_PIX_FMT_GRAY16,    AV_PIX_FMT_GRAY8,     AV_PIX_FMT_GBRP9,     AV_PIX_FMT_GBRP10,
1341
        AV_PIX_FMT_GBRP12,    AV_PIX_FMT_GBRP14,
1342
        AV_PIX_FMT_GBRAP10, AV_PIX_FMT_GBRAP12,
1343
        AV_PIX_FMT_YA8,
1344
        AV_PIX_FMT_GRAY10, AV_PIX_FMT_GRAY12,
1345
        AV_PIX_FMT_GBRP16, AV_PIX_FMT_RGB48,
1346
        AV_PIX_FMT_GBRAP16, AV_PIX_FMT_RGBA64,
1347
        AV_PIX_FMT_GRAY9,
1348
        AV_PIX_FMT_YUV420P14, AV_PIX_FMT_YUV422P14, AV_PIX_FMT_YUV444P14,
1349
        AV_PIX_FMT_YUV440P10, AV_PIX_FMT_YUV440P12,
1350
        AV_PIX_FMT_NONE
1351
1352
    },
1353
#if FF_API_CODER_TYPE
1354
    .defaults       = ffv1_defaults,
1355
#endif
1356
    .priv_class     = &ffv1_class,
1357
    .caps_internal  = FF_CODEC_CAP_INIT_CLEANUP,
1358
};