GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavcodec/ffv1enc.c Lines: 388 706 55.0 %
Date: 2020-04-04 00:26:16 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
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
122164972
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
122164972
    if (v) {
202
70569066
        const int a = FFABS(v);
203
70569066
        const int e = av_log2(a);
204
70569066
        put_rac(c, state + 0, 0);
205
70569066
        if (e <= 9) {
206
272043555
            for (i = 0; i < e; i++)
207
226436667
                put_rac(c, state + 1 + i, 1);  // 1..10
208
45606888
            put_rac(c, state + 1 + i, 0);
209
210
272043555
            for (i = e - 1; i >= 0; i--)
211
226436667
                put_rac(c, state + 22 + i, (a >> i) & 1);  // 22..31
212
213
45606888
            if (is_signed)
214
45591192
                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
51595906
        put_rac(c, state + 0, 1);
228
    }
229
#undef put_rac
230
122164972
}
231
232
47972
static av_noinline void put_symbol(RangeCoder *c, uint8_t *state,
233
                                   int v, int is_signed)
234
{
235
47972
    put_symbol_inline(c, state, v, is_signed, NULL, NULL);
236
47972
}
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
10200
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
10200
    const int ring_size = s->context_model ? 3 : 2;
278
    int16_t *sample[3];
279
10200
    s->run_index = 0;
280
281
10200
    memset(s->sample_buffer, 0, ring_size * (w + 6) * sizeof(*s->sample_buffer));
282
283
998400
    for (y = 0; y < h; y++) {
284
2964600
        for (i = 0; i < ring_size; i++)
285
1976400
            sample[i] = s->sample_buffer + (w + 6) * ((h + i - y) % ring_size) + 3;
286
287
988200
        sample[0][-1]= sample[1][0  ];
288
988200
        sample[1][ w]= sample[1][w-1];
289
988200
        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
538800
            if (s->packed_at_lsb) {
296
30801200
                for (x = 0; x < w; x++) {
297
30531800
                    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
538800
            if((ret = encode_line(s, w, sample, plane_index, s->bits_per_raw_sample)) < 0)
305
                return ret;
306
        }
307
    }
308
10200
    return 0;
309
}
310
311
340
static void write_quant_table(RangeCoder *c, int16_t *quant_table)
312
{
313
340
    int last = 0;
314
    int i;
315
    uint8_t state[CONTEXT_SIZE];
316
340
    memset(state, 128, sizeof(state));
317
318
43520
    for (i = 1; i < 128; i++)
319
43180
        if (quant_table[i] != quant_table[i - 1]) {
320
984
            put_symbol(c, state, i - last - 1, 0);
321
984
            last = i;
322
        }
323
340
    put_symbol(c, state, i - last - 1, 0);
324
340
}
325
326
68
static void write_quant_tables(RangeCoder *c,
327
                               int16_t quant_table[MAX_CONTEXT_INPUTS][256])
328
{
329
    int i;
330
408
    for (i = 0; i < 5; i++)
331
340
        write_quant_table(c, quant_table[i]);
332
68
}
333
334
48
static int contains_non_128(uint8_t (*initial_state)[CONTEXT_SIZE],
335
                            int nb_contexts)
336
{
337
48
    if (!initial_state)
338
        return 0;
339
197544
    for (int i = 0; i < nb_contexts; i++)
340
6517368
        for (int j = 0; j < CONTEXT_SIZE; j++)
341
6319872
            if (initial_state[i][j] != 128)
342
                return 1;
343
48
    return 0;
344
}
345
346
140
static void write_header(FFV1Context *f)
347
{
348
    uint8_t state[CONTEXT_SIZE];
349
    int i, j;
350
140
    RangeCoder *const c = &f->slice_context[0]->c;
351
352
140
    memset(state, 128, sizeof(state));
353
354
140
    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
120
    } 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
140
}
392
393
24
static int write_extradata(FFV1Context *f)
394
{
395
24
    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
24
    memset(state2, 128, sizeof(state2));
402
24
    memset(state, 128, sizeof(state));
403
404
24
    f->avctx->extradata_size = 10000 + 4 +
405
                                    (11 * 11 * 5 * 5 * 5 + 11 * 11 * 11) * 32;
406
24
    f->avctx->extradata = av_malloc(f->avctx->extradata_size + AV_INPUT_BUFFER_PADDING_SIZE);
407
24
    if (!f->avctx->extradata)
408
        return AVERROR(ENOMEM);
409
24
    ff_init_range_encoder(c, f->avctx->extradata, f->avctx->extradata_size);
410
24
    ff_build_rac_states(c, 0.05 * (1LL << 32), 256 - 8);
411
412
24
    put_symbol(c, state, f->version, 0);
413
24
    if (f->version > 2) {
414
24
        if (f->version == 3) {
415
24
            f->micro_version = 4;
416
        } else if (f->version == 4)
417
            f->micro_version = 2;
418
24
        put_symbol(c, state, f->micro_version, 0);
419
    }
420
421
24
    put_symbol(c, state, f->ac, 0);
422
24
    if (f->ac == AC_RANGE_CUSTOM_TAB)
423
3072
        for (i = 1; i < 256; i++)
424
3060
            put_symbol(c, state, f->state_transition[i] - c->one_state[i], 1);
425
426
24
    put_symbol(c, state, f->colorspace, 0); // YUV cs type
427
24
    put_symbol(c, state, f->bits_per_raw_sample, 0);
428
24
    put_rac(c, state, f->chroma_planes);
429
24
    put_symbol(c, state, f->chroma_h_shift, 0);
430
24
    put_symbol(c, state, f->chroma_v_shift, 0);
431
24
    put_rac(c, state, f->transparency);
432
24
    put_symbol(c, state, f->num_h_slices - 1, 0);
433
24
    put_symbol(c, state, f->num_v_slices - 1, 0);
434
435
24
    put_symbol(c, state, f->quant_table_count, 0);
436
72
    for (i = 0; i < f->quant_table_count; i++)
437
48
        write_quant_tables(c, f->quant_tables[i]);
438
439
72
    for (i = 0; i < f->quant_table_count; i++) {
440
48
        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
48
            put_rac(c, state, 0);
450
        }
451
    }
452
453
24
    if (f->version > 2) {
454
24
        put_symbol(c, state, f->ec, 0);
455
24
        put_symbol(c, state, f->intra = (f->avctx->gop_size < 2), 0);
456
    }
457
458
24
    f->avctx->extradata_size = ff_rac_terminate(c, 0);
459
24
    v = av_crc(av_crc_get_table(AV_CRC_32_IEEE), 0, f->avctx->extradata, f->avctx->extradata_size);
460
24
    AV_WL32(f->avctx->extradata + f->avctx->extradata_size, v);
461
24
    f->avctx->extradata_size += 4;
462
463
24
    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
28
static av_cold int encode_init(AVCodecContext *avctx)
515
{
516
28
    FFV1Context *s = avctx->priv_data;
517
28
    const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(avctx->pix_fmt);
518
    int i, j, k, m, ret;
519
520
28
    if ((ret = ff_ffv1_common_init(avctx)) < 0)
521
        return ret;
522
523
28
    s->version = 0;
524
525
28
    if ((avctx->flags & (AV_CODEC_FLAG_PASS1 | AV_CODEC_FLAG_PASS2)) ||
526
28
        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

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

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

28
    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
28
    if (s->ec < 0) {
545
28
        s->ec = (s->version >= 3);
546
    }
547
548
    // CRC requires version 3+
549
28
    if (s->ec)
550
24
        s->version = FFMAX(s->version, 3);
551
552

28
    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
28
    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
28
    if (s->ac == 1) // Compatbility with common command line usage
565
        s->ac = AC_RANGE_CUSTOM_TAB;
566
28
    else if (s->ac == AC_RANGE_DEFAULT_TAB_FORCE)
567
        s->ac = AC_RANGE_DEFAULT_TAB;
568
569
28
    s->plane_count = 3;
570




28
    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

4
        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

4
        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

4
        if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
601
            s->bits_per_raw_sample = 14;
602
4
        s->packed_at_lsb = 1;
603
8
    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

8
        if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample) {
611
4
            s->bits_per_raw_sample = 16;
612
4
        } else if (!s->bits_per_raw_sample) {
613
            s->bits_per_raw_sample = avctx->bits_per_raw_sample;
614
        }
615
8
        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
8
        s->version = FFMAX(s->version, 1);
620
20
    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
20
        s->chroma_planes = desc->nb_components < 3 ? 0 : 1;
632
20
        s->colorspace = 0;
633
20
        s->transparency = !!(desc->flags & AV_PIX_FMT_FLAG_ALPHA);
634

20
        if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
635
12
            s->bits_per_raw_sample = 8;
636
8
        else if (!s->bits_per_raw_sample)
637
            s->bits_per_raw_sample = 8;
638
20
        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
28
    av_assert0(s->bits_per_raw_sample >= 8);
698
699
28
    if (s->bits_per_raw_sample > 8) {
700
12
        if (s->ac == AC_GOLOMB_RICE) {
701
12
            av_log(avctx, AV_LOG_INFO,
702
                    "bits_per_raw_sample > 8, forcing range coder\n");
703
12
            s->ac = AC_RANGE_CUSTOM_TAB;
704
        }
705
    }
706
#if FF_API_PRIVATE_OPT
707
FF_DISABLE_DEPRECATION_WARNINGS
708
28
    if (avctx->context_model)
709
        s->context_model = avctx->context_model;
710
28
    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
28
    if (s->ac == AC_RANGE_CUSTOM_TAB) {
718
3072
        for (i = 1; i < 256; i++)
719
3060
            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
7196
    for (i = 0; i < 256; i++) {
728
7168
        s->quant_table_count = 2;
729
7168
        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
3072
            s->quant_tables[0][0][i]=           quant9_10bit[i];
740
3072
            s->quant_tables[0][1][i]=        11*quant9_10bit[i];
741
3072
            s->quant_tables[0][2][i]=     11*11*quant9_10bit[i];
742
3072
            s->quant_tables[1][0][i]=           quant9_10bit[i];
743
3072
            s->quant_tables[1][1][i]=        11*quant9_10bit[i];
744
3072
            s->quant_tables[1][2][i]=     11*11*quant5_10bit[i];
745
3072
            s->quant_tables[1][3][i]=   5*11*11*quant5_10bit[i];
746
3072
            s->quant_tables[1][4][i]= 5*5*11*11*quant5_10bit[i];
747
        }
748
    }
749
28
    s->context_count[0] = (11 * 11 * 11        + 1) / 2;
750
28
    s->context_count[1] = (11 * 11 * 5 * 5 * 5 + 1) / 2;
751
28
    memcpy(s->quant_table, s->quant_tables[s->context_model],
752
           sizeof(s->quant_table));
753
754
112
    for (i = 0; i < s->plane_count; i++) {
755
84
        PlaneContext *const p = &s->plane[i];
756
757
84
        memcpy(p->quant_table, s->quant_table, sizeof(p->quant_table));
758
84
        p->quant_table_index = s->context_model;
759
84
        p->context_count     = s->context_count[p->quant_table_index];
760
    }
761
762
28
    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
28
    avctx->coded_frame->pict_type = AV_PICTURE_TYPE_I;
768
FF_ENABLE_DEPRECATION_WARNINGS
769
#endif
770
771
28
    if (!s->transparency)
772
28
        s->plane_count = 2;
773

28
    if (!s->chroma_planes && s->version > 3)
774
        s->plane_count--;
775
776
28
    ret = av_pix_fmt_get_chroma_sub_sample (avctx->pix_fmt, &s->chroma_h_shift, &s->chroma_v_shift);
777
28
    if (ret)
778
        return ret;
779
780
28
    s->picture_number = 0;
781
782
28
    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
28
    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
28
    if (s->version > 1) {
873
24
        int plane_count = 1 + 2*s->chroma_planes + s->transparency;
874
24
        int max_h_slices = AV_CEIL_RSHIFT(avctx->width , s->chroma_h_shift);
875
24
        int max_v_slices = AV_CEIL_RSHIFT(avctx->height, s->chroma_v_shift);
876

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

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

28
                if (avctx->slices == s->num_h_slices * s->num_v_slices && avctx->slices <= MAX_SLICES || !avctx->slices)
889
24
                    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
24
slices_ok:
898
24
        if ((ret = write_extradata(s)) < 0)
899
            return ret;
900
    }
901
902
28
    if ((ret = ff_ffv1_init_slice_contexts(s)) < 0)
903
        return ret;
904
28
    s->slice_count = s->max_slice_count;
905
28
    if ((ret = ff_ffv1_init_slices_state(s)) < 0)
906
        return ret;
907
908
#define STATS_OUT_SIZE 1024 * 1024 * 6
909
28
    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
28
    return 0;
925
}
926
927
4800
static void encode_slice_header(FFV1Context *f, FFV1Context *fs)
928
{
929
4800
    RangeCoder *c = &fs->c;
930
    uint8_t state[CONTEXT_SIZE];
931
    int j;
932
4800
    memset(state, 128, sizeof(state));
933
934
4800
    put_symbol(c, state, (fs->slice_x     +1)*f->num_h_slices / f->width   , 0);
935
4800
    put_symbol(c, state, (fs->slice_y     +1)*f->num_v_slices / f->height  , 0);
936
4800
    put_symbol(c, state, (fs->slice_width +1)*f->num_h_slices / f->width -1, 0);
937
4800
    put_symbol(c, state, (fs->slice_height+1)*f->num_v_slices / f->height-1, 0);
938
14400
    for (j=0; j<f->plane_count; j++) {
939
9600
        put_symbol(c, state, f->plane[j].quant_table_index, 0);
940
9600
        av_assert0(f->plane[j].quant_table_index == f->context_model);
941
    }
942
4800
    if (!f->picture.f->interlaced_frame)
943
4800
        put_symbol(c, state, 3, 0);
944
    else
945
        put_symbol(c, state, 1 + !f->picture.f->top_field_first, 0);
946
4800
    put_symbol(c, state, f->picture.f->sample_aspect_ratio.num, 0);
947
4800
    put_symbol(c, state, f->picture.f->sample_aspect_ratio.den, 0);
948
4800
    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
4800
}
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
5000
static int encode_slice(AVCodecContext *c, void *arg)
1043
{
1044
5000
    FFV1Context *fs  = *(void **)arg;
1045
5000
    FFV1Context *f   = fs->avctx->priv_data;
1046
5000
    int width        = fs->slice_width;
1047
5000
    int height       = fs->slice_height;
1048
5000
    int x            = fs->slice_x;
1049
5000
    int y            = fs->slice_y;
1050
5000
    const AVFrame *const p = f->picture.f;
1051
5000
    const int ps     = av_pix_fmt_desc_get(c->pix_fmt)->comp[0].step;
1052
    int ret;
1053
5000
    RangeCoder c_bak = fs->c;
1054
20000
    const uint8_t *planes[4] = {p->data[0] + ps*x + y*p->linesize[0],
1055
5000
                                p->data[1] ? p->data[1] + ps*x + y*p->linesize[1] : NULL,
1056
5000
                                p->data[2] ? p->data[2] + ps*x + y*p->linesize[2] : NULL,
1057
5000
                                p->data[3] ? p->data[3] + ps*x + y*p->linesize[3] : NULL};
1058
1059
5000
    fs->slice_coding_mode = 0;
1060
5000
    if (f->version > 3) {
1061
        choose_rct_params(fs, planes, p->linesize, width, height);
1062
    } else {
1063
5000
        fs->slice_rct_by_coef = 1;
1064
5000
        fs->slice_rct_ry_coef = 1;
1065
    }
1066
1067
5000
retry:
1068
5000
    if (f->key_frame)
1069
500
        ff_ffv1_clear_slice_state(f, fs);
1070
5000
    if (f->version > 2) {
1071
4800
        encode_slice_header(f, fs);
1072
    }
1073
5000
    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

8400
    if (f->colorspace == 0 && c->pix_fmt != AV_PIX_FMT_YA8) {
1081
3400
        const int chroma_width  = AV_CEIL_RSHIFT(width,  f->chroma_h_shift);
1082
3400
        const int chroma_height = AV_CEIL_RSHIFT(height, f->chroma_v_shift);
1083
3400
        const int cx            = x >> f->chroma_h_shift;
1084
3400
        const int cy            = y >> f->chroma_v_shift;
1085
1086
3400
        ret = encode_plane(fs, p->data[0] + ps*x + y*p->linesize[0], width, height, p->linesize[0], 0, 1);
1087
1088
3400
        if (f->chroma_planes) {
1089
3400
            ret |= encode_plane(fs, p->data[1] + ps*cx+cy*p->linesize[1], chroma_width, chroma_height, p->linesize[1], 1, 1);
1090
3400
            ret |= encode_plane(fs, p->data[2] + ps*cx+cy*p->linesize[2], chroma_width, chroma_height, p->linesize[2], 1, 1);
1091
        }
1092
3400
        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
5000
    emms_c();
1103
1104
5000
    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
5000
    return 0;
1117
}
1118
1119
1456
static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
1120
                        const AVFrame *pict, int *got_packet)
1121
{
1122
1456
    FFV1Context *f      = avctx->priv_data;
1123
1456
    RangeCoder *const c = &f->slice_context[0]->c;
1124
1456
    AVFrame *const p    = f->picture.f;
1125
1456
    uint8_t keystate    = 128;
1126
    uint8_t *buf_p;
1127
    int i, ret;
1128
1456
    int64_t maxsize =   AV_INPUT_BUFFER_MIN_SIZE
1129
1456
                      + avctx->width*avctx->height*37LL*4;
1130
1131
1456
    if(!pict) {
1132
56
        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
56
        return 0;
1175
    }
1176
1177
1400
    if (f->version > 3)
1178
        maxsize = AV_INPUT_BUFFER_MIN_SIZE + avctx->width*avctx->height*3LL*4;
1179
1180
1400
    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
1400
    if ((ret = ff_alloc_packet2(avctx, pkt, maxsize, 0)) < 0)
1186
        return ret;
1187
1188
1400
    ff_init_range_encoder(c, pkt->data, pkt->size);
1189
1400
    ff_build_rac_states(c, 0.05 * (1LL << 32), 256 - 8);
1190
1191
1400
    av_frame_unref(p);
1192
1400
    if ((ret = av_frame_ref(p, pict)) < 0)
1193
        return ret;
1194
#if FF_API_CODED_FRAME
1195
FF_DISABLE_DEPRECATION_WARNINGS
1196
1400
    avctx->coded_frame->pict_type = AV_PICTURE_TYPE_I;
1197
FF_ENABLE_DEPRECATION_WARNINGS
1198
#endif
1199
1200

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

5000
        if (i > 0 || f->version > 2) {
1245
4800
            av_assert0(bytes < pkt->size / f->slice_count);
1246
4800
            memmove(buf_p, fs->c.bytestream_start, bytes);
1247
4800
            av_assert0(bytes < (1 << 24));
1248
4800
            AV_WB24(buf_p + bytes, bytes);
1249
4800
            bytes += 3;
1250
        }
1251
5000
        if (f->ec) {
1252
            unsigned v;
1253
4800
            buf_p[bytes++] = 0;
1254
4800
            v = av_crc(av_crc_get_table(AV_CRC_32_IEEE), 0, buf_p, bytes);
1255
4800
            AV_WL32(buf_p + bytes, v);
1256
4800
            bytes += 4;
1257
        }
1258
5000
        buf_p += bytes;
1259
    }
1260
1261
1400
    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
1400
    avctx->coded_frame->key_frame = f->key_frame;
1267
FF_ENABLE_DEPRECATION_WARNINGS
1268
#endif
1269
1270
1400
    f->picture_number++;
1271
1400
    pkt->size   = buf_p - pkt->data;
1272
1400
    pkt->pts    =
1273
1400
    pkt->dts    = pict->pts;
1274
1400
    pkt->flags |= AV_PKT_FLAG_KEY * f->key_frame;
1275
1400
    *got_packet = 1;
1276
1277
1400
    return 0;
1278
}
1279
1280
28
static av_cold int encode_close(AVCodecContext *avctx)
1281
{
1282
28
    ff_ffv1_close(avctx);
1283
28
    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
};