← Back to branch summary

~ubuntu-branches/ubuntu/saucy/gst-libav1.0/saucy-proposed

« back to all changes in this revision

Viewing changes to gst-libs/ext/libav/libavcodec/ffv1enc.c

  • Committer: Package Import Robot
  • Author(s): Sebastian Dröge
  • Date: 2013-07-30 09:00:15 UTC
  • mfrom: (1.1.16) (7.1.7 experimental)
  • Revision ID: package-import@ubuntu.com-20130730090015-sc1ou2yssu7q5w4e
Tags: 1.1.3-1
* New upstream development snapshot:
  + debian/control:
    - Build depend on GStreamer and gst-plugins-base >= 1.1.3.

Show diffs side-by-side

added added

removed removed

Lines of Context:
gst-libs/ext/libav/libavcodec/ffv1enc.c
 
1
/*
 
2
 * FFV1 encoder for libavcodec
 
3
 *
 
4
 * Copyright (c) 2003-2012 Michael Niedermayer <michaelni@gmx.at>
 
5
 *
 
6
 * This file is part of Libav.
 
7
 *
 
8
 * Libav 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
 * Libav 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 Libav; 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/avassert.h"
 
29
#include "libavutil/pixdesc.h"
 
30
#include "libavutil/crc.h"
 
31
#include "libavutil/opt.h"
 
32
#include "libavutil/imgutils.h"
 
33
#include "avcodec.h"
 
34
#include "internal.h"
 
35
#include "get_bits.h"
 
36
#include "put_bits.h"
 
37
#include "dsputil.h"
 
38
#include "rangecoder.h"
 
39
#include "golomb.h"
 
40
#include "mathops.h"
 
41
#include "ffv1.h"
 
42
 
 
43
static void find_best_state(uint8_t best_state[256][256],
 
44
                            const uint8_t one_state[256])
 
45
{
 
46
    int i, j, k, m;
 
47
    double l2tab[256];
 
48
 
 
49
    for (i = 1; i < 256; i++)
 
50
        l2tab[i] = log2(i / 256.0);
 
51
 
 
52
    for (i = 0; i < 256; i++) {
 
53
        double best_len[256];
 
54
        double p = i / 256.0;
 
55
 
 
56
        for (j = 0; j < 256; j++)
 
57
            best_len[j] = 1 << 30;
 
58
 
 
59
        for (j = FFMAX(i - 10, 1); j < FFMIN(i + 11, 256); j++) {
 
60
            double occ[256] = { 0 };
 
61
            double len      = 0;
 
62
            occ[j] = 1.0;
 
63
            for (k = 0; k < 256; k++) {
 
64
                double newocc[256] = { 0 };
 
65
                for (m = 1; m < 256; m++)
 
66
                    if (occ[m]) {
 
67
                        len -= occ[m] *     (p  * l2tab[m] +
 
68
                                        (1 - p) * l2tab[256 - m]);
 
69
                    }
 
70
                if (len < best_len[k]) {
 
71
                    best_len[k]      = len;
 
72
                    best_state[i][k] = j;
 
73
                }
 
74
                for (m = 0; m < 256; m++)
 
75
                    if (occ[m]) {
 
76
                        newocc[one_state[m]]             += occ[m] * p;
 
77
                        newocc[256 - one_state[256 - m]] += occ[m] * (1 - p);
 
78
                    }
 
79
                memcpy(occ, newocc, sizeof(occ));
 
80
            }
 
81
        }
 
82
    }
 
83
}
 
84
 
 
85
static av_always_inline av_flatten void put_symbol_inline(RangeCoder *c,
 
86
                                                          uint8_t *state, int v,
 
87
                                                          int is_signed,
 
88
                                                          uint64_t rc_stat[256][2],
 
89
                                                          uint64_t rc_stat2[32][2])
 
90
{
 
91
    int i;
 
92
 
 
93
#define put_rac(C, S, B)                        \
 
94
    do {                                        \
 
95
        if (rc_stat) {                          \
 
96
            rc_stat[*(S)][B]++;                 \
 
97
            rc_stat2[(S) - state][B]++;         \
 
98
        }                                       \
 
99
        put_rac(C, S, B);                       \
 
100
    } while (0)
 
101
 
 
102
    if (v) {
 
103
        const int a = FFABS(v);
 
104
        const int e = av_log2(a);
 
105
        put_rac(c, state + 0, 0);
 
106
        if (e <= 9) {
 
107
            for (i = 0; i < e; i++)
 
108
                put_rac(c, state + 1 + i, 1);  // 1..10
 
109
            put_rac(c, state + 1 + i, 0);
 
110
 
 
111
            for (i = e - 1; i >= 0; i--)
 
112
                put_rac(c, state + 22 + i, (a >> i) & 1);  // 22..31
 
113
 
 
114
            if (is_signed)
 
115
                put_rac(c, state + 11 + e, v < 0);  // 11..21
 
116
        } else {
 
117
            for (i = 0; i < e; i++)
 
118
                put_rac(c, state + 1 + FFMIN(i, 9), 1);  // 1..10
 
119
            put_rac(c, state + 1 + 9, 0);
 
120
 
 
121
            for (i = e - 1; i >= 0; i--)
 
122
                put_rac(c, state + 22 + FFMIN(i, 9), (a >> i) & 1);  // 22..31
 
123
 
 
124
            if (is_signed)
 
125
                put_rac(c, state + 11 + 10, v < 0);  // 11..21
 
126
        }
 
127
    } else {
 
128
        put_rac(c, state + 0, 1);
 
129
    }
 
130
#undef put_rac
 
131
}
 
132
 
 
133
static av_noinline void put_symbol(RangeCoder *c, uint8_t *state,
 
134
                                   int v, int is_signed)
 
135
{
 
136
    put_symbol_inline(c, state, v, is_signed, NULL, NULL);
 
137
}
 
138
 
 
139
static inline void put_vlc_symbol(PutBitContext *pb, VlcState *const state,
 
140
                                  int v, int bits)
 
141
{
 
142
    int i, k, code;
 
143
    v = fold(v - state->bias, bits);
 
144
 
 
145
    i = state->count;
 
146
    k = 0;
 
147
    while (i < state->error_sum) { // FIXME: optimize
 
148
        k++;
 
149
        i += i;
 
150
    }
 
151
 
 
152
    assert(k <= 13);
 
153
 
 
154
#if 0 // JPEG LS
 
155
    if (k == 0 && 2 * state->drift <= -state->count)
 
156
        code = v ^ (-1);
 
157
    else
 
158
        code = v;
 
159
#else
 
160
    code = v ^ ((2 * state->drift + state->count) >> 31);
 
161
#endif
 
162
 
 
163
    av_dlog(NULL, "v:%d/%d bias:%d error:%d drift:%d count:%d k:%d\n", v, code,
 
164
            state->bias, state->error_sum, state->drift, state->count, k);
 
165
    set_sr_golomb(pb, code, k, 12, bits);
 
166
 
 
167
    update_vlc_state(state, v);
 
168
}
 
169
 
 
170
static av_always_inline int encode_line(FFV1Context *s, int w,
 
171
                                        int16_t *sample[3],
 
172
                                        int plane_index, int bits)
 
173
{
 
174
    PlaneContext *const p = &s->plane[plane_index];
 
175
    RangeCoder *const c   = &s->c;
 
176
    int x;
 
177
    int run_index = s->run_index;
 
178
    int run_count = 0;
 
179
    int run_mode  = 0;
 
180
 
 
181
    if (s->ac) {
 
182
        if (c->bytestream_end - c->bytestream < w * 20) {
 
183
            av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
 
184
            return AVERROR_INVALIDDATA;
 
185
        }
 
186
    } else {
 
187
        if (s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb) >> 3) < w * 4) {
 
188
            av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
 
189
            return AVERROR_INVALIDDATA;
 
190
        }
 
191
    }
 
192
 
 
193
    for (x = 0; x < w; x++) {
 
194
        int diff, context;
 
195
 
 
196
        context = get_context(p, sample[0] + x, sample[1] + x, sample[2] + x);
 
197
        diff    = sample[0][x] - predict(sample[0] + x, sample[1] + x);
 
198
 
 
199
        if (context < 0) {
 
200
            context = -context;
 
201
            diff    = -diff;
 
202
        }
 
203
 
 
204
        diff = fold(diff, bits);
 
205
 
 
206
        if (s->ac) {
 
207
            if (s->flags & CODEC_FLAG_PASS1) {
 
208
                put_symbol_inline(c, p->state[context], diff, 1, s->rc_stat,
 
209
                                  s->rc_stat2[p->quant_table_index][context]);
 
210
            } else {
 
211
                put_symbol_inline(c, p->state[context], diff, 1, NULL, NULL);
 
212
            }
 
213
        } else {
 
214
            if (context == 0)
 
215
                run_mode = 1;
 
216
 
 
217
            if (run_mode) {
 
218
                if (diff) {
 
219
                    while (run_count >= 1 << ff_log2_run[run_index]) {
 
220
                        run_count -= 1 << ff_log2_run[run_index];
 
221
                        run_index++;
 
222
                        put_bits(&s->pb, 1, 1);
 
223
                    }
 
224
 
 
225
                    put_bits(&s->pb, 1 + ff_log2_run[run_index], run_count);
 
226
                    if (run_index)
 
227
                        run_index--;
 
228
                    run_count = 0;
 
229
                    run_mode  = 0;
 
230
                    if (diff > 0)
 
231
                        diff--;
 
232
                } else {
 
233
                    run_count++;
 
234
                }
 
235
            }
 
236
 
 
237
            av_dlog(s->avctx, "count:%d index:%d, mode:%d, x:%d pos:%d\n",
 
238
                    run_count, run_index, run_mode, x,
 
239
                    (int)put_bits_count(&s->pb));
 
240
 
 
241
            if (run_mode == 0)
 
242
                put_vlc_symbol(&s->pb, &p->vlc_state[context], diff, bits);
 
243
        }
 
244
    }
 
245
    if (run_mode) {
 
246
        while (run_count >= 1 << ff_log2_run[run_index]) {
 
247
            run_count -= 1 << ff_log2_run[run_index];
 
248
            run_index++;
 
249
            put_bits(&s->pb, 1, 1);
 
250
        }
 
251
 
 
252
        if (run_count)
 
253
            put_bits(&s->pb, 1, 1);
 
254
    }
 
255
    s->run_index = run_index;
 
256
 
 
257
    return 0;
 
258
}
 
259
 
 
260
static void encode_plane(FFV1Context *s, uint8_t *src, int w, int h,
 
261
                         int stride, int plane_index)
 
262
{
 
263
    int x, y, i;
 
264
    const int ring_size = s->avctx->context_model ? 3 : 2;
 
265
    int16_t *sample[3];
 
266
    s->run_index = 0;
 
267
 
 
268
    memset(s->sample_buffer, 0, ring_size * (w + 6) * sizeof(*s->sample_buffer));
 
269
 
 
270
    for (y = 0; y < h; y++) {
 
271
        for (i = 0; i < ring_size; i++)
 
272
            sample[i] = s->sample_buffer + (w + 6) * ((h + i - y) % ring_size) + 3;
 
273
 
 
274
        sample[0][-1] = sample[1][0];
 
275
        sample[1][w]  = sample[1][w - 1];
 
276
// { START_TIMER
 
277
        if (s->bits_per_raw_sample <= 8) {
 
278
            for (x = 0; x < w; x++)
 
279
                sample[0][x] = src[x + stride * y];
 
280
            encode_line(s, w, sample, plane_index, 8);
 
281
        } else {
 
282
            if (s->packed_at_lsb) {
 
283
                for (x = 0; x < w; x++)
 
284
                    sample[0][x] = ((uint16_t *)(src + stride * y))[x];
 
285
            } else {
 
286
                for (x = 0; x < w; x++)
 
287
                    sample[0][x] =
 
288
                        ((uint16_t *)(src + stride * y))[x] >> (16 - s->bits_per_raw_sample);
 
289
            }
 
290
            encode_line(s, w, sample, plane_index, s->bits_per_raw_sample);
 
291
        }
 
292
// STOP_TIMER("encode line") }
 
293
    }
 
294
}
 
295
 
 
296
static void encode_rgb_frame(FFV1Context *s, uint8_t *src[3], int w, int h,
 
297
                             int stride[3])
 
298
{
 
299
    int x, y, p, i;
 
300
    const int ring_size = s->avctx->context_model ? 3 : 2;
 
301
    int16_t *sample[MAX_PLANES][3];
 
302
    int lbd  = s->avctx->bits_per_raw_sample <= 8;
 
303
    int bits = s->avctx->bits_per_raw_sample > 0
 
304
               ? s->avctx->bits_per_raw_sample
 
305
               : 8;
 
306
    int offset = 1 << bits;
 
307
 
 
308
    s->run_index = 0;
 
309
 
 
310
    memset(s->sample_buffer, 0, ring_size * MAX_PLANES *
 
311
                                (w + 6) * sizeof(*s->sample_buffer));
 
312
 
 
313
    for (y = 0; y < h; y++) {
 
314
        for (i = 0; i < ring_size; i++)
 
315
            for (p = 0; p < MAX_PLANES; p++)
 
316
                sample[p][i] = s->sample_buffer + p * ring_size *
 
317
                               (w + 6) +
 
318
                               ((h + i - y) % ring_size) * (w + 6) + 3;
 
319
 
 
320
        for (x = 0; x < w; x++) {
 
321
            int b, g, r, av_uninit(a);
 
322
            if (lbd) {
 
323
                unsigned v = *((uint32_t *)(src[0] + x * 4 + stride[0] * y));
 
324
                b = v & 0xFF;
 
325
                g = (v >> 8) & 0xFF;
 
326
                r = (v >> 16) & 0xFF;
 
327
                a = v >> 24;
 
328
            } else {
 
329
                b = *((uint16_t *)(src[0] + x * 2 + stride[0] * y));
 
330
                g = *((uint16_t *)(src[1] + x * 2 + stride[1] * y));
 
331
                r = *((uint16_t *)(src[2] + x * 2 + stride[2] * y));
 
332
            }
 
333
 
 
334
            b -= g;
 
335
            r -= g;
 
336
            g += (b + r) >> 2;
 
337
            b += offset;
 
338
            r += offset;
 
339
 
 
340
            sample[0][0][x] = g;
 
341
            sample[1][0][x] = b;
 
342
            sample[2][0][x] = r;
 
343
            sample[3][0][x] = a;
 
344
        }
 
345
        for (p = 0; p < 3 + s->transparency; p++) {
 
346
            sample[p][0][-1] = sample[p][1][0];
 
347
            sample[p][1][w]  = sample[p][1][w - 1];
 
348
            if (lbd)
 
349
                encode_line(s, w, sample[p], (p + 1) / 2, 9);
 
350
            else
 
351
                encode_line(s, w, sample[p], (p + 1) / 2, bits + 1);
 
352
        }
 
353
    }
 
354
}
 
355
 
 
356
 
 
357
static void write_quant_table(RangeCoder *c, int16_t *quant_table)
 
358
{
 
359
    int last = 0;
 
360
    int i;
 
361
    uint8_t state[CONTEXT_SIZE];
 
362
    memset(state, 128, sizeof(state));
 
363
 
 
364
    for (i = 1; i < 128; i++)
 
365
        if (quant_table[i] != quant_table[i - 1]) {
 
366
            put_symbol(c, state, i - last - 1, 0);
 
367
            last = i;
 
368
        }
 
369
    put_symbol(c, state, i - last - 1, 0);
 
370
}
 
371
 
 
372
static void write_quant_tables(RangeCoder *c,
 
373
                               int16_t quant_table[MAX_CONTEXT_INPUTS][256])
 
374
{
 
375
    int i;
 
376
    for (i = 0; i < 5; i++)
 
377
        write_quant_table(c, quant_table[i]);
 
378
}
 
379
 
 
380
static void write_header(FFV1Context *f)
 
381
{
 
382
    uint8_t state[CONTEXT_SIZE];
 
383
    int i, j;
 
384
    RangeCoder *const c = &f->slice_context[0]->c;
 
385
 
 
386
    memset(state, 128, sizeof(state));
 
387
 
 
388
    if (f->version < 2) {
 
389
        put_symbol(c, state, f->version, 0);
 
390
        put_symbol(c, state, f->ac, 0);
 
391
        if (f->ac > 1) {
 
392
            for (i = 1; i < 256; i++)
 
393
                put_symbol(c, state,
 
394
                           f->state_transition[i] - c->one_state[i], 1);
 
395
        }
 
396
        put_symbol(c, state, f->colorspace, 0); // YUV cs type
 
397
        if (f->version > 0)
 
398
            put_symbol(c, state, f->bits_per_raw_sample, 0);
 
399
        put_rac(c, state, f->chroma_planes);
 
400
        put_symbol(c, state, f->chroma_h_shift, 0);
 
401
        put_symbol(c, state, f->chroma_v_shift, 0);
 
402
        put_rac(c, state, f->transparency);
 
403
 
 
404
        write_quant_tables(c, f->quant_table);
 
405
    } else if (f->version < 3) {
 
406
        put_symbol(c, state, f->slice_count, 0);
 
407
        for (i = 0; i < f->slice_count; i++) {
 
408
            FFV1Context *fs = f->slice_context[i];
 
409
            put_symbol(c, state,
 
410
                       (fs->slice_x      + 1) * f->num_h_slices / f->width, 0);
 
411
            put_symbol(c, state,
 
412
                       (fs->slice_y      + 1) * f->num_v_slices / f->height, 0);
 
413
            put_symbol(c, state,
 
414
                       (fs->slice_width  + 1) * f->num_h_slices / f->width - 1,
 
415
                       0);
 
416
            put_symbol(c, state,
 
417
                       (fs->slice_height + 1) * f->num_v_slices / f->height - 1,
 
418
                       0);
 
419
            for (j = 0; j < f->plane_count; j++) {
 
420
                put_symbol(c, state, f->plane[j].quant_table_index, 0);
 
421
                av_assert0(f->plane[j].quant_table_index == f->avctx->context_model);
 
422
            }
 
423
        }
 
424
    }
 
425
}
 
426
 
 
427
static int write_extradata(FFV1Context *f)
 
428
{
 
429
    RangeCoder *const c = &f->c;
 
430
    uint8_t state[CONTEXT_SIZE];
 
431
    int i, j, k;
 
432
    uint8_t state2[32][CONTEXT_SIZE];
 
433
    unsigned v;
 
434
 
 
435
    memset(state2, 128, sizeof(state2));
 
436
    memset(state, 128, sizeof(state));
 
437
 
 
438
    f->avctx->extradata_size = 10000 + 4 +
 
439
                                    (11 * 11 * 5 * 5 * 5 + 11 * 11 * 11) * 32;
 
440
    f->avctx->extradata = av_malloc(f->avctx->extradata_size);
 
441
    ff_init_range_encoder(c, f->avctx->extradata, f->avctx->extradata_size);
 
442
    ff_build_rac_states(c, 0.05 * (1LL << 32), 256 - 8);
 
443
 
 
444
    put_symbol(c, state, f->version, 0);
 
445
    if (f->version > 2) {
 
446
        if (f->version == 3)
 
447
            f->minor_version = 2;
 
448
        put_symbol(c, state, f->minor_version, 0);
 
449
    }
 
450
 
 
451
    put_symbol(c, state, f->ac, 0);
 
452
    if (f->ac > 1)
 
453
        for (i = 1; i < 256; i++)
 
454
            put_symbol(c, state, f->state_transition[i] - c->one_state[i], 1);
 
455
 
 
456
    put_symbol(c, state, f->colorspace, 0); // YUV cs type
 
457
    put_symbol(c, state, f->bits_per_raw_sample, 0);
 
458
    put_rac(c, state, f->chroma_planes);
 
459
    put_symbol(c, state, f->chroma_h_shift, 0);
 
460
    put_symbol(c, state, f->chroma_v_shift, 0);
 
461
    put_rac(c, state, f->transparency);
 
462
    put_symbol(c, state, f->num_h_slices - 1, 0);
 
463
    put_symbol(c, state, f->num_v_slices - 1, 0);
 
464
 
 
465
    put_symbol(c, state, f->quant_table_count, 0);
 
466
    for (i = 0; i < f->quant_table_count; i++)
 
467
        write_quant_tables(c, f->quant_tables[i]);
 
468
 
 
469
    for (i = 0; i < f->quant_table_count; i++) {
 
470
        for (j = 0; j < f->context_count[i] * CONTEXT_SIZE; j++)
 
471
            if (f->initial_states[i] && f->initial_states[i][0][j] != 128)
 
472
                break;
 
473
        if (j < f->context_count[i] * CONTEXT_SIZE) {
 
474
            put_rac(c, state, 1);
 
475
            for (j = 0; j < f->context_count[i]; j++)
 
476
                for (k = 0; k < CONTEXT_SIZE; k++) {
 
477
                    int pred = j ? f->initial_states[i][j - 1][k] : 128;
 
478
                    put_symbol(c, state2[k],
 
479
                               (int8_t)(f->initial_states[i][j][k] - pred), 1);
 
480
                }
 
481
        } else {
 
482
            put_rac(c, state, 0);
 
483
        }
 
484
    }
 
485
 
 
486
    if (f->version > 2) {
 
487
        put_symbol(c, state, f->ec, 0);
 
488
    }
 
489
 
 
490
    f->avctx->extradata_size = ff_rac_terminate(c);
 
491
 
 
492
    v = av_crc(av_crc_get_table(AV_CRC_32_IEEE), 0,
 
493
               f->avctx->extradata, f->avctx->extradata_size);
 
494
    AV_WL32(f->avctx->extradata + f->avctx->extradata_size, v);
 
495
    f->avctx->extradata_size += 4;
 
496
 
 
497
    return 0;
 
498
}
 
499
 
 
500
static int sort_stt(FFV1Context *s, uint8_t stt[256])
 
501
{
 
502
    int i, i2, changed, print = 0;
 
503
 
 
504
    do {
 
505
        changed = 0;
 
506
        for (i = 12; i < 244; i++) {
 
507
            for (i2 = i + 1; i2 < 245 && i2 < i + 4; i2++) {
 
508
 
 
509
#define COST(old, new)                                      \
 
510
    s->rc_stat[old][0] * -log2((256 - (new)) / 256.0) +     \
 
511
    s->rc_stat[old][1] * -log2((new)         / 256.0)
 
512
 
 
513
#define COST2(old, new)                         \
 
514
    COST(old, new) + COST(256 - (old), 256 - (new))
 
515
 
 
516
                double size0 = COST2(i,  i) + COST2(i2, i2);
 
517
                double sizeX = COST2(i, i2) + COST2(i2, i);
 
518
                if (sizeX < size0 && i != 128 && i2 != 128) {
 
519
                    int j;
 
520
                    FFSWAP(int, stt[i], stt[i2]);
 
521
                    FFSWAP(int, s->rc_stat[i][0], s->rc_stat[i2][0]);
 
522
                    FFSWAP(int, s->rc_stat[i][1], s->rc_stat[i2][1]);
 
523
                    if (i != 256 - i2) {
 
524
                        FFSWAP(int, stt[256 - i], stt[256 - i2]);
 
525
                        FFSWAP(int, s->rc_stat[256 - i][0], s->rc_stat[256 - i2][0]);
 
526
                        FFSWAP(int, s->rc_stat[256 - i][1], s->rc_stat[256 - i2][1]);
 
527
                    }
 
528
                    for (j = 1; j < 256; j++) {
 
529
                        if (stt[j] == i)
 
530
                            stt[j] = i2;
 
531
                        else if (stt[j] == i2)
 
532
                            stt[j] = i;
 
533
                        if (i != 256 - i2) {
 
534
                            if (stt[256 - j] == 256 - i)
 
535
                                stt[256 - j] = 256 - i2;
 
536
                            else if (stt[256 - j] == 256 - i2)
 
537
                                stt[256 - j] = 256 - i;
 
538
                        }
 
539
                    }
 
540
                    print = changed = 1;
 
541
                }
 
542
            }
 
543
        }
 
544
    } while (changed);
 
545
    return print;
 
546
}
 
547
 
 
548
static int init_slices_state(FFV1Context *f)
 
549
{
 
550
    int i, ret;
 
551
    for (i = 0; i < f->slice_count; i++) {
 
552
        FFV1Context *fs = f->slice_context[i];
 
553
        if ((ret = ffv1_init_slice_state(f, fs)) < 0)
 
554
            return AVERROR(ENOMEM);
 
555
    }
 
556
    return 0;
 
557
}
 
558
 
 
559
static av_cold int ffv1_encode_init(AVCodecContext *avctx)
 
560
{
 
561
    FFV1Context *s = avctx->priv_data;
 
562
    const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(avctx->pix_fmt);
 
563
    int i, j, k, m, ret;
 
564
 
 
565
    ffv1_common_init(avctx);
 
566
 
 
567
    s->version = 0;
 
568
 
 
569
    if ((avctx->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2)) ||
 
570
        avctx->slices > 1)
 
571
        s->version = FFMAX(s->version, 2);
 
572
 
 
573
    if (avctx->level == 3) {
 
574
        s->version = 3;
 
575
    }
 
576
 
 
577
    if (s->ec < 0) {
 
578
        s->ec = (s->version >= 3);
 
579
    }
 
580
 
 
581
    if (s->version >= 2 &&
 
582
        avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
 
583
        av_log(avctx, AV_LOG_ERROR,
 
584
               "Version %d requested, please set -strict experimental in "
 
585
               "order to enable it\n",
 
586
               s->version);
 
587
        return AVERROR(ENOSYS);
 
588
    }
 
589
 
 
590
    s->ac = avctx->coder_type > 0 ? 2 : 0;
 
591
 
 
592
    s->plane_count = 3;
 
593
    switch (avctx->pix_fmt) {
 
594
    case AV_PIX_FMT_YUV444P9:
 
595
    case AV_PIX_FMT_YUV422P9:
 
596
    case AV_PIX_FMT_YUV420P9:
 
597
        if (!avctx->bits_per_raw_sample)
 
598
            s->bits_per_raw_sample = 9;
 
599
    case AV_PIX_FMT_YUV444P10:
 
600
    case AV_PIX_FMT_YUV420P10:
 
601
    case AV_PIX_FMT_YUV422P10:
 
602
        s->packed_at_lsb = 1;
 
603
        if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
 
604
            s->bits_per_raw_sample = 10;
 
605
    case AV_PIX_FMT_GRAY16:
 
606
    case AV_PIX_FMT_YUV444P16:
 
607
    case AV_PIX_FMT_YUV422P16:
 
608
    case AV_PIX_FMT_YUV420P16:
 
609
        if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample) {
 
610
            s->bits_per_raw_sample = 16;
 
611
        } else if (!s->bits_per_raw_sample) {
 
612
            s->bits_per_raw_sample = avctx->bits_per_raw_sample;
 
613
        }
 
614
        if (s->bits_per_raw_sample <= 8) {
 
615
            av_log(avctx, AV_LOG_ERROR, "bits_per_raw_sample invalid\n");
 
616
            return AVERROR_INVALIDDATA;
 
617
        }
 
618
        if (!s->ac && avctx->coder_type == -1) {
 
619
            av_log(avctx, AV_LOG_INFO,
 
620
                   "bits_per_raw_sample > 8, forcing coder 1\n");
 
621
            s->ac = 2;
 
622
        }
 
623
        if (!s->ac) {
 
624
            av_log(
 
625
                avctx, AV_LOG_ERROR,
 
626
                "bits_per_raw_sample of more than 8 needs -coder 1 currently\n");
 
627
            return AVERROR_INVALIDDATA;
 
628
        }
 
629
        s->version = FFMAX(s->version, 1);
 
630
    case AV_PIX_FMT_GRAY8:
 
631
    case AV_PIX_FMT_YUV444P:
 
632
    case AV_PIX_FMT_YUV440P:
 
633
    case AV_PIX_FMT_YUV422P:
 
634
    case AV_PIX_FMT_YUV420P:
 
635
    case AV_PIX_FMT_YUV411P:
 
636
    case AV_PIX_FMT_YUV410P:
 
637
        s->chroma_planes = desc->nb_components < 3 ? 0 : 1;
 
638
        s->colorspace    = 0;
 
639
        break;
 
640
    case AV_PIX_FMT_YUVA444P:
 
641
    case AV_PIX_FMT_YUVA422P:
 
642
    case AV_PIX_FMT_YUVA420P:
 
643
        s->chroma_planes = 1;
 
644
        s->colorspace    = 0;
 
645
        s->transparency  = 1;
 
646
        break;
 
647
    case AV_PIX_FMT_RGB32:
 
648
        s->colorspace   = 1;
 
649
        s->transparency = 1;
 
650
        break;
 
651
    case AV_PIX_FMT_GBRP9:
 
652
        if (!avctx->bits_per_raw_sample)
 
653
            s->bits_per_raw_sample = 9;
 
654
    case AV_PIX_FMT_GBRP10:
 
655
        if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
 
656
            s->bits_per_raw_sample = 10;
 
657
    case AV_PIX_FMT_GBRP16:
 
658
        if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
 
659
            s->bits_per_raw_sample = 16;
 
660
        else if (!s->bits_per_raw_sample)
 
661
            s->bits_per_raw_sample = avctx->bits_per_raw_sample;
 
662
        s->colorspace    = 1;
 
663
        s->chroma_planes = 1;
 
664
        s->version       = FFMAX(s->version, 1);
 
665
        break;
 
666
    default:
 
667
        av_log(avctx, AV_LOG_ERROR, "format not supported\n");
 
668
        return AVERROR_INVALIDDATA;
 
669
    }
 
670
    if (s->transparency) {
 
671
        av_log(
 
672
            avctx, AV_LOG_WARNING,
 
673
            "Storing alpha plane, this will require a recent FFV1 decoder to playback!\n");
 
674
    }
 
675
    if (avctx->context_model > 1U) {
 
676
        av_log(avctx, AV_LOG_ERROR,
 
677
               "Invalid context model %d, valid values are 0 and 1\n",
 
678
               avctx->context_model);
 
679
        return AVERROR(EINVAL);
 
680
    }
 
681
 
 
682
    if (s->ac > 1)
 
683
        for (i = 1; i < 256; i++)
 
684
            s->state_transition[i] = ffv1_ver2_state[i];
 
685
 
 
686
    for (i = 0; i < 256; i++) {
 
687
        s->quant_table_count = 2;
 
688
        if (s->bits_per_raw_sample <= 8) {
 
689
            s->quant_tables[0][0][i] = ffv1_quant11[i];
 
690
            s->quant_tables[0][1][i] = ffv1_quant11[i] * 11;
 
691
            s->quant_tables[0][2][i] = ffv1_quant11[i] * 11 * 11;
 
692
            s->quant_tables[1][0][i] = ffv1_quant11[i];
 
693
            s->quant_tables[1][1][i] = ffv1_quant11[i] * 11;
 
694
            s->quant_tables[1][2][i] = ffv1_quant5[i]  * 11 * 11;
 
695
            s->quant_tables[1][3][i] = ffv1_quant5[i]  *  5 * 11 * 11;
 
696
            s->quant_tables[1][4][i] = ffv1_quant5[i]  *  5 *  5 * 11 * 11;
 
697
        } else {
 
698
            s->quant_tables[0][0][i] = ffv1_quant9_10bit[i];
 
699
            s->quant_tables[0][1][i] = ffv1_quant9_10bit[i] * 11;
 
700
            s->quant_tables[0][2][i] = ffv1_quant9_10bit[i] * 11 * 11;
 
701
            s->quant_tables[1][0][i] = ffv1_quant9_10bit[i];
 
702
            s->quant_tables[1][1][i] = ffv1_quant9_10bit[i] * 11;
 
703
            s->quant_tables[1][2][i] = ffv1_quant5_10bit[i] * 11 * 11;
 
704
            s->quant_tables[1][3][i] = ffv1_quant5_10bit[i] *  5 * 11 * 11;
 
705
            s->quant_tables[1][4][i] = ffv1_quant5_10bit[i] *  5 *  5 * 11 * 11;
 
706
        }
 
707
    }
 
708
    s->context_count[0] = (11 * 11 * 11        + 1) / 2;
 
709
    s->context_count[1] = (11 * 11 * 5 * 5 * 5 + 1) / 2;
 
710
    memcpy(s->quant_table, s->quant_tables[avctx->context_model],
 
711
           sizeof(s->quant_table));
 
712
 
 
713
    for (i = 0; i < s->plane_count; i++) {
 
714
        PlaneContext *const p = &s->plane[i];
 
715
 
 
716
        memcpy(p->quant_table, s->quant_table, sizeof(p->quant_table));
 
717
        p->quant_table_index = avctx->context_model;
 
718
        p->context_count     = s->context_count[p->quant_table_index];
 
719
    }
 
720
 
 
721
    if ((ret = ffv1_allocate_initial_states(s)) < 0)
 
722
        return ret;
 
723
 
 
724
    avctx->coded_frame = &s->picture;
 
725
    if (!s->transparency)
 
726
        s->plane_count = 2;
 
727
 
 
728
    av_pix_fmt_get_chroma_sub_sample(avctx->pix_fmt, &s->chroma_h_shift,
 
729
                                     &s->chroma_v_shift);
 
730
 
 
731
    s->picture_number = 0;
 
732
 
 
733
    if (avctx->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2)) {
 
734
        for (i = 0; i < s->quant_table_count; i++) {
 
735
            s->rc_stat2[i] = av_mallocz(s->context_count[i] *
 
736
                                        sizeof(*s->rc_stat2[i]));
 
737
            if (!s->rc_stat2[i])
 
738
                return AVERROR(ENOMEM);
 
739
        }
 
740
    }
 
741
    if (avctx->stats_in) {
 
742
        char *p = avctx->stats_in;
 
743
        uint8_t best_state[256][256];
 
744
        int gob_count = 0;
 
745
        char *next;
 
746
 
 
747
        av_assert0(s->version >= 2);
 
748
 
 
749
        for (;; ) {
 
750
            for (j = 0; j < 256; j++)
 
751
                for (i = 0; i < 2; i++) {
 
752
                    s->rc_stat[j][i] = strtol(p, &next, 0);
 
753
                    if (next == p) {
 
754
                        av_log(avctx, AV_LOG_ERROR,
 
755
                               "2Pass file invalid at %d %d [%s]\n", j, i, p);
 
756
                        return AVERROR_INVALIDDATA;
 
757
                    }
 
758
                    p = next;
 
759
                }
 
760
            for (i = 0; i < s->quant_table_count; i++)
 
761
                for (j = 0; j < s->context_count[i]; j++) {
 
762
                    for (k = 0; k < 32; k++)
 
763
                        for (m = 0; m < 2; m++) {
 
764
                            s->rc_stat2[i][j][k][m] = strtol(p, &next, 0);
 
765
                            if (next == p) {
 
766
                                av_log(avctx, AV_LOG_ERROR,
 
767
                                       "2Pass file invalid at %d %d %d %d [%s]\n",
 
768
                                       i, j, k, m, p);
 
769
                                return AVERROR_INVALIDDATA;
 
770
                            }
 
771
                            p = next;
 
772
                        }
 
773
                }
 
774
            gob_count = strtol(p, &next, 0);
 
775
            if (next == p || gob_count <= 0) {
 
776
                av_log(avctx, AV_LOG_ERROR, "2Pass file invalid\n");
 
777
                return AVERROR_INVALIDDATA;
 
778
            }
 
779
            p = next;
 
780
            while (*p == '\n' || *p == ' ')
 
781
                p++;
 
782
            if (p[0] == 0)
 
783
                break;
 
784
        }
 
785
        sort_stt(s, s->state_transition);
 
786
 
 
787
        find_best_state(best_state, s->state_transition);
 
788
 
 
789
        for (i = 0; i < s->quant_table_count; i++) {
 
790
            for (j = 0; j < s->context_count[i]; j++)
 
791
                for (k = 0; k < 32; k++) {
 
792
                    double p = 128;
 
793
                    if (s->rc_stat2[i][j][k][0] + s->rc_stat2[i][j][k][1]) {
 
794
                        p = 256.0 * s->rc_stat2[i][j][k][1] /
 
795
                            (s->rc_stat2[i][j][k][0] + s->rc_stat2[i][j][k][1]);
 
796
                    }
 
797
                    s->initial_states[i][j][k] =
 
798
                        best_state[av_clip(round(p), 1, 255)][av_clip((s->rc_stat2[i][j][k][0] +
 
799
                                                                       s->rc_stat2[i][j][k][1]) /
 
800
                                                                      gob_count, 0, 255)];
 
801
                }
 
802
        }
 
803
    }
 
804
 
 
805
    if (s->version > 1) {
 
806
        for (s->num_v_slices = 2; s->num_v_slices < 9; s->num_v_slices++)
 
807
            for (s->num_h_slices = s->num_v_slices;
 
808
                 s->num_h_slices < 2 * s->num_v_slices; s->num_h_slices++)
 
809
                if (avctx->slices == s->num_h_slices * s->num_v_slices &&
 
810
                    avctx->slices <= 64 || !avctx->slices)
 
811
                    goto slices_ok;
 
812
        av_log(avctx, AV_LOG_ERROR,
 
813
               "Unsupported number %d of slices requested, please specify a "
 
814
               "supported number with -slices (ex:4,6,9,12,16, ...)\n",
 
815
               avctx->slices);
 
816
        return AVERROR(ENOSYS);
 
817
slices_ok:
 
818
        write_extradata(s);
 
819
    }
 
820
 
 
821
    if ((ret = ffv1_init_slice_contexts(s)) < 0)
 
822
        return ret;
 
823
    if ((ret = init_slices_state(s)) < 0)
 
824
        return ret;
 
825
 
 
826
#define STATS_OUT_SIZE 1024 * 1024 * 6
 
827
    if (avctx->flags & CODEC_FLAG_PASS1) {
 
828
        avctx->stats_out = av_mallocz(STATS_OUT_SIZE);
 
829
        for (i = 0; i < s->quant_table_count; i++)
 
830
            for (j = 0; j < s->slice_count; j++) {
 
831
                FFV1Context *sf = s->slice_context[j];
 
832
                av_assert0(!sf->rc_stat2[i]);
 
833
                sf->rc_stat2[i] = av_mallocz(s->context_count[i] *
 
834
                                             sizeof(*sf->rc_stat2[i]));
 
835
                if (!sf->rc_stat2[i])
 
836
                    return AVERROR(ENOMEM);
 
837
            }
 
838
    }
 
839
 
 
840
    return 0;
 
841
}
 
842
 
 
843
static void encode_slice_header(FFV1Context *f, FFV1Context *fs)
 
844
{
 
845
    RangeCoder *c = &fs->c;
 
846
    uint8_t state[CONTEXT_SIZE];
 
847
    int j;
 
848
    memset(state, 128, sizeof(state));
 
849
 
 
850
    put_symbol(c, state, (fs->slice_x + 1) * f->num_h_slices / f->width, 0);
 
851
    put_symbol(c, state, (fs->slice_y + 1) * f->num_v_slices / f->height, 0);
 
852
    put_symbol(c, state, (fs->slice_width + 1) * f->num_h_slices / f->width - 1,
 
853
               0);
 
854
    put_symbol(c, state,
 
855
               (fs->slice_height + 1) * f->num_v_slices / f->height - 1,
 
856
               0);
 
857
    for (j = 0; j < f->plane_count; j++) {
 
858
        put_symbol(c, state, f->plane[j].quant_table_index, 0);
 
859
        av_assert0(f->plane[j].quant_table_index == f->avctx->context_model);
 
860
    }
 
861
    if (!f->picture.interlaced_frame)
 
862
        put_symbol(c, state, 3, 0);
 
863
    else
 
864
        put_symbol(c, state, 1 + !f->picture.top_field_first, 0);
 
865
    put_symbol(c, state, f->picture.sample_aspect_ratio.num, 0);
 
866
    put_symbol(c, state, f->picture.sample_aspect_ratio.den, 0);
 
867
}
 
868
 
 
869
static int encode_slice(AVCodecContext *c, void *arg)
 
870
{
 
871
    FFV1Context *fs  = *(void **)arg;
 
872
    FFV1Context *f   = fs->avctx->priv_data;
 
873
    int width        = fs->slice_width;
 
874
    int height       = fs->slice_height;
 
875
    int x            = fs->slice_x;
 
876
    int y            = fs->slice_y;
 
877
    AVFrame *const p = &f->picture;
 
878
    const int ps     = (av_pix_fmt_desc_get(c->pix_fmt)->flags & PIX_FMT_PLANAR)
 
879
                       ? (f->bits_per_raw_sample > 8) + 1
 
880
                       : 4;
 
881
 
 
882
    if (p->key_frame)
 
883
        ffv1_clear_slice_state(f, fs);
 
884
    if (f->version > 2) {
 
885
        encode_slice_header(f, fs);
 
886
    }
 
887
    if (!fs->ac) {
 
888
        if (f->version > 2)
 
889
            put_rac(&fs->c, (uint8_t[]) { 129 }, 0);
 
890
        fs->ac_byte_count = f->version > 2 || (!x && !y) ? ff_rac_terminate( &fs->c) : 0;
 
891
        init_put_bits(&fs->pb, fs->c.bytestream_start + fs->ac_byte_count,
 
892
                      fs->c.bytestream_end - fs->c.bytestream_start - fs->ac_byte_count);
 
893
    }
 
894
 
 
895
    if (f->colorspace == 0) {
 
896
        const int chroma_width  = -((-width) >> f->chroma_h_shift);
 
897
        const int chroma_height = -((-height) >> f->chroma_v_shift);
 
898
        const int cx            = x >> f->chroma_h_shift;
 
899
        const int cy            = y >> f->chroma_v_shift;
 
900
 
 
901
        encode_plane(fs, p->data[0] + ps * x + y * p->linesize[0],
 
902
                     width, height, p->linesize[0], 0);
 
903
 
 
904
        if (f->chroma_planes) {
 
905
            encode_plane(fs, p->data[1] + ps * cx + cy * p->linesize[1],
 
906
                         chroma_width, chroma_height, p->linesize[1], 1);
 
907
            encode_plane(fs, p->data[2] + ps * cx + cy * p->linesize[2],
 
908
                         chroma_width, chroma_height, p->linesize[2], 1);
 
909
        }
 
910
        if (fs->transparency)
 
911
            encode_plane(fs, p->data[3] + ps * x + y * p->linesize[3], width,
 
912
                         height, p->linesize[3], 2);
 
913
    } else {
 
914
        uint8_t *planes[3] = { p->data[0] + ps * x + y * p->linesize[0],
 
915
                               p->data[1] + ps * x + y * p->linesize[1],
 
916
                               p->data[2] + ps * x + y * p->linesize[2] };
 
917
        encode_rgb_frame(fs, planes, width, height, p->linesize);
 
918
    }
 
919
    emms_c();
 
920
 
 
921
    return 0;
 
922
}
 
923
 
 
924
static int ffv1_encode_frame(AVCodecContext *avctx, AVPacket *pkt,
 
925
                        const AVFrame *pict, int *got_packet)
 
926
{
 
927
    FFV1Context *f      = avctx->priv_data;
 
928
    RangeCoder *const c = &f->slice_context[0]->c;
 
929
    AVFrame *const p    = &f->picture;
 
930
    int used_count      = 0;
 
931
    uint8_t keystate    = 128;
 
932
    uint8_t *buf_p;
 
933
    int i, ret;
 
934
 
 
935
    if ((ret = ff_alloc_packet(pkt, avctx->width * avctx->height *
 
936
                             ((8 * 2 + 1 + 1) * 4) / 8 +
 
937
                             FF_MIN_BUFFER_SIZE)) < 0) {
 
938
        av_log(avctx, AV_LOG_ERROR, "Error getting output packet.\n");
 
939
        return ret;
 
940
    }
 
941
 
 
942
    ff_init_range_encoder(c, pkt->data, pkt->size);
 
943
    ff_build_rac_states(c, 0.05 * (1LL << 32), 256 - 8);
 
944
 
 
945
    *p           = *pict;
 
946
    p->pict_type = AV_PICTURE_TYPE_I;
 
947
 
 
948
    if (avctx->gop_size == 0 || f->picture_number % avctx->gop_size == 0) {
 
949
        put_rac(c, &keystate, 1);
 
950
        p->key_frame = 1;
 
951
        f->gob_count++;
 
952
        write_header(f);
 
953
    } else {
 
954
        put_rac(c, &keystate, 0);
 
955
        p->key_frame = 0;
 
956
    }
 
957
 
 
958
    if (f->ac > 1) {
 
959
        int i;
 
960
        for (i = 1; i < 256; i++) {
 
961
            c->one_state[i]        = f->state_transition[i];
 
962
            c->zero_state[256 - i] = 256 - c->one_state[i];
 
963
        }
 
964
    }
 
965
 
 
966
    for (i = 1; i < f->slice_count; i++) {
 
967
        FFV1Context *fs = f->slice_context[i];
 
968
        uint8_t *start  = pkt->data +
 
969
                          (pkt->size - used_count) * (int64_t)i / f->slice_count;
 
970
        int len = pkt->size / f->slice_count;
 
971
        ff_init_range_encoder(&fs->c, start, len);
 
972
    }
 
973
    avctx->execute(avctx, encode_slice, &f->slice_context[0], NULL,
 
974
                   f->slice_count, sizeof(void *));
 
975
 
 
976
    buf_p = pkt->data;
 
977
    for (i = 0; i < f->slice_count; i++) {
 
978
        FFV1Context *fs = f->slice_context[i];
 
979
        int bytes;
 
980
 
 
981
        if (fs->ac) {
 
982
            uint8_t state = 129;
 
983
            put_rac(&fs->c, &state, 0);
 
984
            bytes = ff_rac_terminate(&fs->c);
 
985
        } else {
 
986
            flush_put_bits(&fs->pb); // FIXME: nicer padding
 
987
            bytes = fs->ac_byte_count + (put_bits_count(&fs->pb) + 7) / 8;
 
988
        }
 
989
        if (i > 0 || f->version > 2) {
 
990
            av_assert0(bytes < pkt->size / f->slice_count);
 
991
            memmove(buf_p, fs->c.bytestream_start, bytes);
 
992
            av_assert0(bytes < (1 << 24));
 
993
            AV_WB24(buf_p + bytes, bytes);
 
994
            bytes += 3;
 
995
        }
 
996
        if (f->ec) {
 
997
            unsigned v;
 
998
            buf_p[bytes++] = 0;
 
999
            v = av_crc(av_crc_get_table(AV_CRC_32_IEEE), 0, buf_p, bytes);
 
1000
            AV_WL32(buf_p + bytes, v);
 
1001
            bytes += 4;
 
1002
        }
 
1003
        buf_p += bytes;
 
1004
    }
 
1005
 
 
1006
    if ((avctx->flags & CODEC_FLAG_PASS1) && (f->picture_number & 31) == 0) {
 
1007
        int j, k, m;
 
1008
        char *p   = avctx->stats_out;
 
1009
        char *end = p + STATS_OUT_SIZE;
 
1010
 
 
1011
        memset(f->rc_stat, 0, sizeof(f->rc_stat));
 
1012
        for (i = 0; i < f->quant_table_count; i++)
 
1013
            memset(f->rc_stat2[i], 0, f->context_count[i] * sizeof(*f->rc_stat2[i]));
 
1014
 
 
1015
        for (j = 0; j < f->slice_count; j++) {
 
1016
            FFV1Context *fs = f->slice_context[j];
 
1017
            for (i = 0; i < 256; i++) {
 
1018
                f->rc_stat[i][0] += fs->rc_stat[i][0];
 
1019
                f->rc_stat[i][1] += fs->rc_stat[i][1];
 
1020
            }
 
1021
            for (i = 0; i < f->quant_table_count; i++) {
 
1022
                for (k = 0; k < f->context_count[i]; k++)
 
1023
                    for (m = 0; m < 32; m++) {
 
1024
                        f->rc_stat2[i][k][m][0] += fs->rc_stat2[i][k][m][0];
 
1025
                        f->rc_stat2[i][k][m][1] += fs->rc_stat2[i][k][m][1];
 
1026
                    }
 
1027
            }
 
1028
        }
 
1029
 
 
1030
        for (j = 0; j < 256; j++) {
 
1031
            snprintf(p, end - p, "%" PRIu64 " %" PRIu64 " ",
 
1032
                     f->rc_stat[j][0], f->rc_stat[j][1]);
 
1033
            p += strlen(p);
 
1034
        }
 
1035
        snprintf(p, end - p, "\n");
 
1036
 
 
1037
        for (i = 0; i < f->quant_table_count; i++) {
 
1038
            for (j = 0; j < f->context_count[i]; j++)
 
1039
                for (m = 0; m < 32; m++) {
 
1040
                    snprintf(p, end - p, "%" PRIu64 " %" PRIu64 " ",
 
1041
                             f->rc_stat2[i][j][m][0], f->rc_stat2[i][j][m][1]);
 
1042
                    p += strlen(p);
 
1043
                }
 
1044
        }
 
1045
        snprintf(p, end - p, "%d\n", f->gob_count);
 
1046
    } else if (avctx->flags & CODEC_FLAG_PASS1)
 
1047
        avctx->stats_out[0] = '\0';
 
1048
 
 
1049
    f->picture_number++;
 
1050
    pkt->size   = buf_p - pkt->data;
 
1051
    pkt->flags |= AV_PKT_FLAG_KEY * p->key_frame;
 
1052
    *got_packet = 1;
 
1053
 
 
1054
    return 0;
 
1055
}
 
1056
 
 
1057
#define OFFSET(x) offsetof(FFV1Context, x)
 
1058
#define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
 
1059
static const AVOption options[] = {
 
1060
    { "slicecrc", "Protect slices with CRCs", OFFSET(ec), AV_OPT_TYPE_INT,
 
1061
             { .i64 = -1 }, -1, 1, VE },
 
1062
    { NULL }
 
1063
};
 
1064
 
 
1065
static const AVClass class = {
 
1066
    .class_name = "ffv1 encoder",
 
1067
    .item_name  = av_default_item_name,
 
1068
    .option     = options,
 
1069
    .version    = LIBAVUTIL_VERSION_INT,
 
1070
};
 
1071
 
 
1072
static const AVCodecDefault ffv1_defaults[] = {
 
1073
    { "coder", "-1" },
 
1074
    { NULL },
 
1075
};
 
1076
 
 
1077
AVCodec ff_ffv1_encoder = {
 
1078
    .name           = "ffv1",
 
1079
    .type           = AVMEDIA_TYPE_VIDEO,
 
1080
    .id             = AV_CODEC_ID_FFV1,
 
1081
    .priv_data_size = sizeof(FFV1Context),
 
1082
    .init           = ffv1_encode_init,
 
1083
    .encode2        = ffv1_encode_frame,
 
1084
    .close          = ffv1_close,
 
1085
    .capabilities   = CODEC_CAP_SLICE_THREADS,
 
1086
    .pix_fmts       = (const enum AVPixelFormat[]) {
 
1087
        AV_PIX_FMT_YUV420P,   AV_PIX_FMT_YUV422P,   AV_PIX_FMT_YUV444P,
 
1088
        AV_PIX_FMT_YUV411P,   AV_PIX_FMT_YUV410P,
 
1089
        AV_PIX_FMT_YUV444P9,  AV_PIX_FMT_YUV422P9,  AV_PIX_FMT_YUV420P9,
 
1090
        AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10,
 
1091
        AV_PIX_FMT_YUV420P16, AV_PIX_FMT_YUV422P16, AV_PIX_FMT_YUV444P16,
 
1092
        AV_PIX_FMT_RGB32,
 
1093
        AV_PIX_FMT_GBRP9,     AV_PIX_FMT_GBRP10,
 
1094
        AV_PIX_FMT_YUVA420P,  AV_PIX_FMT_YUVA422P,  AV_PIX_FMT_YUVA444P,
 
1095
        AV_PIX_FMT_GRAY16,    AV_PIX_FMT_GRAY8,
 
1096
        AV_PIX_FMT_NONE
 
1097
 
 
1098
    },
 
1099
    .long_name      = NULL_IF_CONFIG_SMALL("FFmpeg video codec #1"),
 
1100
    .defaults       = ffv1_defaults,
 
1101
    .priv_class     = &class,
 
1102
};