GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavcodec/ffv1enc.c Lines: 388 706 55.0 %
Date: 2019-11-18 18:00:01 Branches: 231 552 41.8 %

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
#include "libavutil/timer.h"
35
36
#include "avcodec.h"
37
#include "internal.h"
38
#include "put_bits.h"
39
#include "rangecoder.h"
40
#include "golomb.h"
41
#include "mathops.h"
42
#include "ffv1.h"
43
44
static const int8_t quant5_10bit[256] = {
45
     0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  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,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,
48
     1,  1,  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, -2,
57
    -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -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, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
60
    -1, -1, -1, -1, -1, -1, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0,
61
};
62
63
static const int8_t quant5[256] = {
64
     0,  1,  1,  1,  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, -2, -2, -2,
79
    -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -1, -1, -1,
80
};
81
82
static const int8_t quant9_10bit[256] = {
83
     0,  0,  0,  0,  0,  1,  1,  1,  1,  1,  1,  1,  1,  2,  2,  2,
84
     2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  3,  3,  3,  3,  3,
85
     3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,
86
     3,  3,  3,  3,  3,  3,  3,  3,  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, -4, -4, -4, -4, -4, -4, -4,
95
    -4, -4, -4, -4, -4, -4, -4, -4, -4, -3, -3, -3, -3, -3, -3, -3,
96
    -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3,
97
    -3, -3, -3, -3, -3, -3, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
98
    -2, -2, -2, -2, -1, -1, -1, -1, -1, -1, -1, -1, -0, -0, -0, -0,
99
};
100
101
static const int8_t quant11[256] = {
102
     0,  1,  2,  2,  2,  3,  3,  3,  3,  3,  3,  3,  4,  4,  4,  4,
103
     4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,
104
     4,  4,  4,  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, -5, -5,
115
    -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -4, -4,
116
    -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4,
117
    -4, -4, -4, -4, -4, -3, -3, -3, -3, -3, -3, -3, -2, -2, -2, -1,
118
};
119
120
static const uint8_t ver2_state[256] = {
121
      0,  10,  10,  10,  10,  16,  16,  16, 28,   16,  16,  29,  42,  49,  20,  49,
122
     59,  25,  26,  26,  27,  31,  33,  33, 33,   34,  34,  37,  67,  38,  39,  39,
123
     40,  40,  41,  79,  43,  44,  45,  45, 48,   48,  64,  50,  51,  52,  88,  52,
124
     53,  74,  55,  57,  58,  58,  74,  60, 101,  61,  62,  84,  66,  66,  68,  69,
125
     87,  82,  71,  97,  73,  73,  82,  75, 111,  77,  94,  78,  87,  81,  83,  97,
126
     85,  83,  94,  86,  99,  89,  90,  99, 111,  92,  93,  134, 95,  98, 105,  98,
127
    105, 110, 102, 108, 102, 118, 103, 106, 106, 113, 109, 112, 114, 112, 116, 125,
128
    115, 116, 117, 117, 126, 119, 125, 121, 121, 123, 145, 124, 126, 131, 127, 129,
129
    165, 130, 132, 138, 133, 135, 145, 136, 137, 139, 146, 141, 143, 142, 144, 148,
130
    147, 155, 151, 149, 151, 150, 152, 157, 153, 154, 156, 168, 158, 162, 161, 160,
131
    172, 163, 169, 164, 166, 184, 167, 170, 177, 174, 171, 173, 182, 176, 180, 178,
132
    175, 189, 179, 181, 186, 183, 192, 185, 200, 187, 191, 188, 190, 197, 193, 196,
133
    197, 194, 195, 196, 198, 202, 199, 201, 210, 203, 207, 204, 205, 206, 208, 214,
134
    209, 211, 221, 212, 213, 215, 224, 216, 217, 218, 219, 220, 222, 228, 223, 225,
135
    226, 224, 227, 229, 240, 230, 231, 232, 233, 234, 235, 236, 238, 239, 237, 242,
136
    241, 243, 242, 244, 245, 246, 247, 248, 249, 250, 251, 252, 252, 253, 254, 255,
137
};
138
139
static void find_best_state(uint8_t best_state[256][256],
140
                            const uint8_t one_state[256])
141
{
142
    int i, j, k, m;
143
    double l2tab[256];
144
145
    for (i = 1; i < 256; i++)
146
        l2tab[i] = log2(i / 256.0);
147
148
    for (i = 0; i < 256; i++) {
149
        double best_len[256];
150
        double p = i / 256.0;
151
152
        for (j = 0; j < 256; j++)
153
            best_len[j] = 1 << 30;
154
155
        for (j = FFMAX(i - 10, 1); j < FFMIN(i + 11, 256); j++) {
156
            double occ[256] = { 0 };
157
            double len      = 0;
158
            occ[j] = 1.0;
159
160
            if (!one_state[j])
161
                continue;
162
163
            for (k = 0; k < 256; k++) {
164
                double newocc[256] = { 0 };
165
                for (m = 1; m < 256; m++)
166
                    if (occ[m]) {
167
                        len -=occ[m]*(     p *l2tab[    m]
168
                                      + (1-p)*l2tab[256-m]);
169
                    }
170
                if (len < best_len[k]) {
171
                    best_len[k]      = len;
172
                    best_state[i][k] = j;
173
                }
174
                for (m = 1; m < 256; m++)
175
                    if (occ[m]) {
176
                        newocc[      one_state[      m]] += occ[m] * p;
177
                        newocc[256 - one_state[256 - m]] += occ[m] * (1 - p);
178
                    }
179
                memcpy(occ, newocc, sizeof(occ));
180
            }
181
        }
182
    }
183
}
184
185
122164972
static av_always_inline av_flatten void put_symbol_inline(RangeCoder *c,
186
                                                          uint8_t *state, int v,
187
                                                          int is_signed,
188
                                                          uint64_t rc_stat[256][2],
189
                                                          uint64_t rc_stat2[32][2])
190
{
191
    int i;
192
193
#define put_rac(C, S, B)                        \
194
    do {                                        \
195
        if (rc_stat) {                          \
196
            rc_stat[*(S)][B]++;                 \
197
            rc_stat2[(S) - state][B]++;         \
198
        }                                       \
199
        put_rac(C, S, B);                       \
200
    } while (0)
201
202
122164972
    if (v) {
203
70569066
        const int a = FFABS(v);
204
70569066
        const int e = av_log2(a);
205
70569066
        put_rac(c, state + 0, 0);
206
70569066
        if (e <= 9) {
207
272043555
            for (i = 0; i < e; i++)
208
226436667
                put_rac(c, state + 1 + i, 1);  // 1..10
209
45606888
            put_rac(c, state + 1 + i, 0);
210
211
272043555
            for (i = e - 1; i >= 0; i--)
212
226436667
                put_rac(c, state + 22 + i, (a >> i) & 1);  // 22..31
213
214
45606888
            if (is_signed)
215
45591192
                put_rac(c, state + 11 + e, v < 0);  // 11..21
216
        } else {
217
294732467
            for (i = 0; i < e; i++)
218


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


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

28
    if (avctx->slices == 0 && avctx->level < 0 && avctx->width * avctx->height > 720*576)
534
        s->version = FFMAX(s->version, 2);
535
536

28
    if (avctx->level <= 0 && s->version == 2) {
537
4
        s->version = 3;
538
    }
539

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

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




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

4
        if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
592
4
            s->bits_per_raw_sample = 10;
593
    case AV_PIX_FMT_GRAY12:
594
    case AV_PIX_FMT_YUV444P12:
595
    case AV_PIX_FMT_YUV440P12:
596
    case AV_PIX_FMT_YUV420P12:
597
    case AV_PIX_FMT_YUV422P12:
598

4
        if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
599
            s->bits_per_raw_sample = 12;
600
    case AV_PIX_FMT_YUV444P14:
601
    case AV_PIX_FMT_YUV420P14:
602
    case AV_PIX_FMT_YUV422P14:
603

4
        if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
604
            s->bits_per_raw_sample = 14;
605
4
        s->packed_at_lsb = 1;
606
8
    case AV_PIX_FMT_GRAY16:
607
    case AV_PIX_FMT_YUV444P16:
608
    case AV_PIX_FMT_YUV422P16:
609
    case AV_PIX_FMT_YUV420P16:
610
    case AV_PIX_FMT_YUVA444P16:
611
    case AV_PIX_FMT_YUVA422P16:
612
    case AV_PIX_FMT_YUVA420P16:
613

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

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

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

24
        s->num_v_slices = (avctx->width > 352 || avctx->height > 288 || !avctx->slices) ? 2 : 1;
880
881
24
        s->num_v_slices = FFMIN(s->num_v_slices, max_v_slices);
882
883
28
        for (; s->num_v_slices < 32; s->num_v_slices++) {
884
32
            for (s->num_h_slices = s->num_v_slices; s->num_h_slices < 2*s->num_v_slices; s->num_h_slices++) {
885
28
                int maxw = (avctx->width  + s->num_h_slices - 1) / s->num_h_slices;
886
28
                int maxh = (avctx->height + s->num_v_slices - 1) / s->num_v_slices;
887

28
                if (s->num_h_slices > max_h_slices || s->num_v_slices > max_v_slices)
888
                    continue;
889
28
                if (maxw * maxh * (int64_t)(s->bits_per_raw_sample+1) * plane_count > 8<<24)
890
                    continue;
891

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

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

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

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

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