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