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

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