git.sesse.net Git - ffmpeg/blob - libavcodec/ffv1enc.c

   1 /*
   2  * FFV1 encoder
   3  *
   4  * Copyright (c) 2003-2013 Michael Niedermayer <michaelni@gmx.at>
   5  *
   6  * This file is part of FFmpeg.
   7  *
   8  * FFmpeg is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12  *
  13  * FFmpeg is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with FFmpeg; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  21  */
  22
  23 /**
  24  * @file
  25  * FF Video Codec 1 (a lossless codec) encoder
  26  */
  27
  28 #include "libavutil/attributes.h"
  29 #include "libavutil/avassert.h"
  30 #include "libavutil/crc.h"
  31 #include "libavutil/opt.h"
  32 #include "libavutil/imgutils.h"
  33 #include "libavutil/pixdesc.h"
  34 #include "libavutil/timer.h"
  35
  36 #include "avcodec.h"
  37 #include "internal.h"
  38 #include "put_bits.h"
  39 #include "rangecoder.h"
  40 #include "golomb.h"
  41 #include "mathops.h"
  42 #include "ffv1.h"
  43
  44 static const int8_t quant5_10bit[256] = {
  45      0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  1,  1,  1,  1,  1,
  46      1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,
  47      1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,
  48      1,  1,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,
  49      2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,
  50      2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,
  51      2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,
  52      2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,
  53     -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
  54     -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
  55     -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
  56     -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
  57     -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -1,
  58     -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
  59     -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
  60     -1, -1, -1, -1, -1, -1, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0,
  61 };
  62
  63 static const int8_t quant5[256] = {
  64      0,  1,  1,  1,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,
  65      2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,
  66      2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,
  67      2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,
  68      2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,
  69      2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,
  70      2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,
  71      2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,
  72     -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
  73     -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
  74     -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
  75     -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
  76     -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
  77     -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
  78     -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
  79     -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -1, -1, -1,
  80 };
  81
  82 static const int8_t quant9_10bit[256] = {
  83      0,  0,  0,  0,  0,  1,  1,  1,  1,  1,  1,  1,  1,  2,  2,  2,
  84      2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  3,  3,  3,  3,  3,
  85      3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,
  86      3,  3,  3,  3,  3,  3,  3,  3,  4,  4,  4,  4,  4,  4,  4,  4,
  87      4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,
  88      4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,
  89      4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,
  90      4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,
  91     -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4,
  92     -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4,
  93     -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4,
  94     -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4,
  95     -4, -4, -4, -4, -4, -4, -4, -4, -4, -3, -3, -3, -3, -3, -3, -3,
  96     -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3,
  97     -3, -3, -3, -3, -3, -3, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
  98     -2, -2, -2, -2, -1, -1, -1, -1, -1, -1, -1, -1, -0, -0, -0, -0,
  99 };
 100
 101 static const int8_t quant11[256] = {
 102      0,  1,  2,  2,  2,  3,  3,  3,  3,  3,  3,  3,  4,  4,  4,  4,
 103      4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,
 104      4,  4,  4,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,
 105      5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,
 106      5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,
 107      5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,
 108      5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,
 109      5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,
 110     -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5,
 111     -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5,
 112     -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5,
 113     -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5,
 114     -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5,
 115     -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -4, -4,
 116     -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4,
 117     -4, -4, -4, -4, -4, -3, -3, -3, -3, -3, -3, -3, -2, -2, -2, -1,
 118 };
 119
 120 static const uint8_t ver2_state[256] = {
 121       0,  10,  10,  10,  10,  16,  16,  16, 28,   16,  16,  29,  42,  49,  20,  49,
 122      59,  25,  26,  26,  27,  31,  33,  33, 33,   34,  34,  37,  67,  38,  39,  39,
 123      40,  40,  41,  79,  43,  44,  45,  45, 48,   48,  64,  50,  51,  52,  88,  52,
 124      53,  74,  55,  57,  58,  58,  74,  60, 101,  61,  62,  84,  66,  66,  68,  69,
 125      87,  82,  71,  97,  73,  73,  82,  75, 111,  77,  94,  78,  87,  81,  83,  97,
 126      85,  83,  94,  86,  99,  89,  90,  99, 111,  92,  93,  134, 95,  98,  105, 98,
 127     105, 110, 102, 108, 102, 118, 103, 106, 106, 113, 109, 112, 114, 112, 116, 125,
 128     115, 116, 117, 117, 126, 119, 125, 121, 121, 123, 145, 124, 126, 131, 127, 129,
 129     165, 130, 132, 138, 133, 135, 145, 136, 137, 139, 146, 141, 143, 142, 144, 148,
 130     147, 155, 151, 149, 151, 150, 152, 157, 153, 154, 156, 168, 158, 162, 161, 160,
 131     172, 163, 169, 164, 166, 184, 167, 170, 177, 174, 171, 173, 182, 176, 180, 178,
 132     175, 189, 179, 181, 186, 183, 192, 185, 200, 187, 191, 188, 190, 197, 193, 196,
 133     197, 194, 195, 196, 198, 202, 199, 201, 210, 203, 207, 204, 205, 206, 208, 214,
 134     209, 211, 221, 212, 213, 215, 224, 216, 217, 218, 219, 220, 222, 228, 223, 225,
 135     226, 224, 227, 229, 240, 230, 231, 232, 233, 234, 235, 236, 238, 239, 237, 242,
 136     241, 243, 242, 244, 245, 246, 247, 248, 249, 250, 251, 252, 252, 253, 254, 255,
 137 };
 138
 139 static void find_best_state(uint8_t best_state[256][256],
 140                             const uint8_t one_state[256])
 141 {
 142     int i, j, k, m;
 143     double l2tab[256];
 144
 145     for (i = 1; i < 256; i++)
 146         l2tab[i] = log2(i / 256.0);
 147
 148     for (i = 0; i < 256; i++) {
 149         double best_len[256];
 150         double p = i / 256.0;
 151
 152         for (j = 0; j < 256; j++)
 153             best_len[j] = 1 << 30;
 154
 155         for (j = FFMAX(i - 10, 1); j < FFMIN(i + 11, 256); j++) {
 156             double occ[256] = { 0 };
 157             double len      = 0;
 158             occ[j] = 1.0;
 159
 160             if (!one_state[j])
 161                 continue;
 162
 163             for (k = 0; k < 256; k++) {
 164                 double newocc[256] = { 0 };
 165                 for (m = 1; m < 256; m++)
 166                     if (occ[m]) {
 167                         len -=occ[m]*(     p *l2tab[    m]
 168                                       + (1-p)*l2tab[256-m]);
 169                     }
 170                 if (len < best_len[k]) {
 171                     best_len[k]      = len;
 172                     best_state[i][k] = j;
 173                 }
 174                 for (m = 1; m < 256; m++)
 175                     if (occ[m]) {
 176                         newocc[      one_state[      m]] += occ[m] * p;
 177                         newocc[256 - one_state[256 - m]] += occ[m] * (1 - p);
 178                     }
 179                 memcpy(occ, newocc, sizeof(occ));
 180             }
 181         }
 182     }
 183 }
 184
 185 static av_always_inline av_flatten void put_symbol_inline(RangeCoder *c,
 186                                                           uint8_t *state, int v,
 187                                                           int is_signed,
 188                                                           uint64_t rc_stat[256][2],
 189                                                           uint64_t rc_stat2[32][2])
 190 {
 191     int i;
 192
 193 #define put_rac(C, S, B)                        \
 194     do {                                        \
 195         if (rc_stat) {                          \
 196             rc_stat[*(S)][B]++;                 \
 197             rc_stat2[(S) - state][B]++;         \
 198         }                                       \
 199         put_rac(C, S, B);                       \
 200     } while (0)
 201
 202     if (v) {
 203         const int a = FFABS(v);
 204         const int e = av_log2(a);
 205         put_rac(c, state + 0, 0);
 206         if (e <= 9) {
 207             for (i = 0; i < e; i++)
 208                 put_rac(c, state + 1 + i, 1);  // 1..10
 209             put_rac(c, state + 1 + i, 0);
 210
 211             for (i = e - 1; i >= 0; i--)
 212                 put_rac(c, state + 22 + i, (a >> i) & 1);  // 22..31
 213
 214             if (is_signed)
 215                 put_rac(c, state + 11 + e, v < 0);  // 11..21
 216         } else {
 217             for (i = 0; i < e; i++)
 218                 put_rac(c, state + 1 + FFMIN(i, 9), 1);  // 1..10
 219             put_rac(c, state + 1 + 9, 0);
 220
 221             for (i = e - 1; i >= 0; i--)
 222                 put_rac(c, state + 22 + FFMIN(i, 9), (a >> i) & 1);  // 22..31
 223
 224             if (is_signed)
 225                 put_rac(c, state + 11 + 10, v < 0);  // 11..21
 226         }
 227     } else {
 228         put_rac(c, state + 0, 1);
 229     }
 230 #undef put_rac
 231 }
 232
 233 static av_noinline void put_symbol(RangeCoder *c, uint8_t *state,
 234                                    int v, int is_signed)
 235 {
 236     put_symbol_inline(c, state, v, is_signed, NULL, NULL);
 237 }
 238
 239
 240 static inline void put_vlc_symbol(PutBitContext *pb, VlcState *const state,
 241                                   int v, int bits)
 242 {
 243     int i, k, code;
 244     v = fold(v - state->bias, bits);
 245
 246     i = state->count;
 247     k = 0;
 248     while (i < state->error_sum) { // FIXME: optimize
 249         k++;
 250         i += i;
 251     }
 252
 253     av_assert2(k <= 13);
 254
 255 #if 0 // JPEG LS
 256     if (k == 0 && 2 * state->drift <= -state->count)
 257         code = v ^ (-1);
 258     else
 259         code = v;
 260 #else
 261     code = v ^ ((2 * state->drift + state->count) >> 31);
 262 #endif
 263
 264     ff_dlog(NULL, "v:%d/%d bias:%d error:%d drift:%d count:%d k:%d\n", v, code,
 265             state->bias, state->error_sum, state->drift, state->count, k);
 266     set_sr_golomb(pb, code, k, 12, bits);
 267
 268     update_vlc_state(state, v);
 269 }
 270
 271 #define TYPE int16_t
 272 #define RENAME(name) name
 273 #include "ffv1enc_template.c"
 274 #undef TYPE
 275 #undef RENAME
 276
 277 #define TYPE int32_t
 278 #define RENAME(name) name ## 32
 279 #include "ffv1enc_template.c"
 280
 281 static int encode_plane(FFV1Context *s, uint8_t *src, int w, int h,
 282                          int stride, int plane_index, int pixel_stride)
 283 {
 284     int x, y, i, ret;
 285     const int ring_size = s->context_model ? 3 : 2;
 286     int16_t *sample[3];
 287     s->run_index = 0;
 288
 289     memset(s->sample_buffer, 0, ring_size * (w + 6) * sizeof(*s->sample_buffer));
 290
 291     for (y = 0; y < h; y++) {
 292         for (i = 0; i < ring_size; i++)
 293             sample[i] = s->sample_buffer + (w + 6) * ((h + i - y) % ring_size) + 3;
 294
 295         sample[0][-1]= sample[1][0  ];
 296         sample[1][ w]= sample[1][w-1];
 297 // { START_TIMER
 298         if (s->bits_per_raw_sample <= 8) {
 299             for (x = 0; x < w; x++)
 300                 sample[0][x] = src[x * pixel_stride + stride * y];
 301             if((ret = encode_line(s, w, sample, plane_index, 8)) < 0)
 302                 return ret;
 303         } else {
 304             if (s->packed_at_lsb) {
 305                 for (x = 0; x < w; x++) {
 306                     sample[0][x] = ((uint16_t*)(src + stride*y))[x];
 307                 }
 308             } else {
 309                 for (x = 0; x < w; x++) {
 310                     sample[0][x] = ((uint16_t*)(src + stride*y))[x] >> (16 - s->bits_per_raw_sample);
 311                 }
 312             }
 313             if((ret = encode_line(s, w, sample, plane_index, s->bits_per_raw_sample)) < 0)
 314                 return ret;
 315         }
 316 // STOP_TIMER("encode line") }
 317     }
 318     return 0;
 319 }
 320
 321 static void write_quant_table(RangeCoder *c, int16_t *quant_table)
 322 {
 323     int last = 0;
 324     int i;
 325     uint8_t state[CONTEXT_SIZE];
 326     memset(state, 128, sizeof(state));
 327
 328     for (i = 1; i < 128; i++)
 329         if (quant_table[i] != quant_table[i - 1]) {
 330             put_symbol(c, state, i - last - 1, 0);
 331             last = i;
 332         }
 333     put_symbol(c, state, i - last - 1, 0);
 334 }
 335
 336 static void write_quant_tables(RangeCoder *c,
 337                                int16_t quant_table[MAX_CONTEXT_INPUTS][256])
 338 {
 339     int i;
 340     for (i = 0; i < 5; i++)
 341         write_quant_table(c, quant_table[i]);
 342 }
 343
 344 static void write_header(FFV1Context *f)
 345 {
 346     uint8_t state[CONTEXT_SIZE];
 347     int i, j;
 348     RangeCoder *const c = &f->slice_context[0]->c;
 349
 350     memset(state, 128, sizeof(state));
 351
 352     if (f->version < 2) {
 353         put_symbol(c, state, f->version, 0);
 354         put_symbol(c, state, f->ac, 0);
 355         if (f->ac == AC_RANGE_CUSTOM_TAB) {
 356             for (i = 1; i < 256; i++)
 357                 put_symbol(c, state,
 358                            f->state_transition[i] - c->one_state[i], 1);
 359         }
 360         put_symbol(c, state, f->colorspace, 0); //YUV cs type
 361         if (f->version > 0)
 362             put_symbol(c, state, f->bits_per_raw_sample, 0);
 363         put_rac(c, state, f->chroma_planes);
 364         put_symbol(c, state, f->chroma_h_shift, 0);
 365         put_symbol(c, state, f->chroma_v_shift, 0);
 366         put_rac(c, state, f->transparency);
 367
 368         write_quant_tables(c, f->quant_table);
 369     } else if (f->version < 3) {
 370         put_symbol(c, state, f->slice_count, 0);
 371         for (i = 0; i < f->slice_count; i++) {
 372             FFV1Context *fs = f->slice_context[i];
 373             put_symbol(c, state,
 374                        (fs->slice_x      + 1) * f->num_h_slices / f->width, 0);
 375             put_symbol(c, state,
 376                        (fs->slice_y      + 1) * f->num_v_slices / f->height, 0);
 377             put_symbol(c, state,
 378                        (fs->slice_width  + 1) * f->num_h_slices / f->width - 1,
 379                        0);
 380             put_symbol(c, state,
 381                        (fs->slice_height + 1) * f->num_v_slices / f->height - 1,
 382                        0);
 383             for (j = 0; j < f->plane_count; j++) {
 384                 put_symbol(c, state, f->plane[j].quant_table_index, 0);
 385                 av_assert0(f->plane[j].quant_table_index == f->context_model);
 386             }
 387         }
 388     }
 389 }
 390
 391 static int write_extradata(FFV1Context *f)
 392 {
 393     RangeCoder *const c = &f->c;
 394     uint8_t state[CONTEXT_SIZE];
 395     int i, j, k;
 396     uint8_t state2[32][CONTEXT_SIZE];
 397     unsigned v;
 398
 399     memset(state2, 128, sizeof(state2));
 400     memset(state, 128, sizeof(state));
 401
 402     f->avctx->extradata_size = 10000 + 4 +
 403                                     (11 * 11 * 5 * 5 * 5 + 11 * 11 * 11) * 32;
 404     f->avctx->extradata = av_malloc(f->avctx->extradata_size + AV_INPUT_BUFFER_PADDING_SIZE);
 405     if (!f->avctx->extradata)
 406         return AVERROR(ENOMEM);
 407     ff_init_range_encoder(c, f->avctx->extradata, f->avctx->extradata_size);
 408     ff_build_rac_states(c, 0.05 * (1LL << 32), 256 - 8);
 409
 410     put_symbol(c, state, f->version, 0);
 411     if (f->version > 2) {
 412         if (f->version == 3) {
 413             f->micro_version = 4;
 414         } else if (f->version == 4)
 415             f->micro_version = 2;
 416         put_symbol(c, state, f->micro_version, 0);
 417     }
 418
 419     put_symbol(c, state, f->ac, 0);
 420     if (f->ac == AC_RANGE_CUSTOM_TAB)
 421         for (i = 1; i < 256; i++)
 422             put_symbol(c, state, f->state_transition[i] - c->one_state[i], 1);
 423
 424     put_symbol(c, state, f->colorspace, 0); // YUV cs type
 425     put_symbol(c, state, f->bits_per_raw_sample, 0);
 426     put_rac(c, state, f->chroma_planes);
 427     put_symbol(c, state, f->chroma_h_shift, 0);
 428     put_symbol(c, state, f->chroma_v_shift, 0);
 429     put_rac(c, state, f->transparency);
 430     put_symbol(c, state, f->num_h_slices - 1, 0);
 431     put_symbol(c, state, f->num_v_slices - 1, 0);
 432
 433     put_symbol(c, state, f->quant_table_count, 0);
 434     for (i = 0; i < f->quant_table_count; i++)
 435         write_quant_tables(c, f->quant_tables[i]);
 436
 437     for (i = 0; i < f->quant_table_count; i++) {
 438         for (j = 0; j < f->context_count[i] * CONTEXT_SIZE; j++)
 439             if (f->initial_states[i] && f->initial_states[i][0][j] != 128)
 440                 break;
 441         if (j < f->context_count[i] * CONTEXT_SIZE) {
 442             put_rac(c, state, 1);
 443             for (j = 0; j < f->context_count[i]; j++)
 444                 for (k = 0; k < CONTEXT_SIZE; k++) {
 445                     int pred = j ? f->initial_states[i][j - 1][k] : 128;
 446                     put_symbol(c, state2[k],
 447                                (int8_t)(f->initial_states[i][j][k] - pred), 1);
 448                 }
 449         } else {
 450             put_rac(c, state, 0);
 451         }
 452     }
 453
 454     if (f->version > 2) {
 455         put_symbol(c, state, f->ec, 0);
 456         put_symbol(c, state, f->intra = (f->avctx->gop_size < 2), 0);
 457     }
 458
 459     f->avctx->extradata_size = ff_rac_terminate(c);
 460     v = av_crc(av_crc_get_table(AV_CRC_32_IEEE), 0, f->avctx->extradata, f->avctx->extradata_size);
 461     AV_WL32(f->avctx->extradata + f->avctx->extradata_size, v);
 462     f->avctx->extradata_size += 4;
 463
 464     return 0;
 465 }
 466
 467 static int sort_stt(FFV1Context *s, uint8_t stt[256])
 468 {
 469     int i, i2, changed, print = 0;
 470
 471     do {
 472         changed = 0;
 473         for (i = 12; i < 244; i++) {
 474             for (i2 = i + 1; i2 < 245 && i2 < i + 4; i2++) {
 475
 476 #define COST(old, new)                                      \
 477     s->rc_stat[old][0] * -log2((256 - (new)) / 256.0) +     \
 478     s->rc_stat[old][1] * -log2((new)         / 256.0)
 479
 480 #define COST2(old, new)                         \
 481     COST(old, new) + COST(256 - (old), 256 - (new))
 482
 483                 double size0 = COST2(i,  i) + COST2(i2, i2);
 484                 double sizeX = COST2(i, i2) + COST2(i2, i);
 485                 if (size0 - sizeX > size0*(1e-14) && i != 128 && i2 != 128) {
 486                     int j;
 487                     FFSWAP(int, stt[i], stt[i2]);
 488                     FFSWAP(int, s->rc_stat[i][0], s->rc_stat[i2][0]);
 489                     FFSWAP(int, s->rc_stat[i][1], s->rc_stat[i2][1]);
 490                     if (i != 256 - i2) {
 491                         FFSWAP(int, stt[256 - i], stt[256 - i2]);
 492                         FFSWAP(int, s->rc_stat[256 - i][0], s->rc_stat[256 - i2][0]);
 493                         FFSWAP(int, s->rc_stat[256 - i][1], s->rc_stat[256 - i2][1]);
 494                     }
 495                     for (j = 1; j < 256; j++) {
 496                         if (stt[j] == i)
 497                             stt[j] = i2;
 498                         else if (stt[j] == i2)
 499                             stt[j] = i;
 500                         if (i != 256 - i2) {
 501                             if (stt[256 - j] == 256 - i)
 502                                 stt[256 - j] = 256 - i2;
 503                             else if (stt[256 - j] == 256 - i2)
 504                                 stt[256 - j] = 256 - i;
 505                         }
 506                     }
 507                     print = changed = 1;
 508                 }
 509             }
 510         }
 511     } while (changed);
 512     return print;
 513 }
 514
 515 static av_cold int encode_init(AVCodecContext *avctx)
 516 {
 517     FFV1Context *s = avctx->priv_data;
 518     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(avctx->pix_fmt);
 519     int i, j, k, m, ret;
 520
 521     if ((ret = ff_ffv1_common_init(avctx)) < 0)
 522         return ret;
 523
 524     s->version = 0;
 525
 526     if ((avctx->flags & (AV_CODEC_FLAG_PASS1 | AV_CODEC_FLAG_PASS2)) ||
 527         avctx->slices > 1)
 528         s->version = FFMAX(s->version, 2);
 529
 530     // Unspecified level & slices, we choose version 1.2+ to ensure multithreaded decodability
 531     if (avctx->slices == 0 && avctx->level < 0 && avctx->width * avctx->height > 720*576)
 532         s->version = FFMAX(s->version, 2);
 533
 534     if (avctx->level <= 0 && s->version == 2) {
 535         s->version = 3;
 536     }
 537     if (avctx->level >= 0 && avctx->level <= 4) {
 538         if (avctx->level < s->version) {
 539             av_log(avctx, AV_LOG_ERROR, "Version %d needed for requested features but %d requested\n", s->version, avctx->level);
 540             return AVERROR(EINVAL);
 541         }
 542         s->version = avctx->level;
 543     }
 544
 545     if (s->ec < 0) {
 546         s->ec = (s->version >= 3);
 547     }
 548
 549     if ((s->version == 2 || s->version>3) && avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
 550         av_log(avctx, AV_LOG_ERROR, "Version 2 needed for requested features but version 2 is experimental and not enabled\n");
 551         return AVERROR_INVALIDDATA;
 552     }
 553
 554 #if FF_API_CODER_TYPE
 555 FF_DISABLE_DEPRECATION_WARNINGS
 556     if (avctx->coder_type != -1)
 557         s->ac = avctx->coder_type > 0 ? AC_RANGE_CUSTOM_TAB : AC_GOLOMB_RICE;
 558     else
 559 FF_ENABLE_DEPRECATION_WARNINGS
 560 #endif
 561     if (s->ac == 1) // Compatbility with common command line usage
 562         s->ac = AC_RANGE_CUSTOM_TAB;
 563     else if (s->ac == AC_RANGE_DEFAULT_TAB_FORCE)
 564         s->ac = AC_RANGE_DEFAULT_TAB;
 565
 566     s->plane_count = 3;
 567     switch(avctx->pix_fmt) {
 568     case AV_PIX_FMT_YUV444P9:
 569     case AV_PIX_FMT_YUV422P9:
 570     case AV_PIX_FMT_YUV420P9:
 571     case AV_PIX_FMT_YUVA444P9:
 572     case AV_PIX_FMT_YUVA422P9:
 573     case AV_PIX_FMT_YUVA420P9:
 574         if (!avctx->bits_per_raw_sample)
 575             s->bits_per_raw_sample = 9;
 576     case AV_PIX_FMT_GRAY10:
 577     case AV_PIX_FMT_YUV444P10:
 578     case AV_PIX_FMT_YUV420P10:
 579     case AV_PIX_FMT_YUV422P10:
 580     case AV_PIX_FMT_YUVA444P10:
 581     case AV_PIX_FMT_YUVA422P10:
 582     case AV_PIX_FMT_YUVA420P10:
 583         if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
 584             s->bits_per_raw_sample = 10;
 585     case AV_PIX_FMT_GRAY12:
 586     case AV_PIX_FMT_YUV444P12:
 587     case AV_PIX_FMT_YUV420P12:
 588     case AV_PIX_FMT_YUV422P12:
 589         s->packed_at_lsb = 1;
 590         if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
 591             s->bits_per_raw_sample = 12;
 592     case AV_PIX_FMT_GRAY16:
 593     case AV_PIX_FMT_YUV444P16:
 594     case AV_PIX_FMT_YUV422P16:
 595     case AV_PIX_FMT_YUV420P16:
 596     case AV_PIX_FMT_YUVA444P16:
 597     case AV_PIX_FMT_YUVA422P16:
 598     case AV_PIX_FMT_YUVA420P16:
 599         if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample) {
 600             s->bits_per_raw_sample = 16;
 601         } else if (!s->bits_per_raw_sample) {
 602             s->bits_per_raw_sample = avctx->bits_per_raw_sample;
 603         }
 604         if (s->bits_per_raw_sample <= 8) {
 605             av_log(avctx, AV_LOG_ERROR, "bits_per_raw_sample invalid\n");
 606             return AVERROR_INVALIDDATA;
 607         }
 608         s->version = FFMAX(s->version, 1);
 609     case AV_PIX_FMT_GRAY8:
 610     case AV_PIX_FMT_YA8:
 611     case AV_PIX_FMT_YUV444P:
 612     case AV_PIX_FMT_YUV440P:
 613     case AV_PIX_FMT_YUV422P:
 614     case AV_PIX_FMT_YUV420P:
 615     case AV_PIX_FMT_YUV411P:
 616     case AV_PIX_FMT_YUV410P:
 617     case AV_PIX_FMT_YUVA444P:
 618     case AV_PIX_FMT_YUVA422P:
 619     case AV_PIX_FMT_YUVA420P:
 620         s->chroma_planes = desc->nb_components < 3 ? 0 : 1;
 621         s->colorspace = 0;
 622         s->transparency = desc->nb_components == 4 || desc->nb_components == 2;
 623         if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
 624             s->bits_per_raw_sample = 8;
 625         else if (!s->bits_per_raw_sample)
 626             s->bits_per_raw_sample = 8;
 627         break;
 628     case AV_PIX_FMT_RGB32:
 629         s->colorspace = 1;
 630         s->transparency = 1;
 631         s->chroma_planes = 1;
 632         s->bits_per_raw_sample = 8;
 633         break;
 634     case AV_PIX_FMT_RGB48:
 635         s->colorspace = 1;
 636         s->chroma_planes = 1;
 637         s->bits_per_raw_sample = 16;
 638         s->use32bit = 1;
 639         s->version = FFMAX(s->version, 1);
 640         if (avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
 641             av_log(avctx, AV_LOG_ERROR, "16bit RGB is experimental and under development, only use it for experiments\n");
 642             return AVERROR_INVALIDDATA;
 643         }
 644         break;
 645     case AV_PIX_FMT_0RGB32:
 646         s->colorspace = 1;
 647         s->chroma_planes = 1;
 648         s->bits_per_raw_sample = 8;
 649         break;
 650     case AV_PIX_FMT_GBRP9:
 651         if (!avctx->bits_per_raw_sample)
 652             s->bits_per_raw_sample = 9;
 653     case AV_PIX_FMT_GBRP10:
 654         if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
 655             s->bits_per_raw_sample = 10;
 656     case AV_PIX_FMT_GBRP12:
 657         if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
 658             s->bits_per_raw_sample = 12;
 659     case AV_PIX_FMT_GBRP14:
 660         if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
 661             s->bits_per_raw_sample = 14;
 662     case AV_PIX_FMT_GBRP16:
 663         if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
 664             s->bits_per_raw_sample = 16;
 665         else if (!s->bits_per_raw_sample)
 666             s->bits_per_raw_sample = avctx->bits_per_raw_sample;
 667         s->colorspace = 1;
 668         s->chroma_planes = 1;
 669         if (s->bits_per_raw_sample >= 16) {
 670             s->use32bit = 1;
 671             if (avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
 672                 av_log(avctx, AV_LOG_ERROR, "16bit RGB is experimental and under development, only use it for experiments\n");
 673                 return AVERROR_INVALIDDATA;
 674             }
 675         }
 676         s->version = FFMAX(s->version, 1);
 677         break;
 678     default:
 679         av_log(avctx, AV_LOG_ERROR, "format not supported\n");
 680         return AVERROR(ENOSYS);
 681     }
 682     av_assert0(s->bits_per_raw_sample >= 8);
 683
 684     if (s->bits_per_raw_sample > 8) {
 685         if (s->ac == AC_GOLOMB_RICE) {
 686             av_log(avctx, AV_LOG_INFO,
 687                     "bits_per_raw_sample > 8, forcing range coder\n");
 688             s->ac = AC_RANGE_CUSTOM_TAB;
 689         }
 690     }
 691     if (s->transparency) {
 692         av_log(avctx, AV_LOG_WARNING, "Storing alpha plane, this will require a recent FFV1 decoder to playback!\n");
 693     }
 694 #if FF_API_PRIVATE_OPT
 695 FF_DISABLE_DEPRECATION_WARNINGS
 696     if (avctx->context_model)
 697         s->context_model = avctx->context_model;
 698     if (avctx->context_model > 1U) {
 699         av_log(avctx, AV_LOG_ERROR, "Invalid context model %d, valid values are 0 and 1\n", avctx->context_model);
 700         return AVERROR(EINVAL);
 701     }
 702 FF_ENABLE_DEPRECATION_WARNINGS
 703 #endif
 704
 705     if (s->ac == AC_RANGE_CUSTOM_TAB) {
 706         for (i = 1; i < 256; i++)
 707             s->state_transition[i] = ver2_state[i];
 708     } else {
 709         RangeCoder c;
 710         ff_build_rac_states(&c, 0.05 * (1LL << 32), 256 - 8);
 711         for (i = 1; i < 256; i++)
 712             s->state_transition[i] = c.one_state[i];
 713     }
 714
 715     for (i = 0; i < 256; i++) {
 716         s->quant_table_count = 2;
 717         if (s->bits_per_raw_sample <= 8) {
 718             s->quant_tables[0][0][i]=           quant11[i];
 719             s->quant_tables[0][1][i]=        11*quant11[i];
 720             s->quant_tables[0][2][i]=     11*11*quant11[i];
 721             s->quant_tables[1][0][i]=           quant11[i];
 722             s->quant_tables[1][1][i]=        11*quant11[i];
 723             s->quant_tables[1][2][i]=     11*11*quant5 [i];
 724             s->quant_tables[1][3][i]=   5*11*11*quant5 [i];
 725             s->quant_tables[1][4][i]= 5*5*11*11*quant5 [i];
 726         } else {
 727             s->quant_tables[0][0][i]=           quant9_10bit[i];
 728             s->quant_tables[0][1][i]=        11*quant9_10bit[i];
 729             s->quant_tables[0][2][i]=     11*11*quant9_10bit[i];
 730             s->quant_tables[1][0][i]=           quant9_10bit[i];
 731             s->quant_tables[1][1][i]=        11*quant9_10bit[i];
 732             s->quant_tables[1][2][i]=     11*11*quant5_10bit[i];
 733             s->quant_tables[1][3][i]=   5*11*11*quant5_10bit[i];
 734             s->quant_tables[1][4][i]= 5*5*11*11*quant5_10bit[i];
 735         }
 736     }
 737     s->context_count[0] = (11 * 11 * 11        + 1) / 2;
 738     s->context_count[1] = (11 * 11 * 5 * 5 * 5 + 1) / 2;
 739     memcpy(s->quant_table, s->quant_tables[s->context_model],
 740            sizeof(s->quant_table));
 741
 742     for (i = 0; i < s->plane_count; i++) {
 743         PlaneContext *const p = &s->plane[i];
 744
 745         memcpy(p->quant_table, s->quant_table, sizeof(p->quant_table));
 746         p->quant_table_index = s->context_model;
 747         p->context_count     = s->context_count[p->quant_table_index];
 748     }
 749
 750     if ((ret = ff_ffv1_allocate_initial_states(s)) < 0)
 751         return ret;
 752
 753 #if FF_API_CODED_FRAME
 754 FF_DISABLE_DEPRECATION_WARNINGS
 755     avctx->coded_frame->pict_type = AV_PICTURE_TYPE_I;
 756 FF_ENABLE_DEPRECATION_WARNINGS
 757 #endif
 758
 759     if (!s->transparency)
 760         s->plane_count = 2;
 761     if (!s->chroma_planes && s->version > 3)
 762         s->plane_count--;
 763
 764     avcodec_get_chroma_sub_sample(avctx->pix_fmt, &s->chroma_h_shift, &s->chroma_v_shift);
 765     s->picture_number = 0;
 766
 767     if (avctx->flags & (AV_CODEC_FLAG_PASS1 | AV_CODEC_FLAG_PASS2)) {
 768         for (i = 0; i < s->quant_table_count; i++) {
 769             s->rc_stat2[i] = av_mallocz(s->context_count[i] *
 770                                         sizeof(*s->rc_stat2[i]));
 771             if (!s->rc_stat2[i])
 772                 return AVERROR(ENOMEM);
 773         }
 774     }
 775     if (avctx->stats_in) {
 776         char *p = avctx->stats_in;
 777         uint8_t (*best_state)[256] = av_malloc_array(256, 256);
 778         int gob_count = 0;
 779         char *next;
 780         if (!best_state)
 781             return AVERROR(ENOMEM);
 782
 783         av_assert0(s->version >= 2);
 784
 785         for (;;) {
 786             for (j = 0; j < 256; j++)
 787                 for (i = 0; i < 2; i++) {
 788                     s->rc_stat[j][i] = strtol(p, &next, 0);
 789                     if (next == p) {
 790                         av_log(avctx, AV_LOG_ERROR,
 791                                "2Pass file invalid at %d %d [%s]\n", j, i, p);
 792                         av_freep(&best_state);
 793                         return AVERROR_INVALIDDATA;
 794                     }
 795                     p = next;
 796                 }
 797             for (i = 0; i < s->quant_table_count; i++)
 798                 for (j = 0; j < s->context_count[i]; j++) {
 799                     for (k = 0; k < 32; k++)
 800                         for (m = 0; m < 2; m++) {
 801                             s->rc_stat2[i][j][k][m] = strtol(p, &next, 0);
 802                             if (next == p) {
 803                                 av_log(avctx, AV_LOG_ERROR,
 804                                        "2Pass file invalid at %d %d %d %d [%s]\n",
 805                                        i, j, k, m, p);
 806                                 av_freep(&best_state);
 807                                 return AVERROR_INVALIDDATA;
 808                             }
 809                             p = next;
 810                         }
 811                 }
 812             gob_count = strtol(p, &next, 0);
 813             if (next == p || gob_count <= 0) {
 814                 av_log(avctx, AV_LOG_ERROR, "2Pass file invalid\n");
 815                 av_freep(&best_state);
 816                 return AVERROR_INVALIDDATA;
 817             }
 818             p = next;
 819             while (*p == '\n' || *p == ' ')
 820                 p++;
 821             if (p[0] == 0)
 822                 break;
 823         }
 824         if (s->ac == AC_RANGE_CUSTOM_TAB)
 825             sort_stt(s, s->state_transition);
 826
 827         find_best_state(best_state, s->state_transition);
 828
 829         for (i = 0; i < s->quant_table_count; i++) {
 830             for (k = 0; k < 32; k++) {
 831                 double a=0, b=0;
 832                 int jp = 0;
 833                 for (j = 0; j < s->context_count[i]; j++) {
 834                     double p = 128;
 835                     if (s->rc_stat2[i][j][k][0] + s->rc_stat2[i][j][k][1] > 200 && j || a+b > 200) {
 836                         if (a+b)
 837                             p = 256.0 * b / (a + b);
 838                         s->initial_states[i][jp][k] =
 839                             best_state[av_clip(round(p), 1, 255)][av_clip_uint8((a + b) / gob_count)];
 840                         for(jp++; jp<j; jp++)
 841                             s->initial_states[i][jp][k] = s->initial_states[i][jp-1][k];
 842                         a=b=0;
 843                     }
 844                     a += s->rc_stat2[i][j][k][0];
 845                     b += s->rc_stat2[i][j][k][1];
 846                     if (a+b) {
 847                         p = 256.0 * b / (a + b);
 848                     }
 849                     s->initial_states[i][j][k] =
 850                         best_state[av_clip(round(p), 1, 255)][av_clip_uint8((a + b) / gob_count)];
 851                 }
 852             }
 853         }
 854         av_freep(&best_state);
 855     }
 856
 857     if (s->version > 1) {
 858         s->num_v_slices = (avctx->width > 352 || avctx->height > 288 || !avctx->slices) ? 2 : 1;
 859         for (; s->num_v_slices < 9; s->num_v_slices++) {
 860             for (s->num_h_slices = s->num_v_slices; s->num_h_slices < 2*s->num_v_slices; s->num_h_slices++) {
 861                 if (avctx->slices == s->num_h_slices * s->num_v_slices && avctx->slices <= 64 || !avctx->slices)
 862                     goto slices_ok;
 863             }
 864         }
 865         av_log(avctx, AV_LOG_ERROR,
 866                "Unsupported number %d of slices requested, please specify a "
 867                "supported number with -slices (ex:4,6,9,12,16, ...)\n",
 868                avctx->slices);
 869         return AVERROR(ENOSYS);
 870 slices_ok:
 871         if ((ret = write_extradata(s)) < 0)
 872             return ret;
 873     }
 874
 875     if ((ret = ff_ffv1_init_slice_contexts(s)) < 0)
 876         return ret;
 877     s->slice_count = s->max_slice_count;
 878     if ((ret = ff_ffv1_init_slices_state(s)) < 0)
 879         return ret;
 880
 881 #define STATS_OUT_SIZE 1024 * 1024 * 6
 882     if (avctx->flags & AV_CODEC_FLAG_PASS1) {
 883         avctx->stats_out = av_mallocz(STATS_OUT_SIZE);
 884         if (!avctx->stats_out)
 885             return AVERROR(ENOMEM);
 886         for (i = 0; i < s->quant_table_count; i++)
 887             for (j = 0; j < s->max_slice_count; j++) {
 888                 FFV1Context *sf = s->slice_context[j];
 889                 av_assert0(!sf->rc_stat2[i]);
 890                 sf->rc_stat2[i] = av_mallocz(s->context_count[i] *
 891                                              sizeof(*sf->rc_stat2[i]));
 892                 if (!sf->rc_stat2[i])
 893                     return AVERROR(ENOMEM);
 894             }
 895     }
 896
 897     return 0;
 898 }
 899
 900 static void encode_slice_header(FFV1Context *f, FFV1Context *fs)
 901 {
 902     RangeCoder *c = &fs->c;
 903     uint8_t state[CONTEXT_SIZE];
 904     int j;
 905     memset(state, 128, sizeof(state));
 906
 907     put_symbol(c, state, (fs->slice_x     +1)*f->num_h_slices / f->width   , 0);
 908     put_symbol(c, state, (fs->slice_y     +1)*f->num_v_slices / f->height  , 0);
 909     put_symbol(c, state, (fs->slice_width +1)*f->num_h_slices / f->width -1, 0);
 910     put_symbol(c, state, (fs->slice_height+1)*f->num_v_slices / f->height-1, 0);
 911     for (j=0; j<f->plane_count; j++) {
 912         put_symbol(c, state, f->plane[j].quant_table_index, 0);
 913         av_assert0(f->plane[j].quant_table_index == f->context_model);
 914     }
 915     if (!f->picture.f->interlaced_frame)
 916         put_symbol(c, state, 3, 0);
 917     else
 918         put_symbol(c, state, 1 + !f->picture.f->top_field_first, 0);
 919     put_symbol(c, state, f->picture.f->sample_aspect_ratio.num, 0);
 920     put_symbol(c, state, f->picture.f->sample_aspect_ratio.den, 0);
 921     if (f->version > 3) {
 922         put_rac(c, state, fs->slice_coding_mode == 1);
 923         if (fs->slice_coding_mode == 1)
 924             ff_ffv1_clear_slice_state(f, fs);
 925         put_symbol(c, state, fs->slice_coding_mode, 0);
 926         if (fs->slice_coding_mode != 1) {
 927             put_symbol(c, state, fs->slice_rct_by_coef, 0);
 928             put_symbol(c, state, fs->slice_rct_ry_coef, 0);
 929         }
 930     }
 931 }
 932
 933 static void choose_rct_params(FFV1Context *fs, const uint8_t *src[3], const int stride[3], int w, int h)
 934 {
 935 #define NB_Y_COEFF 15
 936     static const int rct_y_coeff[15][2] = {
 937         {0, 0}, //      4G
 938         {1, 1}, //  R + 2G + B
 939         {2, 2}, // 2R      + 2B
 940         {0, 2}, //      2G + 2B
 941         {2, 0}, // 2R + 2G
 942         {4, 0}, // 4R
 943         {0, 4}, //           4B
 944
 945         {0, 3}, //      1G + 3B
 946         {3, 0}, // 3R + 1G
 947         {3, 1}, // 3R      +  B
 948         {1, 3}, //  R      + 3B
 949         {1, 2}, //  R +  G + 2B
 950         {2, 1}, // 2R +  G +  B
 951         {0, 1}, //      3G +  B
 952         {1, 0}, //  R + 3G
 953     };
 954
 955     int stat[NB_Y_COEFF] = {0};
 956     int x, y, i, p, best;
 957     int16_t *sample[3];
 958     int lbd = fs->bits_per_raw_sample <= 8;
 959
 960     for (y = 0; y < h; y++) {
 961         int lastr=0, lastg=0, lastb=0;
 962         for (p = 0; p < 3; p++)
 963             sample[p] = fs->sample_buffer + p*w;
 964
 965         for (x = 0; x < w; x++) {
 966             int b, g, r;
 967             int ab, ag, ar;
 968             if (lbd) {
 969                 unsigned v = *((const uint32_t*)(src[0] + x*4 + stride[0]*y));
 970                 b =  v        & 0xFF;
 971                 g = (v >>  8) & 0xFF;
 972                 r = (v >> 16) & 0xFF;
 973             } else {
 974                 b = *((const uint16_t*)(src[0] + x*2 + stride[0]*y));
 975                 g = *((const uint16_t*)(src[1] + x*2 + stride[1]*y));
 976                 r = *((const uint16_t*)(src[2] + x*2 + stride[2]*y));
 977             }
 978
 979             ar = r - lastr;
 980             ag = g - lastg;
 981             ab = b - lastb;
 982             if (x && y) {
 983                 int bg = ag - sample[0][x];
 984                 int bb = ab - sample[1][x];
 985                 int br = ar - sample[2][x];
 986
 987                 br -= bg;
 988                 bb -= bg;
 989
 990                 for (i = 0; i<NB_Y_COEFF; i++) {
 991                     stat[i] += FFABS(bg + ((br*rct_y_coeff[i][0] + bb*rct_y_coeff[i][1])>>2));
 992                 }
 993
 994             }
 995             sample[0][x] = ag;
 996             sample[1][x] = ab;
 997             sample[2][x] = ar;
 998
 999             lastr = r;
1000             lastg = g;
1001             lastb = b;
1002         }
1003     }
1004
1005     best = 0;
1006     for (i=1; i<NB_Y_COEFF; i++) {
1007         if (stat[i] < stat[best])
1008             best = i;
1009     }
1010
1011     fs->slice_rct_by_coef = rct_y_coeff[best][1];
1012     fs->slice_rct_ry_coef = rct_y_coeff[best][0];
1013 }
1014
1015 static int encode_slice(AVCodecContext *c, void *arg)
1016 {
1017     FFV1Context *fs  = *(void **)arg;
1018     FFV1Context *f   = fs->avctx->priv_data;
1019     int width        = fs->slice_width;
1020     int height       = fs->slice_height;
1021     int x            = fs->slice_x;
1022     int y            = fs->slice_y;
1023     const AVFrame *const p = f->picture.f;
1024     const int ps     = av_pix_fmt_desc_get(c->pix_fmt)->comp[0].step;
1025     int ret;
1026     RangeCoder c_bak = fs->c;
1027     const uint8_t *planes[3] = {p->data[0] + ps*x + y*p->linesize[0],
1028                                 p->data[1] ? p->data[1] + ps*x + y*p->linesize[1] : NULL,
1029                                 p->data[2] ? p->data[2] + ps*x + y*p->linesize[2] : NULL};
1030
1031     fs->slice_coding_mode = 0;
1032     if (f->version > 3) {
1033         choose_rct_params(fs, planes, p->linesize, width, height);
1034     } else {
1035         fs->slice_rct_by_coef = 1;
1036         fs->slice_rct_ry_coef = 1;
1037     }
1038
1039 retry:
1040     if (f->key_frame)
1041         ff_ffv1_clear_slice_state(f, fs);
1042     if (f->version > 2) {
1043         encode_slice_header(f, fs);
1044     }
1045     if (fs->ac == AC_GOLOMB_RICE) {
1046         if (f->version > 2)
1047             put_rac(&fs->c, (uint8_t[]) { 129 }, 0);
1048         fs->ac_byte_count = f->version > 2 || (!x && !y) ? ff_rac_terminate(&fs->c) : 0;
1049         init_put_bits(&fs->pb,
1050                       fs->c.bytestream_start + fs->ac_byte_count,
1051                       fs->c.bytestream_end - fs->c.bytestream_start - fs->ac_byte_count);
1052     }
1053
1054     if (f->colorspace == 0 && c->pix_fmt != AV_PIX_FMT_YA8) {
1055         const int chroma_width  = AV_CEIL_RSHIFT(width,  f->chroma_h_shift);
1056         const int chroma_height = AV_CEIL_RSHIFT(height, f->chroma_v_shift);
1057         const int cx            = x >> f->chroma_h_shift;
1058         const int cy            = y >> f->chroma_v_shift;
1059
1060         ret = encode_plane(fs, p->data[0] + ps*x + y*p->linesize[0], width, height, p->linesize[0], 0, 1);
1061
1062         if (f->chroma_planes) {
1063             ret |= encode_plane(fs, p->data[1] + ps*cx+cy*p->linesize[1], chroma_width, chroma_height, p->linesize[1], 1, 1);
1064             ret |= encode_plane(fs, p->data[2] + ps*cx+cy*p->linesize[2], chroma_width, chroma_height, p->linesize[2], 1, 1);
1065         }
1066         if (fs->transparency)
1067             ret |= encode_plane(fs, p->data[3] + ps*x + y*p->linesize[3], width, height, p->linesize[3], 2, 1);
1068     } else if (c->pix_fmt == AV_PIX_FMT_YA8) {
1069         ret  = encode_plane(fs, p->data[0] +     ps*x + y*p->linesize[0], width, height, p->linesize[0], 0, 2);
1070         ret |= encode_plane(fs, p->data[0] + 1 + ps*x + y*p->linesize[0], width, height, p->linesize[0], 1, 2);
1071     } else if (f->use32bit) {
1072         ret = encode_rgb_frame32(fs, planes, width, height, p->linesize);
1073     } else {
1074         ret = encode_rgb_frame(fs, planes, width, height, p->linesize);
1075     }
1076     emms_c();
1077
1078     if (ret < 0) {
1079         av_assert0(fs->slice_coding_mode == 0);
1080         if (fs->version < 4 || !fs->ac) {
1081             av_log(c, AV_LOG_ERROR, "Buffer too small\n");
1082             return ret;
1083         }
1084         av_log(c, AV_LOG_DEBUG, "Coding slice as PCM\n");
1085         fs->slice_coding_mode = 1;
1086         fs->c = c_bak;
1087         goto retry;
1088     }
1089
1090     return 0;
1091 }
1092
1093 static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
1094                         const AVFrame *pict, int *got_packet)
1095 {
1096     FFV1Context *f      = avctx->priv_data;
1097     RangeCoder *const c = &f->slice_context[0]->c;
1098     AVFrame *const p    = f->picture.f;
1099     uint8_t keystate    = 128;
1100     uint8_t *buf_p;
1101     int i, ret;
1102     int64_t maxsize =   AV_INPUT_BUFFER_MIN_SIZE
1103                       + avctx->width*avctx->height*37LL*4;
1104
1105     if(!pict) {
1106         if (avctx->flags & AV_CODEC_FLAG_PASS1) {
1107             int j, k, m;
1108             char *p   = avctx->stats_out;
1109             char *end = p + STATS_OUT_SIZE;
1110
1111             memset(f->rc_stat, 0, sizeof(f->rc_stat));
1112             for (i = 0; i < f->quant_table_count; i++)
1113                 memset(f->rc_stat2[i], 0, f->context_count[i] * sizeof(*f->rc_stat2[i]));
1114
1115             av_assert0(f->slice_count == f->max_slice_count);
1116             for (j = 0; j < f->slice_count; j++) {
1117                 FFV1Context *fs = f->slice_context[j];
1118                 for (i = 0; i < 256; i++) {
1119                     f->rc_stat[i][0] += fs->rc_stat[i][0];
1120                     f->rc_stat[i][1] += fs->rc_stat[i][1];
1121                 }
1122                 for (i = 0; i < f->quant_table_count; i++) {
1123                     for (k = 0; k < f->context_count[i]; k++)
1124                         for (m = 0; m < 32; m++) {
1125                             f->rc_stat2[i][k][m][0] += fs->rc_stat2[i][k][m][0];
1126                             f->rc_stat2[i][k][m][1] += fs->rc_stat2[i][k][m][1];
1127                         }
1128                 }
1129             }
1130
1131             for (j = 0; j < 256; j++) {
1132                 snprintf(p, end - p, "%" PRIu64 " %" PRIu64 " ",
1133                         f->rc_stat[j][0], f->rc_stat[j][1]);
1134                 p += strlen(p);
1135             }
1136             snprintf(p, end - p, "\n");
1137
1138             for (i = 0; i < f->quant_table_count; i++) {
1139                 for (j = 0; j < f->context_count[i]; j++)
1140                     for (m = 0; m < 32; m++) {
1141                         snprintf(p, end - p, "%" PRIu64 " %" PRIu64 " ",
1142                                 f->rc_stat2[i][j][m][0], f->rc_stat2[i][j][m][1]);
1143                         p += strlen(p);
1144                     }
1145             }
1146             snprintf(p, end - p, "%d\n", f->gob_count);
1147         }
1148         return 0;
1149     }
1150
1151     if (f->version > 3)
1152         maxsize = AV_INPUT_BUFFER_MIN_SIZE + avctx->width*avctx->height*3LL*4;
1153
1154     if (maxsize > INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE - 32) {
1155         av_log(avctx, AV_LOG_WARNING, "Cannot allocate worst case packet size, the encoding could fail\n");
1156         maxsize = INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE - 32;
1157     }
1158
1159     if ((ret = ff_alloc_packet2(avctx, pkt, maxsize, 0)) < 0)
1160         return ret;
1161
1162     ff_init_range_encoder(c, pkt->data, pkt->size);
1163     ff_build_rac_states(c, 0.05 * (1LL << 32), 256 - 8);
1164
1165     av_frame_unref(p);
1166     if ((ret = av_frame_ref(p, pict)) < 0)
1167         return ret;
1168 #if FF_API_CODED_FRAME
1169 FF_DISABLE_DEPRECATION_WARNINGS
1170     avctx->coded_frame->pict_type = AV_PICTURE_TYPE_I;
1171 FF_ENABLE_DEPRECATION_WARNINGS
1172 #endif
1173
1174     if (avctx->gop_size == 0 || f->picture_number % avctx->gop_size == 0) {
1175         put_rac(c, &keystate, 1);
1176         f->key_frame = 1;
1177         f->gob_count++;
1178         write_header(f);
1179     } else {
1180         put_rac(c, &keystate, 0);
1181         f->key_frame = 0;
1182     }
1183
1184     if (f->ac == AC_RANGE_CUSTOM_TAB) {
1185         int i;
1186         for (i = 1; i < 256; i++) {
1187             c->one_state[i]        = f->state_transition[i];
1188             c->zero_state[256 - i] = 256 - c->one_state[i];
1189         }
1190     }
1191
1192     for (i = 0; i < f->slice_count; i++) {
1193         FFV1Context *fs = f->slice_context[i];
1194         uint8_t *start  = pkt->data + pkt->size * (int64_t)i / f->slice_count;
1195         int len         = pkt->size / f->slice_count;
1196         if (i) {
1197             ff_init_range_encoder(&fs->c, start, len);
1198         } else {
1199             av_assert0(fs->c.bytestream_end >= fs->c.bytestream_start + len);
1200             av_assert0(fs->c.bytestream < fs->c.bytestream_start + len);
1201             fs->c.bytestream_end = fs->c.bytestream_start + len;
1202         }
1203     }
1204     avctx->execute(avctx, encode_slice, &f->slice_context[0], NULL,
1205                    f->slice_count, sizeof(void *));
1206
1207     buf_p = pkt->data;
1208     for (i = 0; i < f->slice_count; i++) {
1209         FFV1Context *fs = f->slice_context[i];
1210         int bytes;
1211
1212         if (fs->ac != AC_GOLOMB_RICE) {
1213             uint8_t state = 129;
1214             put_rac(&fs->c, &state, 0);
1215             bytes = ff_rac_terminate(&fs->c);
1216         } else {
1217             flush_put_bits(&fs->pb); // FIXME: nicer padding
1218             bytes = fs->ac_byte_count + (put_bits_count(&fs->pb) + 7) / 8;
1219         }
1220         if (i > 0 || f->version > 2) {
1221             av_assert0(bytes < pkt->size / f->slice_count);
1222             memmove(buf_p, fs->c.bytestream_start, bytes);
1223             av_assert0(bytes < (1 << 24));
1224             AV_WB24(buf_p + bytes, bytes);
1225             bytes += 3;
1226         }
1227         if (f->ec) {
1228             unsigned v;
1229             buf_p[bytes++] = 0;
1230             v = av_crc(av_crc_get_table(AV_CRC_32_IEEE), 0, buf_p, bytes);
1231             AV_WL32(buf_p + bytes, v);
1232             bytes += 4;
1233         }
1234         buf_p += bytes;
1235     }
1236
1237     if (avctx->flags & AV_CODEC_FLAG_PASS1)
1238         avctx->stats_out[0] = '\0';
1239
1240 #if FF_API_CODED_FRAME
1241 FF_DISABLE_DEPRECATION_WARNINGS
1242     avctx->coded_frame->key_frame = f->key_frame;
1243 FF_ENABLE_DEPRECATION_WARNINGS
1244 #endif
1245
1246     f->picture_number++;
1247     pkt->size   = buf_p - pkt->data;
1248     pkt->pts    =
1249     pkt->dts    = pict->pts;
1250     pkt->flags |= AV_PKT_FLAG_KEY * f->key_frame;
1251     *got_packet = 1;
1252
1253     return 0;
1254 }
1255
1256 static av_cold int encode_close(AVCodecContext *avctx)
1257 {
1258     ff_ffv1_close(avctx);
1259     return 0;
1260 }
1261
1262 #define OFFSET(x) offsetof(FFV1Context, x)
1263 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
1264 static const AVOption options[] = {
1265     { "slicecrc", "Protect slices with CRCs", OFFSET(ec), AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, VE },
1266     { "coder", "Coder type", OFFSET(ac), AV_OPT_TYPE_INT,
1267             { .i64 = 0 }, -2, 2, VE, "coder" },
1268         { "rice", "Golomb rice", 0, AV_OPT_TYPE_CONST,
1269             { .i64 = AC_GOLOMB_RICE }, INT_MIN, INT_MAX, VE, "coder" },
1270         { "range_def", "Range with default table", 0, AV_OPT_TYPE_CONST,
1271             { .i64 = AC_RANGE_DEFAULT_TAB_FORCE }, INT_MIN, INT_MAX, VE, "coder" },
1272         { "range_tab", "Range with custom table", 0, AV_OPT_TYPE_CONST,
1273             { .i64 = AC_RANGE_CUSTOM_TAB }, INT_MIN, INT_MAX, VE, "coder" },
1274         { "ac", "Range with custom table (the ac option exists for compatibility and is deprecated)", 0, AV_OPT_TYPE_CONST,
1275             { .i64 = 1 }, INT_MIN, INT_MAX, VE, "coder" },
1276     { "context", "Context model", OFFSET(context_model), AV_OPT_TYPE_INT,
1277             { .i64 = 0 }, 0, 1, VE },
1278
1279     { NULL }
1280 };
1281
1282 static const AVClass ffv1_class = {
1283     .class_name = "ffv1 encoder",
1284     .item_name  = av_default_item_name,
1285     .option     = options,
1286     .version    = LIBAVUTIL_VERSION_INT,
1287 };
1288
1289 #if FF_API_CODER_TYPE
1290 static const AVCodecDefault ffv1_defaults[] = {
1291     { "coder", "-1" },
1292     { NULL },
1293 };
1294 #endif
1295
1296 AVCodec ff_ffv1_encoder = {
1297     .name           = "ffv1",
1298     .long_name      = NULL_IF_CONFIG_SMALL("FFmpeg video codec #1"),
1299     .type           = AVMEDIA_TYPE_VIDEO,
1300     .id             = AV_CODEC_ID_FFV1,
1301     .priv_data_size = sizeof(FFV1Context),
1302     .init           = encode_init,
1303     .encode2        = encode_frame,
1304     .close          = encode_close,
1305     .capabilities   = AV_CODEC_CAP_SLICE_THREADS | AV_CODEC_CAP_DELAY,
1306     .pix_fmts       = (const enum AVPixelFormat[]) {
1307         AV_PIX_FMT_YUV420P,   AV_PIX_FMT_YUVA420P,  AV_PIX_FMT_YUVA422P,  AV_PIX_FMT_YUV444P,
1308         AV_PIX_FMT_YUVA444P,  AV_PIX_FMT_YUV440P,   AV_PIX_FMT_YUV422P,   AV_PIX_FMT_YUV411P,
1309         AV_PIX_FMT_YUV410P,   AV_PIX_FMT_0RGB32,    AV_PIX_FMT_RGB32,     AV_PIX_FMT_YUV420P16,
1310         AV_PIX_FMT_YUV422P16, AV_PIX_FMT_YUV444P16, AV_PIX_FMT_YUV444P9,  AV_PIX_FMT_YUV422P9,
1311         AV_PIX_FMT_YUV420P9,  AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10,
1312         AV_PIX_FMT_YUV420P12, AV_PIX_FMT_YUV422P12, AV_PIX_FMT_YUV444P12,
1313         AV_PIX_FMT_YUVA444P16, AV_PIX_FMT_YUVA422P16, AV_PIX_FMT_YUVA420P16,
1314         AV_PIX_FMT_YUVA444P10, AV_PIX_FMT_YUVA422P10, AV_PIX_FMT_YUVA420P10,
1315         AV_PIX_FMT_YUVA444P9, AV_PIX_FMT_YUVA422P9, AV_PIX_FMT_YUVA420P9,
1316         AV_PIX_FMT_GRAY16,    AV_PIX_FMT_GRAY8,     AV_PIX_FMT_GBRP9,     AV_PIX_FMT_GBRP10,
1317         AV_PIX_FMT_GBRP12,    AV_PIX_FMT_GBRP14,
1318         AV_PIX_FMT_YA8,
1319         AV_PIX_FMT_GRAY10, AV_PIX_FMT_GRAY12,
1320         AV_PIX_FMT_GBRP16, AV_PIX_FMT_RGB48,
1321         AV_PIX_FMT_NONE
1322
1323     },
1324 #if FF_API_CODER_TYPE
1325     .defaults       = ffv1_defaults,
1326 #endif
1327     .priv_class     = &ffv1_class,
1328 };