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);
 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     if ((s->version == 2 || s->version>3) && avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
 543         av_log(avctx, AV_LOG_ERROR, "Version 2 needed for requested features but version 2 is experimental and not enabled\n");
 544         return AVERROR_INVALIDDATA;
 545     }
 546
 547 #if FF_API_CODER_TYPE
 548 FF_DISABLE_DEPRECATION_WARNINGS
 549     if (avctx->coder_type != -1)
 550         s->ac = avctx->coder_type > 0 ? AC_RANGE_CUSTOM_TAB : AC_GOLOMB_RICE;
 551     else
 552 FF_ENABLE_DEPRECATION_WARNINGS
 553 #endif
 554     if (s->ac == 1) // Compatbility with common command line usage
 555         s->ac = AC_RANGE_CUSTOM_TAB;
 556     else if (s->ac == AC_RANGE_DEFAULT_TAB_FORCE)
 557         s->ac = AC_RANGE_DEFAULT_TAB;
 558
 559     s->plane_count = 3;
 560     switch(avctx->pix_fmt) {
 561     case AV_PIX_FMT_YUV444P9:
 562     case AV_PIX_FMT_YUV422P9:
 563     case AV_PIX_FMT_YUV420P9:
 564     case AV_PIX_FMT_YUVA444P9:
 565     case AV_PIX_FMT_YUVA422P9:
 566     case AV_PIX_FMT_YUVA420P9:
 567         if (!avctx->bits_per_raw_sample)
 568             s->bits_per_raw_sample = 9;
 569     case AV_PIX_FMT_GRAY10:
 570     case AV_PIX_FMT_YUV444P10:
 571     case AV_PIX_FMT_YUV420P10:
 572     case AV_PIX_FMT_YUV422P10:
 573     case AV_PIX_FMT_YUVA444P10:
 574     case AV_PIX_FMT_YUVA422P10:
 575     case AV_PIX_FMT_YUVA420P10:
 576         if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
 577             s->bits_per_raw_sample = 10;
 578     case AV_PIX_FMT_GRAY12:
 579     case AV_PIX_FMT_YUV444P12:
 580     case AV_PIX_FMT_YUV420P12:
 581     case AV_PIX_FMT_YUV422P12:
 582         s->packed_at_lsb = 1;
 583         if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
 584             s->bits_per_raw_sample = 12;
 585     case AV_PIX_FMT_GRAY16:
 586     case AV_PIX_FMT_YUV444P16:
 587     case AV_PIX_FMT_YUV422P16:
 588     case AV_PIX_FMT_YUV420P16:
 589     case AV_PIX_FMT_YUVA444P16:
 590     case AV_PIX_FMT_YUVA422P16:
 591     case AV_PIX_FMT_YUVA420P16:
 592         if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample) {
 593             s->bits_per_raw_sample = 16;
 594         } else if (!s->bits_per_raw_sample) {
 595             s->bits_per_raw_sample = avctx->bits_per_raw_sample;
 596         }
 597         if (s->bits_per_raw_sample <= 8) {
 598             av_log(avctx, AV_LOG_ERROR, "bits_per_raw_sample invalid\n");
 599             return AVERROR_INVALIDDATA;
 600         }
 601         s->version = FFMAX(s->version, 1);
 602     case AV_PIX_FMT_GRAY8:
 603     case AV_PIX_FMT_YA8:
 604     case AV_PIX_FMT_YUV444P:
 605     case AV_PIX_FMT_YUV440P:
 606     case AV_PIX_FMT_YUV422P:
 607     case AV_PIX_FMT_YUV420P:
 608     case AV_PIX_FMT_YUV411P:
 609     case AV_PIX_FMT_YUV410P:
 610     case AV_PIX_FMT_YUVA444P:
 611     case AV_PIX_FMT_YUVA422P:
 612     case AV_PIX_FMT_YUVA420P:
 613         s->chroma_planes = desc->nb_components < 3 ? 0 : 1;
 614         s->colorspace = 0;
 615         s->transparency = desc->nb_components == 4 || desc->nb_components == 2;
 616         if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
 617             s->bits_per_raw_sample = 8;
 618         else if (!s->bits_per_raw_sample)
 619             s->bits_per_raw_sample = 8;
 620         break;
 621     case AV_PIX_FMT_RGB32:
 622         s->colorspace = 1;
 623         s->transparency = 1;
 624         s->chroma_planes = 1;
 625         s->bits_per_raw_sample = 8;
 626         break;
 627     case AV_PIX_FMT_RGBA64:
 628         s->colorspace = 1;
 629         s->transparency = 1;
 630         s->chroma_planes = 1;
 631         s->bits_per_raw_sample = 16;
 632         s->use32bit = 1;
 633         s->version = FFMAX(s->version, 1);
 634         break;
 635     case AV_PIX_FMT_RGB48:
 636         s->colorspace = 1;
 637         s->chroma_planes = 1;
 638         s->bits_per_raw_sample = 16;
 639         s->use32bit = 1;
 640         s->version = FFMAX(s->version, 1);
 641         break;
 642     case AV_PIX_FMT_0RGB32:
 643         s->colorspace = 1;
 644         s->chroma_planes = 1;
 645         s->bits_per_raw_sample = 8;
 646         break;
 647     case AV_PIX_FMT_GBRP9:
 648         if (!avctx->bits_per_raw_sample)
 649             s->bits_per_raw_sample = 9;
 650     case AV_PIX_FMT_GBRP10:
 651         if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
 652             s->bits_per_raw_sample = 10;
 653     case AV_PIX_FMT_GBRP12:
 654         if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
 655             s->bits_per_raw_sample = 12;
 656     case AV_PIX_FMT_GBRP14:
 657         if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
 658             s->bits_per_raw_sample = 14;
 659     case AV_PIX_FMT_GBRP16:
 660     case AV_PIX_FMT_GBRAP16:
 661         if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
 662             s->bits_per_raw_sample = 16;
 663         else if (!s->bits_per_raw_sample)
 664             s->bits_per_raw_sample = avctx->bits_per_raw_sample;
 665         s->transparency = desc->nb_components == 4 || desc->nb_components == 2;
 666         s->colorspace = 1;
 667         s->chroma_planes = 1;
 668         if (s->bits_per_raw_sample >= 16) {
 669             s->use32bit = 1;
 670         }
 671         s->version = FFMAX(s->version, 1);
 672         break;
 673     default:
 674         av_log(avctx, AV_LOG_ERROR, "format not supported\n");
 675         return AVERROR(ENOSYS);
 676     }
 677     av_assert0(s->bits_per_raw_sample >= 8);
 678
 679     if (s->bits_per_raw_sample > 8) {
 680         if (s->ac == AC_GOLOMB_RICE) {
 681             av_log(avctx, AV_LOG_INFO,
 682                     "bits_per_raw_sample > 8, forcing range coder\n");
 683             s->ac = AC_RANGE_CUSTOM_TAB;
 684         }
 685     }
 686     if (s->transparency) {
 687         av_log(avctx, AV_LOG_WARNING, "Storing alpha plane, this will require a recent FFV1 decoder to playback!\n");
 688     }
 689 #if FF_API_PRIVATE_OPT
 690 FF_DISABLE_DEPRECATION_WARNINGS
 691     if (avctx->context_model)
 692         s->context_model = avctx->context_model;
 693     if (avctx->context_model > 1U) {
 694         av_log(avctx, AV_LOG_ERROR, "Invalid context model %d, valid values are 0 and 1\n", avctx->context_model);
 695         return AVERROR(EINVAL);
 696     }
 697 FF_ENABLE_DEPRECATION_WARNINGS
 698 #endif
 699
 700     if (s->ac == AC_RANGE_CUSTOM_TAB) {
 701         for (i = 1; i < 256; i++)
 702             s->state_transition[i] = ver2_state[i];
 703     } else {
 704         RangeCoder c;
 705         ff_build_rac_states(&c, 0.05 * (1LL << 32), 256 - 8);
 706         for (i = 1; i < 256; i++)
 707             s->state_transition[i] = c.one_state[i];
 708     }
 709
 710     for (i = 0; i < 256; i++) {
 711         s->quant_table_count = 2;
 712         if (s->bits_per_raw_sample <= 8) {
 713             s->quant_tables[0][0][i]=           quant11[i];
 714             s->quant_tables[0][1][i]=        11*quant11[i];
 715             s->quant_tables[0][2][i]=     11*11*quant11[i];
 716             s->quant_tables[1][0][i]=           quant11[i];
 717             s->quant_tables[1][1][i]=        11*quant11[i];
 718             s->quant_tables[1][2][i]=     11*11*quant5 [i];
 719             s->quant_tables[1][3][i]=   5*11*11*quant5 [i];
 720             s->quant_tables[1][4][i]= 5*5*11*11*quant5 [i];
 721         } else {
 722             s->quant_tables[0][0][i]=           quant9_10bit[i];
 723             s->quant_tables[0][1][i]=        11*quant9_10bit[i];
 724             s->quant_tables[0][2][i]=     11*11*quant9_10bit[i];
 725             s->quant_tables[1][0][i]=           quant9_10bit[i];
 726             s->quant_tables[1][1][i]=        11*quant9_10bit[i];
 727             s->quant_tables[1][2][i]=     11*11*quant5_10bit[i];
 728             s->quant_tables[1][3][i]=   5*11*11*quant5_10bit[i];
 729             s->quant_tables[1][4][i]= 5*5*11*11*quant5_10bit[i];
 730         }
 731     }
 732     s->context_count[0] = (11 * 11 * 11        + 1) / 2;
 733     s->context_count[1] = (11 * 11 * 5 * 5 * 5 + 1) / 2;
 734     memcpy(s->quant_table, s->quant_tables[s->context_model],
 735            sizeof(s->quant_table));
 736
 737     for (i = 0; i < s->plane_count; i++) {
 738         PlaneContext *const p = &s->plane[i];
 739
 740         memcpy(p->quant_table, s->quant_table, sizeof(p->quant_table));
 741         p->quant_table_index = s->context_model;
 742         p->context_count     = s->context_count[p->quant_table_index];
 743     }
 744
 745     if ((ret = ff_ffv1_allocate_initial_states(s)) < 0)
 746         return ret;
 747
 748 #if FF_API_CODED_FRAME
 749 FF_DISABLE_DEPRECATION_WARNINGS
 750     avctx->coded_frame->pict_type = AV_PICTURE_TYPE_I;
 751 FF_ENABLE_DEPRECATION_WARNINGS
 752 #endif
 753
 754     if (!s->transparency)
 755         s->plane_count = 2;
 756     if (!s->chroma_planes && s->version > 3)
 757         s->plane_count--;
 758
 759     ret = av_pix_fmt_get_chroma_sub_sample (avctx->pix_fmt, &s->chroma_h_shift, &s->chroma_v_shift);
 760     if (ret)
 761         return ret;
 762
 763     s->picture_number = 0;
 764
 765     if (avctx->flags & (AV_CODEC_FLAG_PASS1 | AV_CODEC_FLAG_PASS2)) {
 766         for (i = 0; i < s->quant_table_count; i++) {
 767             s->rc_stat2[i] = av_mallocz(s->context_count[i] *
 768                                         sizeof(*s->rc_stat2[i]));
 769             if (!s->rc_stat2[i])
 770                 return AVERROR(ENOMEM);
 771         }
 772     }
 773     if (avctx->stats_in) {
 774         char *p = avctx->stats_in;
 775         uint8_t (*best_state)[256] = av_malloc_array(256, 256);
 776         int gob_count = 0;
 777         char *next;
 778         if (!best_state)
 779             return AVERROR(ENOMEM);
 780
 781         av_assert0(s->version >= 2);
 782
 783         for (;;) {
 784             for (j = 0; j < 256; j++)
 785                 for (i = 0; i < 2; i++) {
 786                     s->rc_stat[j][i] = strtol(p, &next, 0);
 787                     if (next == p) {
 788                         av_log(avctx, AV_LOG_ERROR,
 789                                "2Pass file invalid at %d %d [%s]\n", j, i, p);
 790                         av_freep(&best_state);
 791                         return AVERROR_INVALIDDATA;
 792                     }
 793                     p = next;
 794                 }
 795             for (i = 0; i < s->quant_table_count; i++)
 796                 for (j = 0; j < s->context_count[i]; j++) {
 797                     for (k = 0; k < 32; k++)
 798                         for (m = 0; m < 2; m++) {
 799                             s->rc_stat2[i][j][k][m] = strtol(p, &next, 0);
 800                             if (next == p) {
 801                                 av_log(avctx, AV_LOG_ERROR,
 802                                        "2Pass file invalid at %d %d %d %d [%s]\n",
 803                                        i, j, k, m, p);
 804                                 av_freep(&best_state);
 805                                 return AVERROR_INVALIDDATA;
 806                             }
 807                             p = next;
 808                         }
 809                 }
 810             gob_count = strtol(p, &next, 0);
 811             if (next == p || gob_count <= 0) {
 812                 av_log(avctx, AV_LOG_ERROR, "2Pass file invalid\n");
 813                 av_freep(&best_state);
 814                 return AVERROR_INVALIDDATA;
 815             }
 816             p = next;
 817             while (*p == '\n' || *p == ' ')
 818                 p++;
 819             if (p[0] == 0)
 820                 break;
 821         }
 822         if (s->ac == AC_RANGE_CUSTOM_TAB)
 823             sort_stt(s, s->state_transition);
 824
 825         find_best_state(best_state, s->state_transition);
 826
 827         for (i = 0; i < s->quant_table_count; i++) {
 828             for (k = 0; k < 32; k++) {
 829                 double a=0, b=0;
 830                 int jp = 0;
 831                 for (j = 0; j < s->context_count[i]; j++) {
 832                     double p = 128;
 833                     if (s->rc_stat2[i][j][k][0] + s->rc_stat2[i][j][k][1] > 200 && j || a+b > 200) {
 834                         if (a+b)
 835                             p = 256.0 * b / (a + b);
 836                         s->initial_states[i][jp][k] =
 837                             best_state[av_clip(round(p), 1, 255)][av_clip_uint8((a + b) / gob_count)];
 838                         for(jp++; jp<j; jp++)
 839                             s->initial_states[i][jp][k] = s->initial_states[i][jp-1][k];
 840                         a=b=0;
 841                     }
 842                     a += s->rc_stat2[i][j][k][0];
 843                     b += s->rc_stat2[i][j][k][1];
 844                     if (a+b) {
 845                         p = 256.0 * b / (a + b);
 846                     }
 847                     s->initial_states[i][j][k] =
 848                         best_state[av_clip(round(p), 1, 255)][av_clip_uint8((a + b) / gob_count)];
 849                 }
 850             }
 851         }
 852         av_freep(&best_state);
 853     }
 854
 855     if (s->version > 1) {
 856         int plane_count = 1 + 2*s->chroma_planes + s->transparency;
 857         int max_h_slices = AV_CEIL_RSHIFT(avctx->width , s->chroma_h_shift);
 858         int max_v_slices = AV_CEIL_RSHIFT(avctx->height, s->chroma_v_shift);
 859         s->num_v_slices = (avctx->width > 352 || avctx->height > 288 || !avctx->slices) ? 2 : 1;
 860
 861         s->num_v_slices = FFMIN(s->num_v_slices, max_v_slices);
 862
 863         for (; s->num_v_slices < 32; s->num_v_slices++) {
 864             for (s->num_h_slices = s->num_v_slices; s->num_h_slices < 2*s->num_v_slices; s->num_h_slices++) {
 865                 int maxw = (avctx->width  + s->num_h_slices - 1) / s->num_h_slices;
 866                 int maxh = (avctx->height + s->num_v_slices - 1) / s->num_v_slices;
 867                 if (s->num_h_slices > max_h_slices || s->num_v_slices > max_v_slices)
 868                     continue;
 869                 if (maxw * maxh * (int64_t)(s->bits_per_raw_sample+1) * plane_count > 8<<24)
 870                     continue;
 871                 if (avctx->slices == s->num_h_slices * s->num_v_slices && avctx->slices <= MAX_SLICES || !avctx->slices)
 872                     goto slices_ok;
 873             }
 874         }
 875         av_log(avctx, AV_LOG_ERROR,
 876                "Unsupported number %d of slices requested, please specify a "
 877                "supported number with -slices (ex:4,6,9,12,16, ...)\n",
 878                avctx->slices);
 879         return AVERROR(ENOSYS);
 880 slices_ok:
 881         if ((ret = write_extradata(s)) < 0)
 882             return ret;
 883     }
 884
 885     if ((ret = ff_ffv1_init_slice_contexts(s)) < 0)
 886         return ret;
 887     s->slice_count = s->max_slice_count;
 888     if ((ret = ff_ffv1_init_slices_state(s)) < 0)
 889         return ret;
 890
 891 #define STATS_OUT_SIZE 1024 * 1024 * 6
 892     if (avctx->flags & AV_CODEC_FLAG_PASS1) {
 893         avctx->stats_out = av_mallocz(STATS_OUT_SIZE);
 894         if (!avctx->stats_out)
 895             return AVERROR(ENOMEM);
 896         for (i = 0; i < s->quant_table_count; i++)
 897             for (j = 0; j < s->max_slice_count; j++) {
 898                 FFV1Context *sf = s->slice_context[j];
 899                 av_assert0(!sf->rc_stat2[i]);
 900                 sf->rc_stat2[i] = av_mallocz(s->context_count[i] *
 901                                              sizeof(*sf->rc_stat2[i]));
 902                 if (!sf->rc_stat2[i])
 903                     return AVERROR(ENOMEM);
 904             }
 905     }
 906
 907     return 0;
 908 }
 909
 910 static void encode_slice_header(FFV1Context *f, FFV1Context *fs)
 911 {
 912     RangeCoder *c = &fs->c;
 913     uint8_t state[CONTEXT_SIZE];
 914     int j;
 915     memset(state, 128, sizeof(state));
 916
 917     put_symbol(c, state, (fs->slice_x     +1)*f->num_h_slices / f->width   , 0);
 918     put_symbol(c, state, (fs->slice_y     +1)*f->num_v_slices / f->height  , 0);
 919     put_symbol(c, state, (fs->slice_width +1)*f->num_h_slices / f->width -1, 0);
 920     put_symbol(c, state, (fs->slice_height+1)*f->num_v_slices / f->height-1, 0);
 921     for (j=0; j<f->plane_count; j++) {
 922         put_symbol(c, state, f->plane[j].quant_table_index, 0);
 923         av_assert0(f->plane[j].quant_table_index == f->context_model);
 924     }
 925     if (!f->picture.f->interlaced_frame)
 926         put_symbol(c, state, 3, 0);
 927     else
 928         put_symbol(c, state, 1 + !f->picture.f->top_field_first, 0);
 929     put_symbol(c, state, f->picture.f->sample_aspect_ratio.num, 0);
 930     put_symbol(c, state, f->picture.f->sample_aspect_ratio.den, 0);
 931     if (f->version > 3) {
 932         put_rac(c, state, fs->slice_coding_mode == 1);
 933         if (fs->slice_coding_mode == 1)
 934             ff_ffv1_clear_slice_state(f, fs);
 935         put_symbol(c, state, fs->slice_coding_mode, 0);
 936         if (fs->slice_coding_mode != 1) {
 937             put_symbol(c, state, fs->slice_rct_by_coef, 0);
 938             put_symbol(c, state, fs->slice_rct_ry_coef, 0);
 939         }
 940     }
 941 }
 942
 943 static void choose_rct_params(FFV1Context *fs, const uint8_t *src[3], const int stride[3], int w, int h)
 944 {
 945 #define NB_Y_COEFF 15
 946     static const int rct_y_coeff[15][2] = {
 947         {0, 0}, //      4G
 948         {1, 1}, //  R + 2G + B
 949         {2, 2}, // 2R      + 2B
 950         {0, 2}, //      2G + 2B
 951         {2, 0}, // 2R + 2G
 952         {4, 0}, // 4R
 953         {0, 4}, //           4B
 954
 955         {0, 3}, //      1G + 3B
 956         {3, 0}, // 3R + 1G
 957         {3, 1}, // 3R      +  B
 958         {1, 3}, //  R      + 3B
 959         {1, 2}, //  R +  G + 2B
 960         {2, 1}, // 2R +  G +  B
 961         {0, 1}, //      3G +  B
 962         {1, 0}, //  R + 3G
 963     };
 964
 965     int stat[NB_Y_COEFF] = {0};
 966     int x, y, i, p, best;
 967     int16_t *sample[3];
 968     int lbd = fs->bits_per_raw_sample <= 8;
 969
 970     for (y = 0; y < h; y++) {
 971         int lastr=0, lastg=0, lastb=0;
 972         for (p = 0; p < 3; p++)
 973             sample[p] = fs->sample_buffer + p*w;
 974
 975         for (x = 0; x < w; x++) {
 976             int b, g, r;
 977             int ab, ag, ar;
 978             if (lbd) {
 979                 unsigned v = *((const uint32_t*)(src[0] + x*4 + stride[0]*y));
 980                 b =  v        & 0xFF;
 981                 g = (v >>  8) & 0xFF;
 982                 r = (v >> 16) & 0xFF;
 983             } else {
 984                 b = *((const uint16_t*)(src[0] + x*2 + stride[0]*y));
 985                 g = *((const uint16_t*)(src[1] + x*2 + stride[1]*y));
 986                 r = *((const uint16_t*)(src[2] + x*2 + stride[2]*y));
 987             }
 988
 989             ar = r - lastr;
 990             ag = g - lastg;
 991             ab = b - lastb;
 992             if (x && y) {
 993                 int bg = ag - sample[0][x];
 994                 int bb = ab - sample[1][x];
 995                 int br = ar - sample[2][x];
 996
 997                 br -= bg;
 998                 bb -= bg;
 999
1000                 for (i = 0; i<NB_Y_COEFF; i++) {
1001                     stat[i] += FFABS(bg + ((br*rct_y_coeff[i][0] + bb*rct_y_coeff[i][1])>>2));
1002                 }
1003
1004             }
1005             sample[0][x] = ag;
1006             sample[1][x] = ab;
1007             sample[2][x] = ar;
1008
1009             lastr = r;
1010             lastg = g;
1011             lastb = b;
1012         }
1013     }
1014
1015     best = 0;
1016     for (i=1; i<NB_Y_COEFF; i++) {
1017         if (stat[i] < stat[best])
1018             best = i;
1019     }
1020
1021     fs->slice_rct_by_coef = rct_y_coeff[best][1];
1022     fs->slice_rct_ry_coef = rct_y_coeff[best][0];
1023 }
1024
1025 static int encode_slice(AVCodecContext *c, void *arg)
1026 {
1027     FFV1Context *fs  = *(void **)arg;
1028     FFV1Context *f   = fs->avctx->priv_data;
1029     int width        = fs->slice_width;
1030     int height       = fs->slice_height;
1031     int x            = fs->slice_x;
1032     int y            = fs->slice_y;
1033     const AVFrame *const p = f->picture.f;
1034     const int ps     = av_pix_fmt_desc_get(c->pix_fmt)->comp[0].step;
1035     int ret;
1036     RangeCoder c_bak = fs->c;
1037     const uint8_t *planes[4] = {p->data[0] + ps*x + y*p->linesize[0],
1038                                 p->data[1] ? p->data[1] + ps*x + y*p->linesize[1] : NULL,
1039                                 p->data[2] ? p->data[2] + ps*x + y*p->linesize[2] : NULL,
1040                                 p->data[3] ? p->data[3] + ps*x + y*p->linesize[3] : NULL};
1041
1042     fs->slice_coding_mode = 0;
1043     if (f->version > 3) {
1044         choose_rct_params(fs, planes, p->linesize, width, height);
1045     } else {
1046         fs->slice_rct_by_coef = 1;
1047         fs->slice_rct_ry_coef = 1;
1048     }
1049
1050 retry:
1051     if (f->key_frame)
1052         ff_ffv1_clear_slice_state(f, fs);
1053     if (f->version > 2) {
1054         encode_slice_header(f, fs);
1055     }
1056     if (fs->ac == AC_GOLOMB_RICE) {
1057         if (f->version > 2)
1058             put_rac(&fs->c, (uint8_t[]) { 129 }, 0);
1059         fs->ac_byte_count = f->version > 2 || (!x && !y) ? ff_rac_terminate(&fs->c) : 0;
1060         init_put_bits(&fs->pb,
1061                       fs->c.bytestream_start + fs->ac_byte_count,
1062                       fs->c.bytestream_end - fs->c.bytestream_start - fs->ac_byte_count);
1063     }
1064
1065     if (f->colorspace == 0 && c->pix_fmt != AV_PIX_FMT_YA8) {
1066         const int chroma_width  = AV_CEIL_RSHIFT(width,  f->chroma_h_shift);
1067         const int chroma_height = AV_CEIL_RSHIFT(height, f->chroma_v_shift);
1068         const int cx            = x >> f->chroma_h_shift;
1069         const int cy            = y >> f->chroma_v_shift;
1070
1071         ret = encode_plane(fs, p->data[0] + ps*x + y*p->linesize[0], width, height, p->linesize[0], 0, 1);
1072
1073         if (f->chroma_planes) {
1074             ret |= encode_plane(fs, p->data[1] + ps*cx+cy*p->linesize[1], chroma_width, chroma_height, p->linesize[1], 1, 1);
1075             ret |= encode_plane(fs, p->data[2] + ps*cx+cy*p->linesize[2], chroma_width, chroma_height, p->linesize[2], 1, 1);
1076         }
1077         if (fs->transparency)
1078             ret |= encode_plane(fs, p->data[3] + ps*x + y*p->linesize[3], width, height, p->linesize[3], 2, 1);
1079     } else if (c->pix_fmt == AV_PIX_FMT_YA8) {
1080         ret  = encode_plane(fs, p->data[0] +     ps*x + y*p->linesize[0], width, height, p->linesize[0], 0, 2);
1081         ret |= encode_plane(fs, p->data[0] + 1 + ps*x + y*p->linesize[0], width, height, p->linesize[0], 1, 2);
1082     } else if (f->use32bit) {
1083         ret = encode_rgb_frame32(fs, planes, width, height, p->linesize);
1084     } else {
1085         ret = encode_rgb_frame(fs, planes, width, height, p->linesize);
1086     }
1087     emms_c();
1088
1089     if (ret < 0) {
1090         av_assert0(fs->slice_coding_mode == 0);
1091         if (fs->version < 4 || !fs->ac) {
1092             av_log(c, AV_LOG_ERROR, "Buffer too small\n");
1093             return ret;
1094         }
1095         av_log(c, AV_LOG_DEBUG, "Coding slice as PCM\n");
1096         fs->slice_coding_mode = 1;
1097         fs->c = c_bak;
1098         goto retry;
1099     }
1100
1101     return 0;
1102 }
1103
1104 static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
1105                         const AVFrame *pict, int *got_packet)
1106 {
1107     FFV1Context *f      = avctx->priv_data;
1108     RangeCoder *const c = &f->slice_context[0]->c;
1109     AVFrame *const p    = f->picture.f;
1110     uint8_t keystate    = 128;
1111     uint8_t *buf_p;
1112     int i, ret;
1113     int64_t maxsize =   AV_INPUT_BUFFER_MIN_SIZE
1114                       + avctx->width*avctx->height*37LL*4;
1115
1116     if(!pict) {
1117         if (avctx->flags & AV_CODEC_FLAG_PASS1) {
1118             int j, k, m;
1119             char *p   = avctx->stats_out;
1120             char *end = p + STATS_OUT_SIZE;
1121
1122             memset(f->rc_stat, 0, sizeof(f->rc_stat));
1123             for (i = 0; i < f->quant_table_count; i++)
1124                 memset(f->rc_stat2[i], 0, f->context_count[i] * sizeof(*f->rc_stat2[i]));
1125
1126             av_assert0(f->slice_count == f->max_slice_count);
1127             for (j = 0; j < f->slice_count; j++) {
1128                 FFV1Context *fs = f->slice_context[j];
1129                 for (i = 0; i < 256; i++) {
1130                     f->rc_stat[i][0] += fs->rc_stat[i][0];
1131                     f->rc_stat[i][1] += fs->rc_stat[i][1];
1132                 }
1133                 for (i = 0; i < f->quant_table_count; i++) {
1134                     for (k = 0; k < f->context_count[i]; k++)
1135                         for (m = 0; m < 32; m++) {
1136                             f->rc_stat2[i][k][m][0] += fs->rc_stat2[i][k][m][0];
1137                             f->rc_stat2[i][k][m][1] += fs->rc_stat2[i][k][m][1];
1138                         }
1139                 }
1140             }
1141
1142             for (j = 0; j < 256; j++) {
1143                 snprintf(p, end - p, "%" PRIu64 " %" PRIu64 " ",
1144                         f->rc_stat[j][0], f->rc_stat[j][1]);
1145                 p += strlen(p);
1146             }
1147             snprintf(p, end - p, "\n");
1148
1149             for (i = 0; i < f->quant_table_count; i++) {
1150                 for (j = 0; j < f->context_count[i]; j++)
1151                     for (m = 0; m < 32; m++) {
1152                         snprintf(p, end - p, "%" PRIu64 " %" PRIu64 " ",
1153                                 f->rc_stat2[i][j][m][0], f->rc_stat2[i][j][m][1]);
1154                         p += strlen(p);
1155                     }
1156             }
1157             snprintf(p, end - p, "%d\n", f->gob_count);
1158         }
1159         return 0;
1160     }
1161
1162     if (f->version > 3)
1163         maxsize = AV_INPUT_BUFFER_MIN_SIZE + avctx->width*avctx->height*3LL*4;
1164
1165     if (maxsize > INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE - 32) {
1166         av_log(avctx, AV_LOG_WARNING, "Cannot allocate worst case packet size, the encoding could fail\n");
1167         maxsize = INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE - 32;
1168     }
1169
1170     if ((ret = ff_alloc_packet2(avctx, pkt, maxsize, 0)) < 0)
1171         return ret;
1172
1173     ff_init_range_encoder(c, pkt->data, pkt->size);
1174     ff_build_rac_states(c, 0.05 * (1LL << 32), 256 - 8);
1175
1176     av_frame_unref(p);
1177     if ((ret = av_frame_ref(p, pict)) < 0)
1178         return ret;
1179 #if FF_API_CODED_FRAME
1180 FF_DISABLE_DEPRECATION_WARNINGS
1181     avctx->coded_frame->pict_type = AV_PICTURE_TYPE_I;
1182 FF_ENABLE_DEPRECATION_WARNINGS
1183 #endif
1184
1185     if (avctx->gop_size == 0 || f->picture_number % avctx->gop_size == 0) {
1186         put_rac(c, &keystate, 1);
1187         f->key_frame = 1;
1188         f->gob_count++;
1189         write_header(f);
1190     } else {
1191         put_rac(c, &keystate, 0);
1192         f->key_frame = 0;
1193     }
1194
1195     if (f->ac == AC_RANGE_CUSTOM_TAB) {
1196         int i;
1197         for (i = 1; i < 256; i++) {
1198             c->one_state[i]        = f->state_transition[i];
1199             c->zero_state[256 - i] = 256 - c->one_state[i];
1200         }
1201     }
1202
1203     for (i = 0; i < f->slice_count; i++) {
1204         FFV1Context *fs = f->slice_context[i];
1205         uint8_t *start  = pkt->data + pkt->size * (int64_t)i / f->slice_count;
1206         int len         = pkt->size / f->slice_count;
1207         if (i) {
1208             ff_init_range_encoder(&fs->c, start, len);
1209         } else {
1210             av_assert0(fs->c.bytestream_end >= fs->c.bytestream_start + len);
1211             av_assert0(fs->c.bytestream < fs->c.bytestream_start + len);
1212             fs->c.bytestream_end = fs->c.bytestream_start + len;
1213         }
1214     }
1215     avctx->execute(avctx, encode_slice, &f->slice_context[0], NULL,
1216                    f->slice_count, sizeof(void *));
1217
1218     buf_p = pkt->data;
1219     for (i = 0; i < f->slice_count; i++) {
1220         FFV1Context *fs = f->slice_context[i];
1221         int bytes;
1222
1223         if (fs->ac != AC_GOLOMB_RICE) {
1224             uint8_t state = 129;
1225             put_rac(&fs->c, &state, 0);
1226             bytes = ff_rac_terminate(&fs->c);
1227         } else {
1228             flush_put_bits(&fs->pb); // FIXME: nicer padding
1229             bytes = fs->ac_byte_count + (put_bits_count(&fs->pb) + 7) / 8;
1230         }
1231         if (i > 0 || f->version > 2) {
1232             av_assert0(bytes < pkt->size / f->slice_count);
1233             memmove(buf_p, fs->c.bytestream_start, bytes);
1234             av_assert0(bytes < (1 << 24));
1235             AV_WB24(buf_p + bytes, bytes);
1236             bytes += 3;
1237         }
1238         if (f->ec) {
1239             unsigned v;
1240             buf_p[bytes++] = 0;
1241             v = av_crc(av_crc_get_table(AV_CRC_32_IEEE), 0, buf_p, bytes);
1242             AV_WL32(buf_p + bytes, v);
1243             bytes += 4;
1244         }
1245         buf_p += bytes;
1246     }
1247
1248     if (avctx->flags & AV_CODEC_FLAG_PASS1)
1249         avctx->stats_out[0] = '\0';
1250
1251 #if FF_API_CODED_FRAME
1252 FF_DISABLE_DEPRECATION_WARNINGS
1253     avctx->coded_frame->key_frame = f->key_frame;
1254 FF_ENABLE_DEPRECATION_WARNINGS
1255 #endif
1256
1257     f->picture_number++;
1258     pkt->size   = buf_p - pkt->data;
1259     pkt->pts    =
1260     pkt->dts    = pict->pts;
1261     pkt->flags |= AV_PKT_FLAG_KEY * f->key_frame;
1262     *got_packet = 1;
1263
1264     return 0;
1265 }
1266
1267 static av_cold int encode_close(AVCodecContext *avctx)
1268 {
1269     ff_ffv1_close(avctx);
1270     return 0;
1271 }
1272
1273 #define OFFSET(x) offsetof(FFV1Context, x)
1274 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
1275 static const AVOption options[] = {
1276     { "slicecrc", "Protect slices with CRCs", OFFSET(ec), AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, VE },
1277     { "coder", "Coder type", OFFSET(ac), AV_OPT_TYPE_INT,
1278             { .i64 = 0 }, -2, 2, VE, "coder" },
1279         { "rice", "Golomb rice", 0, AV_OPT_TYPE_CONST,
1280             { .i64 = AC_GOLOMB_RICE }, INT_MIN, INT_MAX, VE, "coder" },
1281         { "range_def", "Range with default table", 0, AV_OPT_TYPE_CONST,
1282             { .i64 = AC_RANGE_DEFAULT_TAB_FORCE }, INT_MIN, INT_MAX, VE, "coder" },
1283         { "range_tab", "Range with custom table", 0, AV_OPT_TYPE_CONST,
1284             { .i64 = AC_RANGE_CUSTOM_TAB }, INT_MIN, INT_MAX, VE, "coder" },
1285         { "ac", "Range with custom table (the ac option exists for compatibility and is deprecated)", 0, AV_OPT_TYPE_CONST,
1286             { .i64 = 1 }, INT_MIN, INT_MAX, VE, "coder" },
1287     { "context", "Context model", OFFSET(context_model), AV_OPT_TYPE_INT,
1288             { .i64 = 0 }, 0, 1, VE },
1289
1290     { NULL }
1291 };
1292
1293 static const AVClass ffv1_class = {
1294     .class_name = "ffv1 encoder",
1295     .item_name  = av_default_item_name,
1296     .option     = options,
1297     .version    = LIBAVUTIL_VERSION_INT,
1298 };
1299
1300 #if FF_API_CODER_TYPE
1301 static const AVCodecDefault ffv1_defaults[] = {
1302     { "coder", "-1" },
1303     { NULL },
1304 };
1305 #endif
1306
1307 AVCodec ff_ffv1_encoder = {
1308     .name           = "ffv1",
1309     .long_name      = NULL_IF_CONFIG_SMALL("FFmpeg video codec #1"),
1310     .type           = AVMEDIA_TYPE_VIDEO,
1311     .id             = AV_CODEC_ID_FFV1,
1312     .priv_data_size = sizeof(FFV1Context),
1313     .init           = encode_init,
1314     .encode2        = encode_frame,
1315     .close          = encode_close,
1316     .capabilities   = AV_CODEC_CAP_SLICE_THREADS | AV_CODEC_CAP_DELAY,
1317     .pix_fmts       = (const enum AVPixelFormat[]) {
1318         AV_PIX_FMT_YUV420P,   AV_PIX_FMT_YUVA420P,  AV_PIX_FMT_YUVA422P,  AV_PIX_FMT_YUV444P,
1319         AV_PIX_FMT_YUVA444P,  AV_PIX_FMT_YUV440P,   AV_PIX_FMT_YUV422P,   AV_PIX_FMT_YUV411P,
1320         AV_PIX_FMT_YUV410P,   AV_PIX_FMT_0RGB32,    AV_PIX_FMT_RGB32,     AV_PIX_FMT_YUV420P16,
1321         AV_PIX_FMT_YUV422P16, AV_PIX_FMT_YUV444P16, AV_PIX_FMT_YUV444P9,  AV_PIX_FMT_YUV422P9,
1322         AV_PIX_FMT_YUV420P9,  AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10,
1323         AV_PIX_FMT_YUV420P12, AV_PIX_FMT_YUV422P12, AV_PIX_FMT_YUV444P12,
1324         AV_PIX_FMT_YUVA444P16, AV_PIX_FMT_YUVA422P16, AV_PIX_FMT_YUVA420P16,
1325         AV_PIX_FMT_YUVA444P10, AV_PIX_FMT_YUVA422P10, AV_PIX_FMT_YUVA420P10,
1326         AV_PIX_FMT_YUVA444P9, AV_PIX_FMT_YUVA422P9, AV_PIX_FMT_YUVA420P9,
1327         AV_PIX_FMT_GRAY16,    AV_PIX_FMT_GRAY8,     AV_PIX_FMT_GBRP9,     AV_PIX_FMT_GBRP10,
1328         AV_PIX_FMT_GBRP12,    AV_PIX_FMT_GBRP14,
1329         AV_PIX_FMT_YA8,
1330         AV_PIX_FMT_GRAY10, AV_PIX_FMT_GRAY12,
1331         AV_PIX_FMT_GBRP16, AV_PIX_FMT_RGB48,
1332         AV_PIX_FMT_GBRAP16, AV_PIX_FMT_RGBA64,
1333         AV_PIX_FMT_NONE
1334
1335     },
1336 #if FF_API_CODER_TYPE
1337     .defaults       = ffv1_defaults,
1338 #endif
1339     .priv_class     = &ffv1_class,
1340 };