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