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     code = v ^ ((2 * state->drift + state->count) >> 31);
 256
 257     ff_dlog(NULL, "v:%d/%d bias:%d error:%d drift:%d count:%d k:%d\n", v, code,
 258             state->bias, state->error_sum, state->drift, state->count, k);
 259     set_sr_golomb(pb, code, k, 12, bits);
 260
 261     update_vlc_state(state, v);
 262 }
 263
 264 #define TYPE int16_t
 265 #define RENAME(name) name
 266 #include "ffv1enc_template.c"
 267 #undef TYPE
 268 #undef RENAME
 269
 270 #define TYPE int32_t
 271 #define RENAME(name) name ## 32
 272 #include "ffv1enc_template.c"
 273
 274 static int encode_plane(FFV1Context *s, uint8_t *src, int w, int h,
 275                          int stride, int plane_index, int pixel_stride)
 276 {
 277     int x, y, i, ret;
 278     const int ring_size = s->context_model ? 3 : 2;
 279     int16_t *sample[3];
 280     s->run_index = 0;
 281
 282     memset(s->sample_buffer, 0, ring_size * (w + 6) * sizeof(*s->sample_buffer));
 283
 284     for (y = 0; y < h; y++) {
 285         for (i = 0; i < ring_size; i++)
 286             sample[i] = s->sample_buffer + (w + 6) * ((h + i - y) % ring_size) + 3;
 287
 288         sample[0][-1]= sample[1][0  ];
 289         sample[1][ w]= sample[1][w-1];
 290 // { START_TIMER
 291         if (s->bits_per_raw_sample <= 8) {
 292             for (x = 0; x < w; x++)
 293                 sample[0][x] = src[x * pixel_stride + stride * y];
 294             if((ret = encode_line(s, w, sample, plane_index, 8)) < 0)
 295                 return ret;
 296         } else {
 297             if (s->packed_at_lsb) {
 298                 for (x = 0; x < w; x++) {
 299                     sample[0][x] = ((uint16_t*)(src + stride*y))[x];
 300                 }
 301             } else {
 302                 for (x = 0; x < w; x++) {
 303                     sample[0][x] = ((uint16_t*)(src + stride*y))[x] >> (16 - s->bits_per_raw_sample);
 304                 }
 305             }
 306             if((ret = encode_line(s, w, sample, plane_index, s->bits_per_raw_sample)) < 0)
 307                 return ret;
 308         }
 309 // STOP_TIMER("encode line") }
 310     }
 311     return 0;
 312 }
 313
 314 static void write_quant_table(RangeCoder *c, int16_t *quant_table)
 315 {
 316     int last = 0;
 317     int i;
 318     uint8_t state[CONTEXT_SIZE];
 319     memset(state, 128, sizeof(state));
 320
 321     for (i = 1; i < 128; i++)
 322         if (quant_table[i] != quant_table[i - 1]) {
 323             put_symbol(c, state, i - last - 1, 0);
 324             last = i;
 325         }
 326     put_symbol(c, state, i - last - 1, 0);
 327 }
 328
 329 static void write_quant_tables(RangeCoder *c,
 330                                int16_t quant_table[MAX_CONTEXT_INPUTS][256])
 331 {
 332     int i;
 333     for (i = 0; i < 5; i++)
 334         write_quant_table(c, quant_table[i]);
 335 }
 336
 337 static void write_header(FFV1Context *f)
 338 {
 339     uint8_t state[CONTEXT_SIZE];
 340     int i, j;
 341     RangeCoder *const c = &f->slice_context[0]->c;
 342
 343     memset(state, 128, sizeof(state));
 344
 345     if (f->version < 2) {
 346         put_symbol(c, state, f->version, 0);
 347         put_symbol(c, state, f->ac, 0);
 348         if (f->ac == AC_RANGE_CUSTOM_TAB) {
 349             for (i = 1; i < 256; i++)
 350                 put_symbol(c, state,
 351                            f->state_transition[i] - c->one_state[i], 1);
 352         }
 353         put_symbol(c, state, f->colorspace, 0); //YUV cs type
 354         if (f->version > 0)
 355             put_symbol(c, state, f->bits_per_raw_sample, 0);
 356         put_rac(c, state, f->chroma_planes);
 357         put_symbol(c, state, f->chroma_h_shift, 0);
 358         put_symbol(c, state, f->chroma_v_shift, 0);
 359         put_rac(c, state, f->transparency);
 360
 361         write_quant_tables(c, f->quant_table);
 362     } else if (f->version < 3) {
 363         put_symbol(c, state, f->slice_count, 0);
 364         for (i = 0; i < f->slice_count; i++) {
 365             FFV1Context *fs = f->slice_context[i];
 366             put_symbol(c, state,
 367                        (fs->slice_x      + 1) * f->num_h_slices / f->width, 0);
 368             put_symbol(c, state,
 369                        (fs->slice_y      + 1) * f->num_v_slices / f->height, 0);
 370             put_symbol(c, state,
 371                        (fs->slice_width  + 1) * f->num_h_slices / f->width - 1,
 372                        0);
 373             put_symbol(c, state,
 374                        (fs->slice_height + 1) * f->num_v_slices / f->height - 1,
 375                        0);
 376             for (j = 0; j < f->plane_count; j++) {
 377                 put_symbol(c, state, f->plane[j].quant_table_index, 0);
 378                 av_assert0(f->plane[j].quant_table_index == f->context_model);
 379             }
 380         }
 381     }
 382 }
 383
 384 static int write_extradata(FFV1Context *f)
 385 {
 386     RangeCoder *const c = &f->c;
 387     uint8_t state[CONTEXT_SIZE];
 388     int i, j, k;
 389     uint8_t state2[32][CONTEXT_SIZE];
 390     unsigned v;
 391
 392     memset(state2, 128, sizeof(state2));
 393     memset(state, 128, sizeof(state));
 394
 395     f->avctx->extradata_size = 10000 + 4 +
 396                                     (11 * 11 * 5 * 5 * 5 + 11 * 11 * 11) * 32;
 397     f->avctx->extradata = av_malloc(f->avctx->extradata_size + AV_INPUT_BUFFER_PADDING_SIZE);
 398     if (!f->avctx->extradata)
 399         return AVERROR(ENOMEM);
 400     ff_init_range_encoder(c, f->avctx->extradata, f->avctx->extradata_size);
 401     ff_build_rac_states(c, 0.05 * (1LL << 32), 256 - 8);
 402
 403     put_symbol(c, state, f->version, 0);
 404     if (f->version > 2) {
 405         if (f->version == 3) {
 406             f->micro_version = 4;
 407         } else if (f->version == 4)
 408             f->micro_version = 2;
 409         put_symbol(c, state, f->micro_version, 0);
 410     }
 411
 412     put_symbol(c, state, f->ac, 0);
 413     if (f->ac == AC_RANGE_CUSTOM_TAB)
 414         for (i = 1; i < 256; i++)
 415             put_symbol(c, state, f->state_transition[i] - c->one_state[i], 1);
 416
 417     put_symbol(c, state, f->colorspace, 0); // YUV cs type
 418     put_symbol(c, state, f->bits_per_raw_sample, 0);
 419     put_rac(c, state, f->chroma_planes);
 420     put_symbol(c, state, f->chroma_h_shift, 0);
 421     put_symbol(c, state, f->chroma_v_shift, 0);
 422     put_rac(c, state, f->transparency);
 423     put_symbol(c, state, f->num_h_slices - 1, 0);
 424     put_symbol(c, state, f->num_v_slices - 1, 0);
 425
 426     put_symbol(c, state, f->quant_table_count, 0);
 427     for (i = 0; i < f->quant_table_count; i++)
 428         write_quant_tables(c, f->quant_tables[i]);
 429
 430     for (i = 0; i < f->quant_table_count; i++) {
 431         for (j = 0; j < f->context_count[i] * CONTEXT_SIZE; j++)
 432             if (f->initial_states[i] && f->initial_states[i][0][j] != 128)
 433                 break;
 434         if (j < f->context_count[i] * CONTEXT_SIZE) {
 435             put_rac(c, state, 1);
 436             for (j = 0; j < f->context_count[i]; j++)
 437                 for (k = 0; k < CONTEXT_SIZE; k++) {
 438                     int pred = j ? f->initial_states[i][j - 1][k] : 128;
 439                     put_symbol(c, state2[k],
 440                                (int8_t)(f->initial_states[i][j][k] - pred), 1);
 441                 }
 442         } else {
 443             put_rac(c, state, 0);
 444         }
 445     }
 446
 447     if (f->version > 2) {
 448         put_symbol(c, state, f->ec, 0);
 449         put_symbol(c, state, f->intra = (f->avctx->gop_size < 2), 0);
 450     }
 451
 452     f->avctx->extradata_size = ff_rac_terminate(c, 0);
 453     v = av_crc(av_crc_get_table(AV_CRC_32_IEEE), 0, f->avctx->extradata, f->avctx->extradata_size);
 454     AV_WL32(f->avctx->extradata + f->avctx->extradata_size, v);
 455     f->avctx->extradata_size += 4;
 456
 457     return 0;
 458 }
 459
 460 static int sort_stt(FFV1Context *s, uint8_t stt[256])
 461 {
 462     int i, i2, changed, print = 0;
 463
 464     do {
 465         changed = 0;
 466         for (i = 12; i < 244; i++) {
 467             for (i2 = i + 1; i2 < 245 && i2 < i + 4; i2++) {
 468
 469 #define COST(old, new)                                      \
 470     s->rc_stat[old][0] * -log2((256 - (new)) / 256.0) +     \
 471     s->rc_stat[old][1] * -log2((new)         / 256.0)
 472
 473 #define COST2(old, new)                         \
 474     COST(old, new) + COST(256 - (old), 256 - (new))
 475
 476                 double size0 = COST2(i,  i) + COST2(i2, i2);
 477                 double sizeX = COST2(i, i2) + COST2(i2, i);
 478                 if (size0 - sizeX > size0*(1e-14) && i != 128 && i2 != 128) {
 479                     int j;
 480                     FFSWAP(int, stt[i], stt[i2]);
 481                     FFSWAP(int, s->rc_stat[i][0], s->rc_stat[i2][0]);
 482                     FFSWAP(int, s->rc_stat[i][1], s->rc_stat[i2][1]);
 483                     if (i != 256 - i2) {
 484                         FFSWAP(int, stt[256 - i], stt[256 - i2]);
 485                         FFSWAP(int, s->rc_stat[256 - i][0], s->rc_stat[256 - i2][0]);
 486                         FFSWAP(int, s->rc_stat[256 - i][1], s->rc_stat[256 - i2][1]);
 487                     }
 488                     for (j = 1; j < 256; j++) {
 489                         if (stt[j] == i)
 490                             stt[j] = i2;
 491                         else if (stt[j] == i2)
 492                             stt[j] = i;
 493                         if (i != 256 - i2) {
 494                             if (stt[256 - j] == 256 - i)
 495                                 stt[256 - j] = 256 - i2;
 496                             else if (stt[256 - j] == 256 - i2)
 497                                 stt[256 - j] = 256 - i;
 498                         }
 499                     }
 500                     print = changed = 1;
 501                 }
 502             }
 503         }
 504     } while (changed);
 505     return print;
 506 }
 507
 508 static av_cold int encode_init(AVCodecContext *avctx)
 509 {
 510     FFV1Context *s = avctx->priv_data;
 511     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(avctx->pix_fmt);
 512     int i, j, k, m, ret;
 513
 514     if ((ret = ff_ffv1_common_init(avctx)) < 0)
 515         return ret;
 516
 517     s->version = 0;
 518
 519     if ((avctx->flags & (AV_CODEC_FLAG_PASS1 | AV_CODEC_FLAG_PASS2)) ||
 520         avctx->slices > 1)
 521         s->version = FFMAX(s->version, 2);
 522
 523     // Unspecified level & slices, we choose version 1.2+ to ensure multithreaded decodability
 524     if (avctx->slices == 0 && avctx->level < 0 && avctx->width * avctx->height > 720*576)
 525         s->version = FFMAX(s->version, 2);
 526
 527     if (avctx->level <= 0 && s->version == 2) {
 528         s->version = 3;
 529     }
 530     if (avctx->level >= 0 && avctx->level <= 4) {
 531         if (avctx->level < s->version) {
 532             av_log(avctx, AV_LOG_ERROR, "Version %d needed for requested features but %d requested\n", s->version, avctx->level);
 533             return AVERROR(EINVAL);
 534         }
 535         s->version = avctx->level;
 536     }
 537
 538     if (s->ec < 0) {
 539         s->ec = (s->version >= 3);
 540     }
 541
 542     // CRC requires version 3+
 543     if (s->ec)
 544         s->version = FFMAX(s->version, 3);
 545
 546     if ((s->version == 2 || s->version>3) && avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
 547         av_log(avctx, AV_LOG_ERROR, "Version 2 needed for requested features but version 2 is experimental and not enabled\n");
 548         return AVERROR_INVALIDDATA;
 549     }
 550
 551 #if FF_API_CODER_TYPE
 552 FF_DISABLE_DEPRECATION_WARNINGS
 553     if (avctx->coder_type != -1)
 554         s->ac = avctx->coder_type > 0 ? AC_RANGE_CUSTOM_TAB : AC_GOLOMB_RICE;
 555     else
 556 FF_ENABLE_DEPRECATION_WARNINGS
 557 #endif
 558     if (s->ac == 1) // Compatbility with common command line usage
 559         s->ac = AC_RANGE_CUSTOM_TAB;
 560     else if (s->ac == AC_RANGE_DEFAULT_TAB_FORCE)
 561         s->ac = AC_RANGE_DEFAULT_TAB;
 562
 563     s->plane_count = 3;
 564     switch(avctx->pix_fmt) {
 565     case AV_PIX_FMT_GRAY9:
 566     case AV_PIX_FMT_YUV444P9:
 567     case AV_PIX_FMT_YUV422P9:
 568     case AV_PIX_FMT_YUV420P9:
 569     case AV_PIX_FMT_YUVA444P9:
 570     case AV_PIX_FMT_YUVA422P9:
 571     case AV_PIX_FMT_YUVA420P9:
 572         if (!avctx->bits_per_raw_sample)
 573             s->bits_per_raw_sample = 9;
 574     case AV_PIX_FMT_GRAY10:
 575     case AV_PIX_FMT_YUV444P10:
 576     case AV_PIX_FMT_YUV440P10:
 577     case AV_PIX_FMT_YUV420P10:
 578     case AV_PIX_FMT_YUV422P10:
 579     case AV_PIX_FMT_YUVA444P10:
 580     case AV_PIX_FMT_YUVA422P10:
 581     case AV_PIX_FMT_YUVA420P10:
 582         if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
 583             s->bits_per_raw_sample = 10;
 584     case AV_PIX_FMT_GRAY12:
 585     case AV_PIX_FMT_YUV444P12:
 586     case AV_PIX_FMT_YUV440P12:
 587     case AV_PIX_FMT_YUV420P12:
 588     case AV_PIX_FMT_YUV422P12:
 589         if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
 590             s->bits_per_raw_sample = 12;
 591     case AV_PIX_FMT_YUV444P14:
 592     case AV_PIX_FMT_YUV420P14:
 593     case AV_PIX_FMT_YUV422P14:
 594         if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
 595             s->bits_per_raw_sample = 14;
 596         s->packed_at_lsb = 1;
 597     case AV_PIX_FMT_GRAY16:
 598     case AV_PIX_FMT_YUV444P16:
 599     case AV_PIX_FMT_YUV422P16:
 600     case AV_PIX_FMT_YUV420P16:
 601     case AV_PIX_FMT_YUVA444P16:
 602     case AV_PIX_FMT_YUVA422P16:
 603     case AV_PIX_FMT_YUVA420P16:
 604         if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample) {
 605             s->bits_per_raw_sample = 16;
 606         } else if (!s->bits_per_raw_sample) {
 607             s->bits_per_raw_sample = avctx->bits_per_raw_sample;
 608         }
 609         if (s->bits_per_raw_sample <= 8) {
 610             av_log(avctx, AV_LOG_ERROR, "bits_per_raw_sample invalid\n");
 611             return AVERROR_INVALIDDATA;
 612         }
 613         s->version = FFMAX(s->version, 1);
 614     case AV_PIX_FMT_GRAY8:
 615     case AV_PIX_FMT_YA8:
 616     case AV_PIX_FMT_YUV444P:
 617     case AV_PIX_FMT_YUV440P:
 618     case AV_PIX_FMT_YUV422P:
 619     case AV_PIX_FMT_YUV420P:
 620     case AV_PIX_FMT_YUV411P:
 621     case AV_PIX_FMT_YUV410P:
 622     case AV_PIX_FMT_YUVA444P:
 623     case AV_PIX_FMT_YUVA422P:
 624     case AV_PIX_FMT_YUVA420P:
 625         s->chroma_planes = desc->nb_components < 3 ? 0 : 1;
 626         s->colorspace = 0;
 627         s->transparency = !!(desc->flags & AV_PIX_FMT_FLAG_ALPHA);
 628         if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
 629             s->bits_per_raw_sample = 8;
 630         else if (!s->bits_per_raw_sample)
 631             s->bits_per_raw_sample = 8;
 632         break;
 633     case AV_PIX_FMT_RGB32:
 634         s->colorspace = 1;
 635         s->transparency = 1;
 636         s->chroma_planes = 1;
 637         s->bits_per_raw_sample = 8;
 638         break;
 639     case AV_PIX_FMT_RGBA64:
 640         s->colorspace = 1;
 641         s->transparency = 1;
 642         s->chroma_planes = 1;
 643         s->bits_per_raw_sample = 16;
 644         s->use32bit = 1;
 645         s->version = FFMAX(s->version, 1);
 646         break;
 647     case AV_PIX_FMT_RGB48:
 648         s->colorspace = 1;
 649         s->chroma_planes = 1;
 650         s->bits_per_raw_sample = 16;
 651         s->use32bit = 1;
 652         s->version = FFMAX(s->version, 1);
 653         break;
 654     case AV_PIX_FMT_0RGB32:
 655         s->colorspace = 1;
 656         s->chroma_planes = 1;
 657         s->bits_per_raw_sample = 8;
 658         break;
 659     case AV_PIX_FMT_GBRP9:
 660         if (!avctx->bits_per_raw_sample)
 661             s->bits_per_raw_sample = 9;
 662     case AV_PIX_FMT_GBRP10:
 663     case AV_PIX_FMT_GBRAP10:
 664         if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
 665             s->bits_per_raw_sample = 10;
 666     case AV_PIX_FMT_GBRP12:
 667     case AV_PIX_FMT_GBRAP12:
 668         if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
 669             s->bits_per_raw_sample = 12;
 670     case AV_PIX_FMT_GBRP14:
 671         if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
 672             s->bits_per_raw_sample = 14;
 673     case AV_PIX_FMT_GBRP16:
 674     case AV_PIX_FMT_GBRAP16:
 675         if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
 676             s->bits_per_raw_sample = 16;
 677         else if (!s->bits_per_raw_sample)
 678             s->bits_per_raw_sample = avctx->bits_per_raw_sample;
 679         s->transparency = !!(desc->flags & AV_PIX_FMT_FLAG_ALPHA);
 680         s->colorspace = 1;
 681         s->chroma_planes = 1;
 682         if (s->bits_per_raw_sample >= 16) {
 683             s->use32bit = 1;
 684         }
 685         s->version = FFMAX(s->version, 1);
 686         break;
 687     default:
 688         av_log(avctx, AV_LOG_ERROR, "format not supported\n");
 689         return AVERROR(ENOSYS);
 690     }
 691     av_assert0(s->bits_per_raw_sample >= 8);
 692
 693     if (s->bits_per_raw_sample > 8) {
 694         if (s->ac == AC_GOLOMB_RICE) {
 695             av_log(avctx, AV_LOG_INFO,
 696                     "bits_per_raw_sample > 8, forcing range coder\n");
 697             s->ac = AC_RANGE_CUSTOM_TAB;
 698         }
 699     }
 700 #if FF_API_PRIVATE_OPT
 701 FF_DISABLE_DEPRECATION_WARNINGS
 702     if (avctx->context_model)
 703         s->context_model = avctx->context_model;
 704     if (avctx->context_model > 1U) {
 705         av_log(avctx, AV_LOG_ERROR, "Invalid context model %d, valid values are 0 and 1\n", avctx->context_model);
 706         return AVERROR(EINVAL);
 707     }
 708 FF_ENABLE_DEPRECATION_WARNINGS
 709 #endif
 710
 711     if (s->ac == AC_RANGE_CUSTOM_TAB) {
 712         for (i = 1; i < 256; i++)
 713             s->state_transition[i] = ver2_state[i];
 714     } else {
 715         RangeCoder c;
 716         ff_build_rac_states(&c, 0.05 * (1LL << 32), 256 - 8);
 717         for (i = 1; i < 256; i++)
 718             s->state_transition[i] = c.one_state[i];
 719     }
 720
 721     for (i = 0; i < 256; i++) {
 722         s->quant_table_count = 2;
 723         if (s->bits_per_raw_sample <= 8) {
 724             s->quant_tables[0][0][i]=           quant11[i];
 725             s->quant_tables[0][1][i]=        11*quant11[i];
 726             s->quant_tables[0][2][i]=     11*11*quant11[i];
 727             s->quant_tables[1][0][i]=           quant11[i];
 728             s->quant_tables[1][1][i]=        11*quant11[i];
 729             s->quant_tables[1][2][i]=     11*11*quant5 [i];
 730             s->quant_tables[1][3][i]=   5*11*11*quant5 [i];
 731             s->quant_tables[1][4][i]= 5*5*11*11*quant5 [i];
 732         } else {
 733             s->quant_tables[0][0][i]=           quant9_10bit[i];
 734             s->quant_tables[0][1][i]=        11*quant9_10bit[i];
 735             s->quant_tables[0][2][i]=     11*11*quant9_10bit[i];
 736             s->quant_tables[1][0][i]=           quant9_10bit[i];
 737             s->quant_tables[1][1][i]=        11*quant9_10bit[i];
 738             s->quant_tables[1][2][i]=     11*11*quant5_10bit[i];
 739             s->quant_tables[1][3][i]=   5*11*11*quant5_10bit[i];
 740             s->quant_tables[1][4][i]= 5*5*11*11*quant5_10bit[i];
 741         }
 742     }
 743     s->context_count[0] = (11 * 11 * 11        + 1) / 2;
 744     s->context_count[1] = (11 * 11 * 5 * 5 * 5 + 1) / 2;
 745     memcpy(s->quant_table, s->quant_tables[s->context_model],
 746            sizeof(s->quant_table));
 747
 748     for (i = 0; i < s->plane_count; i++) {
 749         PlaneContext *const p = &s->plane[i];
 750
 751         memcpy(p->quant_table, s->quant_table, sizeof(p->quant_table));
 752         p->quant_table_index = s->context_model;
 753         p->context_count     = s->context_count[p->quant_table_index];
 754     }
 755
 756     if ((ret = ff_ffv1_allocate_initial_states(s)) < 0)
 757         return ret;
 758
 759 #if FF_API_CODED_FRAME
 760 FF_DISABLE_DEPRECATION_WARNINGS
 761     avctx->coded_frame->pict_type = AV_PICTURE_TYPE_I;
 762 FF_ENABLE_DEPRECATION_WARNINGS
 763 #endif
 764
 765     if (!s->transparency)
 766         s->plane_count = 2;
 767     if (!s->chroma_planes && s->version > 3)
 768         s->plane_count--;
 769
 770     ret = av_pix_fmt_get_chroma_sub_sample (avctx->pix_fmt, &s->chroma_h_shift, &s->chroma_v_shift);
 771     if (ret)
 772         return ret;
 773
 774     s->picture_number = 0;
 775
 776     if (avctx->flags & (AV_CODEC_FLAG_PASS1 | AV_CODEC_FLAG_PASS2)) {
 777         for (i = 0; i < s->quant_table_count; i++) {
 778             s->rc_stat2[i] = av_mallocz(s->context_count[i] *
 779                                         sizeof(*s->rc_stat2[i]));
 780             if (!s->rc_stat2[i])
 781                 return AVERROR(ENOMEM);
 782         }
 783     }
 784     if (avctx->stats_in) {
 785         char *p = avctx->stats_in;
 786         uint8_t (*best_state)[256] = av_malloc_array(256, 256);
 787         int gob_count = 0;
 788         char *next;
 789         if (!best_state)
 790             return AVERROR(ENOMEM);
 791
 792         av_assert0(s->version >= 2);
 793
 794         for (;;) {
 795             for (j = 0; j < 256; j++)
 796                 for (i = 0; i < 2; i++) {
 797                     s->rc_stat[j][i] = strtol(p, &next, 0);
 798                     if (next == p) {
 799                         av_log(avctx, AV_LOG_ERROR,
 800                                "2Pass file invalid at %d %d [%s]\n", j, i, p);
 801                         av_freep(&best_state);
 802                         return AVERROR_INVALIDDATA;
 803                     }
 804                     p = next;
 805                 }
 806             for (i = 0; i < s->quant_table_count; i++)
 807                 for (j = 0; j < s->context_count[i]; j++) {
 808                     for (k = 0; k < 32; k++)
 809                         for (m = 0; m < 2; m++) {
 810                             s->rc_stat2[i][j][k][m] = strtol(p, &next, 0);
 811                             if (next == p) {
 812                                 av_log(avctx, AV_LOG_ERROR,
 813                                        "2Pass file invalid at %d %d %d %d [%s]\n",
 814                                        i, j, k, m, p);
 815                                 av_freep(&best_state);
 816                                 return AVERROR_INVALIDDATA;
 817                             }
 818                             p = next;
 819                         }
 820                 }
 821             gob_count = strtol(p, &next, 0);
 822             if (next == p || gob_count <= 0) {
 823                 av_log(avctx, AV_LOG_ERROR, "2Pass file invalid\n");
 824                 av_freep(&best_state);
 825                 return AVERROR_INVALIDDATA;
 826             }
 827             p = next;
 828             while (*p == '\n' || *p == ' ')
 829                 p++;
 830             if (p[0] == 0)
 831                 break;
 832         }
 833         if (s->ac == AC_RANGE_CUSTOM_TAB)
 834             sort_stt(s, s->state_transition);
 835
 836         find_best_state(best_state, s->state_transition);
 837
 838         for (i = 0; i < s->quant_table_count; i++) {
 839             for (k = 0; k < 32; k++) {
 840                 double a=0, b=0;
 841                 int jp = 0;
 842                 for (j = 0; j < s->context_count[i]; j++) {
 843                     double p = 128;
 844                     if (s->rc_stat2[i][j][k][0] + s->rc_stat2[i][j][k][1] > 200 && j || a+b > 200) {
 845                         if (a+b)
 846                             p = 256.0 * b / (a + b);
 847                         s->initial_states[i][jp][k] =
 848                             best_state[av_clip(round(p), 1, 255)][av_clip_uint8((a + b) / gob_count)];
 849                         for(jp++; jp<j; jp++)
 850                             s->initial_states[i][jp][k] = s->initial_states[i][jp-1][k];
 851                         a=b=0;
 852                     }
 853                     a += s->rc_stat2[i][j][k][0];
 854                     b += s->rc_stat2[i][j][k][1];
 855                     if (a+b) {
 856                         p = 256.0 * b / (a + b);
 857                     }
 858                     s->initial_states[i][j][k] =
 859                         best_state[av_clip(round(p), 1, 255)][av_clip_uint8((a + b) / gob_count)];
 860                 }
 861             }
 862         }
 863         av_freep(&best_state);
 864     }
 865
 866     if (s->version > 1) {
 867         int plane_count = 1 + 2*s->chroma_planes + s->transparency;
 868         int max_h_slices = AV_CEIL_RSHIFT(avctx->width , s->chroma_h_shift);
 869         int max_v_slices = AV_CEIL_RSHIFT(avctx->height, s->chroma_v_shift);
 870         s->num_v_slices = (avctx->width > 352 || avctx->height > 288 || !avctx->slices) ? 2 : 1;
 871
 872         s->num_v_slices = FFMIN(s->num_v_slices, max_v_slices);
 873
 874         for (; s->num_v_slices < 32; s->num_v_slices++) {
 875             for (s->num_h_slices = s->num_v_slices; s->num_h_slices < 2*s->num_v_slices; s->num_h_slices++) {
 876                 int maxw = (avctx->width  + s->num_h_slices - 1) / s->num_h_slices;
 877                 int maxh = (avctx->height + s->num_v_slices - 1) / s->num_v_slices;
 878                 if (s->num_h_slices > max_h_slices || s->num_v_slices > max_v_slices)
 879                     continue;
 880                 if (maxw * maxh * (int64_t)(s->bits_per_raw_sample+1) * plane_count > 8<<24)
 881                     continue;
 882                 if (avctx->slices == s->num_h_slices * s->num_v_slices && avctx->slices <= MAX_SLICES || !avctx->slices)
 883                     goto slices_ok;
 884             }
 885         }
 886         av_log(avctx, AV_LOG_ERROR,
 887                "Unsupported number %d of slices requested, please specify a "
 888                "supported number with -slices (ex:4,6,9,12,16, ...)\n",
 889                avctx->slices);
 890         return AVERROR(ENOSYS);
 891 slices_ok:
 892         if ((ret = write_extradata(s)) < 0)
 893             return ret;
 894     }
 895
 896     if ((ret = ff_ffv1_init_slice_contexts(s)) < 0)
 897         return ret;
 898     s->slice_count = s->max_slice_count;
 899     if ((ret = ff_ffv1_init_slices_state(s)) < 0)
 900         return ret;
 901
 902 #define STATS_OUT_SIZE 1024 * 1024 * 6
 903     if (avctx->flags & AV_CODEC_FLAG_PASS1) {
 904         avctx->stats_out = av_mallocz(STATS_OUT_SIZE);
 905         if (!avctx->stats_out)
 906             return AVERROR(ENOMEM);
 907         for (i = 0; i < s->quant_table_count; i++)
 908             for (j = 0; j < s->max_slice_count; j++) {
 909                 FFV1Context *sf = s->slice_context[j];
 910                 av_assert0(!sf->rc_stat2[i]);
 911                 sf->rc_stat2[i] = av_mallocz(s->context_count[i] *
 912                                              sizeof(*sf->rc_stat2[i]));
 913                 if (!sf->rc_stat2[i])
 914                     return AVERROR(ENOMEM);
 915             }
 916     }
 917
 918     return 0;
 919 }
 920
 921 static void encode_slice_header(FFV1Context *f, FFV1Context *fs)
 922 {
 923     RangeCoder *c = &fs->c;
 924     uint8_t state[CONTEXT_SIZE];
 925     int j;
 926     memset(state, 128, sizeof(state));
 927
 928     put_symbol(c, state, (fs->slice_x     +1)*f->num_h_slices / f->width   , 0);
 929     put_symbol(c, state, (fs->slice_y     +1)*f->num_v_slices / f->height  , 0);
 930     put_symbol(c, state, (fs->slice_width +1)*f->num_h_slices / f->width -1, 0);
 931     put_symbol(c, state, (fs->slice_height+1)*f->num_v_slices / f->height-1, 0);
 932     for (j=0; j<f->plane_count; j++) {
 933         put_symbol(c, state, f->plane[j].quant_table_index, 0);
 934         av_assert0(f->plane[j].quant_table_index == f->context_model);
 935     }
 936     if (!f->picture.f->interlaced_frame)
 937         put_symbol(c, state, 3, 0);
 938     else
 939         put_symbol(c, state, 1 + !f->picture.f->top_field_first, 0);
 940     put_symbol(c, state, f->picture.f->sample_aspect_ratio.num, 0);
 941     put_symbol(c, state, f->picture.f->sample_aspect_ratio.den, 0);
 942     if (f->version > 3) {
 943         put_rac(c, state, fs->slice_coding_mode == 1);
 944         if (fs->slice_coding_mode == 1)
 945             ff_ffv1_clear_slice_state(f, fs);
 946         put_symbol(c, state, fs->slice_coding_mode, 0);
 947         if (fs->slice_coding_mode != 1) {
 948             put_symbol(c, state, fs->slice_rct_by_coef, 0);
 949             put_symbol(c, state, fs->slice_rct_ry_coef, 0);
 950         }
 951     }
 952 }
 953
 954 static void choose_rct_params(FFV1Context *fs, const uint8_t *src[3], const int stride[3], int w, int h)
 955 {
 956 #define NB_Y_COEFF 15
 957     static const int rct_y_coeff[15][2] = {
 958         {0, 0}, //      4G
 959         {1, 1}, //  R + 2G + B
 960         {2, 2}, // 2R      + 2B
 961         {0, 2}, //      2G + 2B
 962         {2, 0}, // 2R + 2G
 963         {4, 0}, // 4R
 964         {0, 4}, //           4B
 965
 966         {0, 3}, //      1G + 3B
 967         {3, 0}, // 3R + 1G
 968         {3, 1}, // 3R      +  B
 969         {1, 3}, //  R      + 3B
 970         {1, 2}, //  R +  G + 2B
 971         {2, 1}, // 2R +  G +  B
 972         {0, 1}, //      3G +  B
 973         {1, 0}, //  R + 3G
 974     };
 975
 976     int stat[NB_Y_COEFF] = {0};
 977     int x, y, i, p, best;
 978     int16_t *sample[3];
 979     int lbd = fs->bits_per_raw_sample <= 8;
 980
 981     for (y = 0; y < h; y++) {
 982         int lastr=0, lastg=0, lastb=0;
 983         for (p = 0; p < 3; p++)
 984             sample[p] = fs->sample_buffer + p*w;
 985
 986         for (x = 0; x < w; x++) {
 987             int b, g, r;
 988             int ab, ag, ar;
 989             if (lbd) {
 990                 unsigned v = *((const uint32_t*)(src[0] + x*4 + stride[0]*y));
 991                 b =  v        & 0xFF;
 992                 g = (v >>  8) & 0xFF;
 993                 r = (v >> 16) & 0xFF;
 994             } else {
 995                 b = *((const uint16_t*)(src[0] + x*2 + stride[0]*y));
 996                 g = *((const uint16_t*)(src[1] + x*2 + stride[1]*y));
 997                 r = *((const uint16_t*)(src[2] + x*2 + stride[2]*y));
 998             }
 999
1000             ar = r - lastr;
1001             ag = g - lastg;
1002             ab = b - lastb;
1003             if (x && y) {
1004                 int bg = ag - sample[0][x];
1005                 int bb = ab - sample[1][x];
1006                 int br = ar - sample[2][x];
1007
1008                 br -= bg;
1009                 bb -= bg;
1010
1011                 for (i = 0; i<NB_Y_COEFF; i++) {
1012                     stat[i] += FFABS(bg + ((br*rct_y_coeff[i][0] + bb*rct_y_coeff[i][1])>>2));
1013                 }
1014
1015             }
1016             sample[0][x] = ag;
1017             sample[1][x] = ab;
1018             sample[2][x] = ar;
1019
1020             lastr = r;
1021             lastg = g;
1022             lastb = b;
1023         }
1024     }
1025
1026     best = 0;
1027     for (i=1; i<NB_Y_COEFF; i++) {
1028         if (stat[i] < stat[best])
1029             best = i;
1030     }
1031
1032     fs->slice_rct_by_coef = rct_y_coeff[best][1];
1033     fs->slice_rct_ry_coef = rct_y_coeff[best][0];
1034 }
1035
1036 static int encode_slice(AVCodecContext *c, void *arg)
1037 {
1038     FFV1Context *fs  = *(void **)arg;
1039     FFV1Context *f   = fs->avctx->priv_data;
1040     int width        = fs->slice_width;
1041     int height       = fs->slice_height;
1042     int x            = fs->slice_x;
1043     int y            = fs->slice_y;
1044     const AVFrame *const p = f->picture.f;
1045     const int ps     = av_pix_fmt_desc_get(c->pix_fmt)->comp[0].step;
1046     int ret;
1047     RangeCoder c_bak = fs->c;
1048     const uint8_t *planes[4] = {p->data[0] + ps*x + y*p->linesize[0],
1049                                 p->data[1] ? p->data[1] + ps*x + y*p->linesize[1] : NULL,
1050                                 p->data[2] ? p->data[2] + ps*x + y*p->linesize[2] : NULL,
1051                                 p->data[3] ? p->data[3] + ps*x + y*p->linesize[3] : NULL};
1052
1053     fs->slice_coding_mode = 0;
1054     if (f->version > 3) {
1055         choose_rct_params(fs, planes, p->linesize, width, height);
1056     } else {
1057         fs->slice_rct_by_coef = 1;
1058         fs->slice_rct_ry_coef = 1;
1059     }
1060
1061 retry:
1062     if (f->key_frame)
1063         ff_ffv1_clear_slice_state(f, fs);
1064     if (f->version > 2) {
1065         encode_slice_header(f, fs);
1066     }
1067     if (fs->ac == AC_GOLOMB_RICE) {
1068         fs->ac_byte_count = f->version > 2 || (!x && !y) ? ff_rac_terminate(&fs->c, f->version > 2) : 0;
1069         init_put_bits(&fs->pb,
1070                       fs->c.bytestream_start + fs->ac_byte_count,
1071                       fs->c.bytestream_end - fs->c.bytestream_start - fs->ac_byte_count);
1072     }
1073
1074     if (f->colorspace == 0 && c->pix_fmt != AV_PIX_FMT_YA8) {
1075         const int chroma_width  = AV_CEIL_RSHIFT(width,  f->chroma_h_shift);
1076         const int chroma_height = AV_CEIL_RSHIFT(height, f->chroma_v_shift);
1077         const int cx            = x >> f->chroma_h_shift;
1078         const int cy            = y >> f->chroma_v_shift;
1079
1080         ret = encode_plane(fs, p->data[0] + ps*x + y*p->linesize[0], width, height, p->linesize[0], 0, 1);
1081
1082         if (f->chroma_planes) {
1083             ret |= encode_plane(fs, p->data[1] + ps*cx+cy*p->linesize[1], chroma_width, chroma_height, p->linesize[1], 1, 1);
1084             ret |= encode_plane(fs, p->data[2] + ps*cx+cy*p->linesize[2], chroma_width, chroma_height, p->linesize[2], 1, 1);
1085         }
1086         if (fs->transparency)
1087             ret |= encode_plane(fs, p->data[3] + ps*x + y*p->linesize[3], width, height, p->linesize[3], 2, 1);
1088     } else if (c->pix_fmt == AV_PIX_FMT_YA8) {
1089         ret  = encode_plane(fs, p->data[0] +     ps*x + y*p->linesize[0], width, height, p->linesize[0], 0, 2);
1090         ret |= encode_plane(fs, p->data[0] + 1 + ps*x + y*p->linesize[0], width, height, p->linesize[0], 1, 2);
1091     } else if (f->use32bit) {
1092         ret = encode_rgb_frame32(fs, planes, width, height, p->linesize);
1093     } else {
1094         ret = encode_rgb_frame(fs, planes, width, height, p->linesize);
1095     }
1096     emms_c();
1097
1098     if (ret < 0) {
1099         av_assert0(fs->slice_coding_mode == 0);
1100         if (fs->version < 4 || !fs->ac) {
1101             av_log(c, AV_LOG_ERROR, "Buffer too small\n");
1102             return ret;
1103         }
1104         av_log(c, AV_LOG_DEBUG, "Coding slice as PCM\n");
1105         fs->slice_coding_mode = 1;
1106         fs->c = c_bak;
1107         goto retry;
1108     }
1109
1110     return 0;
1111 }
1112
1113 static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
1114                         const AVFrame *pict, int *got_packet)
1115 {
1116     FFV1Context *f      = avctx->priv_data;
1117     RangeCoder *const c = &f->slice_context[0]->c;
1118     AVFrame *const p    = f->picture.f;
1119     uint8_t keystate    = 128;
1120     uint8_t *buf_p;
1121     int i, ret;
1122     int64_t maxsize =   AV_INPUT_BUFFER_MIN_SIZE
1123                       + avctx->width*avctx->height*37LL*4;
1124
1125     if(!pict) {
1126         if (avctx->flags & AV_CODEC_FLAG_PASS1) {
1127             int j, k, m;
1128             char *p   = avctx->stats_out;
1129             char *end = p + STATS_OUT_SIZE;
1130
1131             memset(f->rc_stat, 0, sizeof(f->rc_stat));
1132             for (i = 0; i < f->quant_table_count; i++)
1133                 memset(f->rc_stat2[i], 0, f->context_count[i] * sizeof(*f->rc_stat2[i]));
1134
1135             av_assert0(f->slice_count == f->max_slice_count);
1136             for (j = 0; j < f->slice_count; j++) {
1137                 FFV1Context *fs = f->slice_context[j];
1138                 for (i = 0; i < 256; i++) {
1139                     f->rc_stat[i][0] += fs->rc_stat[i][0];
1140                     f->rc_stat[i][1] += fs->rc_stat[i][1];
1141                 }
1142                 for (i = 0; i < f->quant_table_count; i++) {
1143                     for (k = 0; k < f->context_count[i]; k++)
1144                         for (m = 0; m < 32; m++) {
1145                             f->rc_stat2[i][k][m][0] += fs->rc_stat2[i][k][m][0];
1146                             f->rc_stat2[i][k][m][1] += fs->rc_stat2[i][k][m][1];
1147                         }
1148                 }
1149             }
1150
1151             for (j = 0; j < 256; j++) {
1152                 snprintf(p, end - p, "%" PRIu64 " %" PRIu64 " ",
1153                         f->rc_stat[j][0], f->rc_stat[j][1]);
1154                 p += strlen(p);
1155             }
1156             snprintf(p, end - p, "\n");
1157
1158             for (i = 0; i < f->quant_table_count; i++) {
1159                 for (j = 0; j < f->context_count[i]; j++)
1160                     for (m = 0; m < 32; m++) {
1161                         snprintf(p, end - p, "%" PRIu64 " %" PRIu64 " ",
1162                                 f->rc_stat2[i][j][m][0], f->rc_stat2[i][j][m][1]);
1163                         p += strlen(p);
1164                     }
1165             }
1166             snprintf(p, end - p, "%d\n", f->gob_count);
1167         }
1168         return 0;
1169     }
1170
1171     if (f->version > 3)
1172         maxsize = AV_INPUT_BUFFER_MIN_SIZE + avctx->width*avctx->height*3LL*4;
1173
1174     if (maxsize > INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE - 32) {
1175         av_log(avctx, AV_LOG_WARNING, "Cannot allocate worst case packet size, the encoding could fail\n");
1176         maxsize = INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE - 32;
1177     }
1178
1179     if ((ret = ff_alloc_packet2(avctx, pkt, maxsize, 0)) < 0)
1180         return ret;
1181
1182     ff_init_range_encoder(c, pkt->data, pkt->size);
1183     ff_build_rac_states(c, 0.05 * (1LL << 32), 256 - 8);
1184
1185     av_frame_unref(p);
1186     if ((ret = av_frame_ref(p, pict)) < 0)
1187         return ret;
1188 #if FF_API_CODED_FRAME
1189 FF_DISABLE_DEPRECATION_WARNINGS
1190     avctx->coded_frame->pict_type = AV_PICTURE_TYPE_I;
1191 FF_ENABLE_DEPRECATION_WARNINGS
1192 #endif
1193
1194     if (avctx->gop_size == 0 || f->picture_number % avctx->gop_size == 0) {
1195         put_rac(c, &keystate, 1);
1196         f->key_frame = 1;
1197         f->gob_count++;
1198         write_header(f);
1199     } else {
1200         put_rac(c, &keystate, 0);
1201         f->key_frame = 0;
1202     }
1203
1204     if (f->ac == AC_RANGE_CUSTOM_TAB) {
1205         int i;
1206         for (i = 1; i < 256; i++) {
1207             c->one_state[i]        = f->state_transition[i];
1208             c->zero_state[256 - i] = 256 - c->one_state[i];
1209         }
1210     }
1211
1212     for (i = 0; i < f->slice_count; i++) {
1213         FFV1Context *fs = f->slice_context[i];
1214         uint8_t *start  = pkt->data + pkt->size * (int64_t)i / f->slice_count;
1215         int len         = pkt->size / f->slice_count;
1216         if (i) {
1217             ff_init_range_encoder(&fs->c, start, len);
1218         } else {
1219             av_assert0(fs->c.bytestream_end >= fs->c.bytestream_start + len);
1220             av_assert0(fs->c.bytestream < fs->c.bytestream_start + len);
1221             fs->c.bytestream_end = fs->c.bytestream_start + len;
1222         }
1223     }
1224     avctx->execute(avctx, encode_slice, &f->slice_context[0], NULL,
1225                    f->slice_count, sizeof(void *));
1226
1227     buf_p = pkt->data;
1228     for (i = 0; i < f->slice_count; i++) {
1229         FFV1Context *fs = f->slice_context[i];
1230         int bytes;
1231
1232         if (fs->ac != AC_GOLOMB_RICE) {
1233             bytes = ff_rac_terminate(&fs->c, 1);
1234         } else {
1235             flush_put_bits(&fs->pb); // FIXME: nicer padding
1236             bytes = fs->ac_byte_count + (put_bits_count(&fs->pb) + 7) / 8;
1237         }
1238         if (i > 0 || f->version > 2) {
1239             av_assert0(bytes < pkt->size / f->slice_count);
1240             memmove(buf_p, fs->c.bytestream_start, bytes);
1241             av_assert0(bytes < (1 << 24));
1242             AV_WB24(buf_p + bytes, bytes);
1243             bytes += 3;
1244         }
1245         if (f->ec) {
1246             unsigned v;
1247             buf_p[bytes++] = 0;
1248             v = av_crc(av_crc_get_table(AV_CRC_32_IEEE), 0, buf_p, bytes);
1249             AV_WL32(buf_p + bytes, v);
1250             bytes += 4;
1251         }
1252         buf_p += bytes;
1253     }
1254
1255     if (avctx->flags & AV_CODEC_FLAG_PASS1)
1256         avctx->stats_out[0] = '\0';
1257
1258 #if FF_API_CODED_FRAME
1259 FF_DISABLE_DEPRECATION_WARNINGS
1260     avctx->coded_frame->key_frame = f->key_frame;
1261 FF_ENABLE_DEPRECATION_WARNINGS
1262 #endif
1263
1264     f->picture_number++;
1265     pkt->size   = buf_p - pkt->data;
1266     pkt->pts    =
1267     pkt->dts    = pict->pts;
1268     pkt->flags |= AV_PKT_FLAG_KEY * f->key_frame;
1269     *got_packet = 1;
1270
1271     return 0;
1272 }
1273
1274 static av_cold int encode_close(AVCodecContext *avctx)
1275 {
1276     ff_ffv1_close(avctx);
1277     return 0;
1278 }
1279
1280 #define OFFSET(x) offsetof(FFV1Context, x)
1281 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
1282 static const AVOption options[] = {
1283     { "slicecrc", "Protect slices with CRCs", OFFSET(ec), AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, VE },
1284     { "coder", "Coder type", OFFSET(ac), AV_OPT_TYPE_INT,
1285             { .i64 = 0 }, -2, 2, VE, "coder" },
1286         { "rice", "Golomb rice", 0, AV_OPT_TYPE_CONST,
1287             { .i64 = AC_GOLOMB_RICE }, INT_MIN, INT_MAX, VE, "coder" },
1288         { "range_def", "Range with default table", 0, AV_OPT_TYPE_CONST,
1289             { .i64 = AC_RANGE_DEFAULT_TAB_FORCE }, INT_MIN, INT_MAX, VE, "coder" },
1290         { "range_tab", "Range with custom table", 0, AV_OPT_TYPE_CONST,
1291             { .i64 = AC_RANGE_CUSTOM_TAB }, INT_MIN, INT_MAX, VE, "coder" },
1292         { "ac", "Range with custom table (the ac option exists for compatibility and is deprecated)", 0, AV_OPT_TYPE_CONST,
1293             { .i64 = 1 }, INT_MIN, INT_MAX, VE, "coder" },
1294     { "context", "Context model", OFFSET(context_model), AV_OPT_TYPE_INT,
1295             { .i64 = 0 }, 0, 1, VE },
1296
1297     { NULL }
1298 };
1299
1300 static const AVClass ffv1_class = {
1301     .class_name = "ffv1 encoder",
1302     .item_name  = av_default_item_name,
1303     .option     = options,
1304     .version    = LIBAVUTIL_VERSION_INT,
1305 };
1306
1307 #if FF_API_CODER_TYPE
1308 static const AVCodecDefault ffv1_defaults[] = {
1309     { "coder", "-1" },
1310     { NULL },
1311 };
1312 #endif
1313
1314 AVCodec ff_ffv1_encoder = {
1315     .name           = "ffv1",
1316     .long_name      = NULL_IF_CONFIG_SMALL("FFmpeg video codec #1"),
1317     .type           = AVMEDIA_TYPE_VIDEO,
1318     .id             = AV_CODEC_ID_FFV1,
1319     .priv_data_size = sizeof(FFV1Context),
1320     .init           = encode_init,
1321     .encode2        = encode_frame,
1322     .close          = encode_close,
1323     .capabilities   = AV_CODEC_CAP_SLICE_THREADS | AV_CODEC_CAP_DELAY,
1324     .pix_fmts       = (const enum AVPixelFormat[]) {
1325         AV_PIX_FMT_YUV420P,   AV_PIX_FMT_YUVA420P,  AV_PIX_FMT_YUVA422P,  AV_PIX_FMT_YUV444P,
1326         AV_PIX_FMT_YUVA444P,  AV_PIX_FMT_YUV440P,   AV_PIX_FMT_YUV422P,   AV_PIX_FMT_YUV411P,
1327         AV_PIX_FMT_YUV410P,   AV_PIX_FMT_0RGB32,    AV_PIX_FMT_RGB32,     AV_PIX_FMT_YUV420P16,
1328         AV_PIX_FMT_YUV422P16, AV_PIX_FMT_YUV444P16, AV_PIX_FMT_YUV444P9,  AV_PIX_FMT_YUV422P9,
1329         AV_PIX_FMT_YUV420P9,  AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10,
1330         AV_PIX_FMT_YUV420P12, AV_PIX_FMT_YUV422P12, AV_PIX_FMT_YUV444P12,
1331         AV_PIX_FMT_YUVA444P16, AV_PIX_FMT_YUVA422P16, AV_PIX_FMT_YUVA420P16,
1332         AV_PIX_FMT_YUVA444P10, AV_PIX_FMT_YUVA422P10, AV_PIX_FMT_YUVA420P10,
1333         AV_PIX_FMT_YUVA444P9, AV_PIX_FMT_YUVA422P9, AV_PIX_FMT_YUVA420P9,
1334         AV_PIX_FMT_GRAY16,    AV_PIX_FMT_GRAY8,     AV_PIX_FMT_GBRP9,     AV_PIX_FMT_GBRP10,
1335         AV_PIX_FMT_GBRP12,    AV_PIX_FMT_GBRP14,
1336         AV_PIX_FMT_GBRAP10, AV_PIX_FMT_GBRAP12,
1337         AV_PIX_FMT_YA8,
1338         AV_PIX_FMT_GRAY10, AV_PIX_FMT_GRAY12,
1339         AV_PIX_FMT_GBRP16, AV_PIX_FMT_RGB48,
1340         AV_PIX_FMT_GBRAP16, AV_PIX_FMT_RGBA64,
1341         AV_PIX_FMT_GRAY9,
1342         AV_PIX_FMT_YUV420P14, AV_PIX_FMT_YUV422P14, AV_PIX_FMT_YUV444P14,
1343         AV_PIX_FMT_YUV440P10, AV_PIX_FMT_YUV440P12,
1344         AV_PIX_FMT_NONE
1345
1346     },
1347 #if FF_API_CODER_TYPE
1348     .defaults       = ffv1_defaults,
1349 #endif
1350     .priv_class     = &ffv1_class,
1351 };