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