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

   1 /*
   2  * FFV1 encoder
   3  *
   4  * Copyright (c) 2003-2012 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 * 20) {
 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     for (x = 0; x < w; x++) {
 290         int diff, context;
 291
 292         context = get_context(p, sample[0] + x, sample[1] + x, sample[2] + x);
 293         diff    = sample[0][x] - predict(sample[0] + x, sample[1] + x);
 294
 295         if (context < 0) {
 296             context = -context;
 297             diff    = -diff;
 298         }
 299
 300         diff = fold(diff, bits);
 301
 302         if (s->ac) {
 303             if (s->flags & CODEC_FLAG_PASS1) {
 304                 put_symbol_inline(c, p->state[context], diff, 1, s->rc_stat,
 305                                   s->rc_stat2[p->quant_table_index][context]);
 306             } else {
 307                 put_symbol_inline(c, p->state[context], diff, 1, NULL, NULL);
 308             }
 309         } else {
 310             if (context == 0)
 311                 run_mode = 1;
 312
 313             if (run_mode) {
 314                 if (diff) {
 315                     while (run_count >= 1 << ff_log2_run[run_index]) {
 316                         run_count -= 1 << ff_log2_run[run_index];
 317                         run_index++;
 318                         put_bits(&s->pb, 1, 1);
 319                     }
 320
 321                     put_bits(&s->pb, 1 + ff_log2_run[run_index], run_count);
 322                     if (run_index)
 323                         run_index--;
 324                     run_count = 0;
 325                     run_mode  = 0;
 326                     if (diff > 0)
 327                         diff--;
 328                 } else {
 329                     run_count++;
 330                 }
 331             }
 332
 333             av_dlog(s->avctx, "count:%d index:%d, mode:%d, x:%d pos:%d\n",
 334                     run_count, run_index, run_mode, x,
 335                     (int)put_bits_count(&s->pb));
 336
 337             if (run_mode == 0)
 338                 put_vlc_symbol(&s->pb, &p->vlc_state[context], diff, bits);
 339         }
 340     }
 341     if (run_mode) {
 342         while (run_count >= 1 << ff_log2_run[run_index]) {
 343             run_count -= 1 << ff_log2_run[run_index];
 344             run_index++;
 345             put_bits(&s->pb, 1, 1);
 346         }
 347
 348         if (run_count)
 349             put_bits(&s->pb, 1, 1);
 350     }
 351     s->run_index = run_index;
 352
 353     return 0;
 354 }
 355
 356 static void encode_plane(FFV1Context *s, uint8_t *src, int w, int h,
 357                          int stride, int plane_index)
 358 {
 359     int x, y, i;
 360     const int ring_size = s->avctx->context_model ? 3 : 2;
 361     int16_t *sample[3];
 362     s->run_index = 0;
 363
 364     memset(s->sample_buffer, 0, ring_size * (w + 6) * sizeof(*s->sample_buffer));
 365
 366     for (y = 0; y < h; y++) {
 367         for (i = 0; i < ring_size; i++)
 368             sample[i] = s->sample_buffer + (w + 6) * ((h + i - y) % ring_size) + 3;
 369
 370         sample[0][-1]= sample[1][0  ];
 371         sample[1][ w]= sample[1][w-1];
 372 // { START_TIMER
 373         if (s->bits_per_raw_sample <= 8) {
 374             for (x = 0; x < w; x++)
 375                 sample[0][x] = src[x + stride * y];
 376             encode_line(s, w, sample, plane_index, 8);
 377         } else {
 378             if (s->packed_at_lsb) {
 379                 for (x = 0; x < w; x++) {
 380                     sample[0][x] = ((uint16_t*)(src + stride*y))[x];
 381                 }
 382             } else {
 383                 for (x = 0; x < w; x++) {
 384                     sample[0][x] = ((uint16_t*)(src + stride*y))[x] >> (16 - s->bits_per_raw_sample);
 385                 }
 386             }
 387             encode_line(s, w, sample, plane_index, s->bits_per_raw_sample);
 388         }
 389 // STOP_TIMER("encode line") }
 390     }
 391 }
 392
 393 static void encode_rgb_frame(FFV1Context *s, uint8_t *src[3], int w, int h, int stride[3])
 394 {
 395     int x, y, p, i;
 396     const int ring_size = s->avctx->context_model ? 3 : 2;
 397     int16_t *sample[4][3];
 398     int lbd    = s->bits_per_raw_sample <= 8;
 399     int bits   = s->bits_per_raw_sample > 0 ? s->bits_per_raw_sample : 8;
 400     int offset = 1 << bits;
 401
 402     s->run_index = 0;
 403
 404     memset(s->sample_buffer, 0, ring_size * MAX_PLANES *
 405                                 (w + 6) * sizeof(*s->sample_buffer));
 406
 407     for (y = 0; y < h; y++) {
 408         for (i = 0; i < ring_size; i++)
 409             for (p = 0; p < MAX_PLANES; p++)
 410                 sample[p][i]= s->sample_buffer + p*ring_size*(w+6) + ((h+i-y)%ring_size)*(w+6) + 3;
 411
 412         for (x = 0; x < w; x++) {
 413             int b, g, r, av_uninit(a);
 414             if (lbd) {
 415                 unsigned v = *((uint32_t*)(src[0] + x*4 + stride[0]*y));
 416                 b =  v        & 0xFF;
 417                 g = (v >>  8) & 0xFF;
 418                 r = (v >> 16) & 0xFF;
 419                 a =  v >> 24;
 420             } else {
 421                 b = *((uint16_t*)(src[0] + x*2 + stride[0]*y));
 422                 g = *((uint16_t*)(src[1] + x*2 + stride[1]*y));
 423                 r = *((uint16_t*)(src[2] + x*2 + stride[2]*y));
 424             }
 425
 426             b -= g;
 427             r -= g;
 428             g += (b + r) >> 2;
 429             b += offset;
 430             r += offset;
 431
 432             sample[0][0][x] = g;
 433             sample[1][0][x] = b;
 434             sample[2][0][x] = r;
 435             sample[3][0][x] = a;
 436         }
 437         for (p = 0; p < 3 + s->transparency; p++) {
 438             sample[p][0][-1] = sample[p][1][0  ];
 439             sample[p][1][ w] = sample[p][1][w-1];
 440             if (lbd)
 441                 encode_line(s, w, sample[p], (p + 1) / 2, 9);
 442             else
 443                 encode_line(s, w, sample[p], (p + 1) / 2, bits + 1);
 444         }
 445     }
 446 }
 447
 448 static void write_quant_table(RangeCoder *c, int16_t *quant_table)
 449 {
 450     int last = 0;
 451     int i;
 452     uint8_t state[CONTEXT_SIZE];
 453     memset(state, 128, sizeof(state));
 454
 455     for (i = 1; i < 128; i++)
 456         if (quant_table[i] != quant_table[i - 1]) {
 457             put_symbol(c, state, i - last - 1, 0);
 458             last = i;
 459         }
 460     put_symbol(c, state, i - last - 1, 0);
 461 }
 462
 463 static void write_quant_tables(RangeCoder *c,
 464                                int16_t quant_table[MAX_CONTEXT_INPUTS][256])
 465 {
 466     int i;
 467     for (i = 0; i < 5; i++)
 468         write_quant_table(c, quant_table[i]);
 469 }
 470
 471 static void write_header(FFV1Context *f)
 472 {
 473     uint8_t state[CONTEXT_SIZE];
 474     int i, j;
 475     RangeCoder *const c = &f->slice_context[0]->c;
 476
 477     memset(state, 128, sizeof(state));
 478
 479     if (f->version < 2) {
 480         put_symbol(c, state, f->version, 0);
 481         put_symbol(c, state, f->ac, 0);
 482         if (f->ac > 1) {
 483             for (i = 1; i < 256; i++)
 484                 put_symbol(c, state,
 485                            f->state_transition[i] - c->one_state[i], 1);
 486         }
 487         put_symbol(c, state, f->colorspace, 0); //YUV cs type
 488         if (f->version > 0)
 489             put_symbol(c, state, f->bits_per_raw_sample, 0);
 490         put_rac(c, state, f->chroma_planes);
 491         put_symbol(c, state, f->chroma_h_shift, 0);
 492         put_symbol(c, state, f->chroma_v_shift, 0);
 493         put_rac(c, state, f->transparency);
 494
 495         write_quant_tables(c, f->quant_table);
 496     } else if (f->version < 3) {
 497         put_symbol(c, state, f->slice_count, 0);
 498         for (i = 0; i < f->slice_count; i++) {
 499             FFV1Context *fs = f->slice_context[i];
 500             put_symbol(c, state,
 501                        (fs->slice_x      + 1) * f->num_h_slices / f->width, 0);
 502             put_symbol(c, state,
 503                        (fs->slice_y      + 1) * f->num_v_slices / f->height, 0);
 504             put_symbol(c, state,
 505                        (fs->slice_width  + 1) * f->num_h_slices / f->width - 1,
 506                        0);
 507             put_symbol(c, state,
 508                        (fs->slice_height + 1) * f->num_v_slices / f->height - 1,
 509                        0);
 510             for (j = 0; j < f->plane_count; j++) {
 511                 put_symbol(c, state, f->plane[j].quant_table_index, 0);
 512                 av_assert0(f->plane[j].quant_table_index == f->avctx->context_model);
 513             }
 514         }
 515     }
 516 }
 517
 518 static int write_extradata(FFV1Context *f)
 519 {
 520     RangeCoder *const c = &f->c;
 521     uint8_t state[CONTEXT_SIZE];
 522     int i, j, k;
 523     uint8_t state2[32][CONTEXT_SIZE];
 524     unsigned v;
 525
 526     memset(state2, 128, sizeof(state2));
 527     memset(state, 128, sizeof(state));
 528
 529     f->avctx->extradata_size = 10000 + 4 +
 530                                     (11 * 11 * 5 * 5 * 5 + 11 * 11 * 11) * 32;
 531     f->avctx->extradata = av_malloc(f->avctx->extradata_size);
 532     ff_init_range_encoder(c, f->avctx->extradata, f->avctx->extradata_size);
 533     ff_build_rac_states(c, 0.05 * (1LL << 32), 256 - 8);
 534
 535     put_symbol(c, state, f->version, 0);
 536     if (f->version > 2) {
 537         if (f->version == 3)
 538             f->minor_version = 4;
 539         put_symbol(c, state, f->minor_version, 0);
 540     }
 541
 542     put_symbol(c, state, f->ac, 0);
 543     if (f->ac > 1)
 544         for (i = 1; i < 256; i++)
 545             put_symbol(c, state, f->state_transition[i] - c->one_state[i], 1);
 546
 547     put_symbol(c, state, f->colorspace, 0); // YUV cs type
 548     put_symbol(c, state, f->bits_per_raw_sample, 0);
 549     put_rac(c, state, f->chroma_planes);
 550     put_symbol(c, state, f->chroma_h_shift, 0);
 551     put_symbol(c, state, f->chroma_v_shift, 0);
 552     put_rac(c, state, f->transparency);
 553     put_symbol(c, state, f->num_h_slices - 1, 0);
 554     put_symbol(c, state, f->num_v_slices - 1, 0);
 555
 556     put_symbol(c, state, f->quant_table_count, 0);
 557     for (i = 0; i < f->quant_table_count; i++)
 558         write_quant_tables(c, f->quant_tables[i]);
 559
 560     for (i = 0; i < f->quant_table_count; i++) {
 561         for (j = 0; j < f->context_count[i] * CONTEXT_SIZE; j++)
 562             if (f->initial_states[i] && f->initial_states[i][0][j] != 128)
 563                 break;
 564         if (j < f->context_count[i] * CONTEXT_SIZE) {
 565             put_rac(c, state, 1);
 566             for (j = 0; j < f->context_count[i]; j++)
 567                 for (k = 0; k < CONTEXT_SIZE; k++) {
 568                     int pred = j ? f->initial_states[i][j - 1][k] : 128;
 569                     put_symbol(c, state2[k],
 570                                (int8_t)(f->initial_states[i][j][k] - pred), 1);
 571                 }
 572         } else {
 573             put_rac(c, state, 0);
 574         }
 575     }
 576
 577     if (f->version > 2) {
 578         put_symbol(c, state, f->ec, 0);
 579         put_symbol(c, state, f->intra = (f->avctx->gop_size < 2), 0);
 580     }
 581
 582     f->avctx->extradata_size = ff_rac_terminate(c);
 583     v = av_crc(av_crc_get_table(AV_CRC_32_IEEE), 0, f->avctx->extradata, f->avctx->extradata_size);
 584     AV_WL32(f->avctx->extradata + f->avctx->extradata_size, v);
 585     f->avctx->extradata_size += 4;
 586
 587     return 0;
 588 }
 589
 590 static int sort_stt(FFV1Context *s, uint8_t stt[256])
 591 {
 592     int i, i2, changed, print = 0;
 593
 594     do {
 595         changed = 0;
 596         for (i = 12; i < 244; i++) {
 597             for (i2 = i + 1; i2 < 245 && i2 < i + 4; i2++) {
 598
 599 #define COST(old, new)                                      \
 600     s->rc_stat[old][0] * -log2((256 - (new)) / 256.0) +     \
 601     s->rc_stat[old][1] * -log2((new)         / 256.0)
 602
 603 #define COST2(old, new)                         \
 604     COST(old, new) + COST(256 - (old), 256 - (new))
 605
 606                 double size0 = COST2(i,  i) + COST2(i2, i2);
 607                 double sizeX = COST2(i, i2) + COST2(i2, i);
 608                 if (size0 - sizeX > size0*(1e-14) && i != 128 && i2 != 128) {
 609                     int j;
 610                     FFSWAP(int, stt[i], stt[i2]);
 611                     FFSWAP(int, s->rc_stat[i][0], s->rc_stat[i2][0]);
 612                     FFSWAP(int, s->rc_stat[i][1], s->rc_stat[i2][1]);
 613                     if (i != 256 - i2) {
 614                         FFSWAP(int, stt[256 - i], stt[256 - i2]);
 615                         FFSWAP(int, s->rc_stat[256 - i][0], s->rc_stat[256 - i2][0]);
 616                         FFSWAP(int, s->rc_stat[256 - i][1], s->rc_stat[256 - i2][1]);
 617                     }
 618                     for (j = 1; j < 256; j++) {
 619                         if (stt[j] == i)
 620                             stt[j] = i2;
 621                         else if (stt[j] == i2)
 622                             stt[j] = i;
 623                         if (i != 256 - i2) {
 624                             if (stt[256 - j] == 256 - i)
 625                                 stt[256 - j] = 256 - i2;
 626                             else if (stt[256 - j] == 256 - i2)
 627                                 stt[256 - j] = 256 - i;
 628                         }
 629                     }
 630                     print = changed = 1;
 631                 }
 632             }
 633         }
 634     } while (changed);
 635     return print;
 636 }
 637
 638 static av_cold int encode_init(AVCodecContext *avctx)
 639 {
 640     FFV1Context *s = avctx->priv_data;
 641     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(avctx->pix_fmt);
 642     int i, j, k, m, ret;
 643
 644     if ((ret = ffv1_common_init(avctx)) < 0)
 645         return ret;
 646
 647     s->version = 0;
 648
 649     if ((avctx->flags & (CODEC_FLAG_PASS1|CODEC_FLAG_PASS2)) || avctx->slices>1)
 650         s->version = FFMAX(s->version, 2);
 651
 652     if (avctx->level == 3 || (s->version==2 && avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL)) {
 653         s->version = 3;
 654     }
 655
 656     if (s->ec < 0) {
 657         s->ec = (s->version >= 3);
 658     }
 659
 660     if (s->version >= 2 && avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
 661         av_log(avctx, AV_LOG_ERROR, "Version 2 needed for requested features but version 2 is experimental and not enabled\n");
 662         return AVERROR_INVALIDDATA;
 663     }
 664
 665     s->ac = avctx->coder_type > 0 ? 2 : 0;
 666
 667     s->plane_count = 3;
 668     switch(avctx->pix_fmt) {
 669     case AV_PIX_FMT_YUV444P9:
 670     case AV_PIX_FMT_YUV422P9:
 671     case AV_PIX_FMT_YUV420P9:
 672         if (!avctx->bits_per_raw_sample)
 673             s->bits_per_raw_sample = 9;
 674     case AV_PIX_FMT_YUV444P10:
 675     case AV_PIX_FMT_YUV420P10:
 676     case AV_PIX_FMT_YUV422P10:
 677         s->packed_at_lsb = 1;
 678         if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
 679             s->bits_per_raw_sample = 10;
 680     case AV_PIX_FMT_GRAY16:
 681     case AV_PIX_FMT_YUV444P16:
 682     case AV_PIX_FMT_YUV422P16:
 683     case AV_PIX_FMT_YUV420P16:
 684         if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample) {
 685             s->bits_per_raw_sample = 16;
 686         } else if (!s->bits_per_raw_sample) {
 687             s->bits_per_raw_sample = avctx->bits_per_raw_sample;
 688         }
 689         if (s->bits_per_raw_sample <= 8) {
 690             av_log(avctx, AV_LOG_ERROR, "bits_per_raw_sample invalid\n");
 691             return AVERROR_INVALIDDATA;
 692         }
 693         if (!s->ac && avctx->coder_type == -1) {
 694             av_log(avctx, AV_LOG_INFO, "bits_per_raw_sample > 8, forcing coder 1\n");
 695             s->ac = 2;
 696         }
 697         if (!s->ac) {
 698             av_log(avctx, AV_LOG_ERROR, "bits_per_raw_sample of more than 8 needs -coder 1 currently\n");
 699             return AVERROR(ENOSYS);
 700         }
 701         s->version = FFMAX(s->version, 1);
 702     case AV_PIX_FMT_GRAY8:
 703     case AV_PIX_FMT_YUV444P:
 704     case AV_PIX_FMT_YUV440P:
 705     case AV_PIX_FMT_YUV422P:
 706     case AV_PIX_FMT_YUV420P:
 707     case AV_PIX_FMT_YUV411P:
 708     case AV_PIX_FMT_YUV410P:
 709         s->chroma_planes = desc->nb_components < 3 ? 0 : 1;
 710         s->colorspace = 0;
 711         break;
 712     case AV_PIX_FMT_YUVA444P:
 713     case AV_PIX_FMT_YUVA422P:
 714     case AV_PIX_FMT_YUVA420P:
 715         s->chroma_planes = 1;
 716         s->colorspace = 0;
 717         s->transparency = 1;
 718         break;
 719     case AV_PIX_FMT_RGB32:
 720         s->colorspace = 1;
 721         s->transparency = 1;
 722         s->chroma_planes = 1;
 723         break;
 724     case AV_PIX_FMT_0RGB32:
 725         s->colorspace = 1;
 726         s->chroma_planes = 1;
 727         break;
 728     case AV_PIX_FMT_GBRP9:
 729         if (!avctx->bits_per_raw_sample)
 730             s->bits_per_raw_sample = 9;
 731     case AV_PIX_FMT_GBRP10:
 732         if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
 733             s->bits_per_raw_sample = 10;
 734     case AV_PIX_FMT_GBRP12:
 735         if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
 736             s->bits_per_raw_sample = 12;
 737     case AV_PIX_FMT_GBRP14:
 738         if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
 739             s->bits_per_raw_sample = 14;
 740         else if (!s->bits_per_raw_sample)
 741             s->bits_per_raw_sample = avctx->bits_per_raw_sample;
 742         s->colorspace = 1;
 743         s->chroma_planes = 1;
 744         s->version = FFMAX(s->version, 1);
 745         break;
 746     default:
 747         av_log(avctx, AV_LOG_ERROR, "format not supported\n");
 748         return AVERROR(ENOSYS);
 749     }
 750     if (s->transparency) {
 751         av_log(avctx, AV_LOG_WARNING, "Storing alpha plane, this will require a recent FFV1 decoder to playback!\n");
 752     }
 753     if (avctx->context_model > 1U) {
 754         av_log(avctx, AV_LOG_ERROR, "Invalid context model %d, valid values are 0 and 1\n", avctx->context_model);
 755         return AVERROR(EINVAL);
 756     }
 757
 758     if (s->ac > 1)
 759         for (i = 1; i < 256; i++)
 760             s->state_transition[i] = ver2_state[i];
 761
 762     for (i = 0; i < 256; i++) {
 763         s->quant_table_count = 2;
 764         if (s->bits_per_raw_sample <= 8) {
 765             s->quant_tables[0][0][i]=           quant11[i];
 766             s->quant_tables[0][1][i]=        11*quant11[i];
 767             s->quant_tables[0][2][i]=     11*11*quant11[i];
 768             s->quant_tables[1][0][i]=           quant11[i];
 769             s->quant_tables[1][1][i]=        11*quant11[i];
 770             s->quant_tables[1][2][i]=     11*11*quant5 [i];
 771             s->quant_tables[1][3][i]=   5*11*11*quant5 [i];
 772             s->quant_tables[1][4][i]= 5*5*11*11*quant5 [i];
 773         } else {
 774             s->quant_tables[0][0][i]=           quant9_10bit[i];
 775             s->quant_tables[0][1][i]=        11*quant9_10bit[i];
 776             s->quant_tables[0][2][i]=     11*11*quant9_10bit[i];
 777             s->quant_tables[1][0][i]=           quant9_10bit[i];
 778             s->quant_tables[1][1][i]=        11*quant9_10bit[i];
 779             s->quant_tables[1][2][i]=     11*11*quant5_10bit[i];
 780             s->quant_tables[1][3][i]=   5*11*11*quant5_10bit[i];
 781             s->quant_tables[1][4][i]= 5*5*11*11*quant5_10bit[i];
 782         }
 783     }
 784     s->context_count[0] = (11 * 11 * 11        + 1) / 2;
 785     s->context_count[1] = (11 * 11 * 5 * 5 * 5 + 1) / 2;
 786     memcpy(s->quant_table, s->quant_tables[avctx->context_model],
 787            sizeof(s->quant_table));
 788
 789     for (i = 0; i < s->plane_count; i++) {
 790         PlaneContext *const p = &s->plane[i];
 791
 792         memcpy(p->quant_table, s->quant_table, sizeof(p->quant_table));
 793         p->quant_table_index = avctx->context_model;
 794         p->context_count     = s->context_count[p->quant_table_index];
 795     }
 796
 797     if ((ret = ffv1_allocate_initial_states(s)) < 0)
 798         return ret;
 799
 800     if (!s->transparency)
 801         s->plane_count = 2;
 802     if (!s->chroma_planes && s->version > 3)
 803         s->plane_count--;
 804
 805     avcodec_get_chroma_sub_sample(avctx->pix_fmt, &s->chroma_h_shift, &s->chroma_v_shift);
 806     s->picture_number = 0;
 807
 808     if (avctx->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2)) {
 809         for (i = 0; i < s->quant_table_count; i++) {
 810             s->rc_stat2[i] = av_mallocz(s->context_count[i] *
 811                                         sizeof(*s->rc_stat2[i]));
 812             if (!s->rc_stat2[i])
 813                 return AVERROR(ENOMEM);
 814         }
 815     }
 816     if (avctx->stats_in) {
 817         char *p = avctx->stats_in;
 818         uint8_t best_state[256][256];
 819         int gob_count = 0;
 820         char *next;
 821
 822         av_assert0(s->version >= 2);
 823
 824         for (;;) {
 825             for (j = 0; j < 256; j++)
 826                 for (i = 0; i < 2; i++) {
 827                     s->rc_stat[j][i] = strtol(p, &next, 0);
 828                     if (next == p) {
 829                         av_log(avctx, AV_LOG_ERROR,
 830                                "2Pass file invalid at %d %d [%s]\n", j, i, p);
 831                         return AVERROR_INVALIDDATA;
 832                     }
 833                     p = next;
 834                 }
 835             for (i = 0; i < s->quant_table_count; i++)
 836                 for (j = 0; j < s->context_count[i]; j++) {
 837                     for (k = 0; k < 32; k++)
 838                         for (m = 0; m < 2; m++) {
 839                             s->rc_stat2[i][j][k][m] = strtol(p, &next, 0);
 840                             if (next == p) {
 841                                 av_log(avctx, AV_LOG_ERROR,
 842                                        "2Pass file invalid at %d %d %d %d [%s]\n",
 843                                        i, j, k, m, p);
 844                                 return AVERROR_INVALIDDATA;
 845                             }
 846                             p = next;
 847                         }
 848                 }
 849             gob_count = strtol(p, &next, 0);
 850             if (next == p || gob_count <= 0) {
 851                 av_log(avctx, AV_LOG_ERROR, "2Pass file invalid\n");
 852                 return AVERROR_INVALIDDATA;
 853             }
 854             p = next;
 855             while (*p == '\n' || *p == ' ')
 856                 p++;
 857             if (p[0] == 0)
 858                 break;
 859         }
 860         sort_stt(s, s->state_transition);
 861
 862         find_best_state(best_state, s->state_transition);
 863
 864         for (i = 0; i < s->quant_table_count; i++) {
 865             for (k = 0; k < 32; k++) {
 866                 double a=0, b=0;
 867                 int jp = 0;
 868                 for (j = 0; j < s->context_count[i]; j++) {
 869                     double p = 128;
 870                     if (s->rc_stat2[i][j][k][0] + s->rc_stat2[i][j][k][1] > 200 && j || a+b > 200) {
 871                         if (a+b)
 872                             p = 256.0 * b / (a + b);
 873                         s->initial_states[i][jp][k] =
 874                             best_state[av_clip(round(p), 1, 255)][av_clip((a + b) / gob_count, 0, 255)];
 875                         for(jp++; jp<j; jp++)
 876                             s->initial_states[i][jp][k] = s->initial_states[i][jp-1][k];
 877                         a=b=0;
 878                     }
 879                     a += s->rc_stat2[i][j][k][0];
 880                     b += s->rc_stat2[i][j][k][1];
 881                     if (a+b) {
 882                         p = 256.0 * b / (a + b);
 883                     }
 884                     s->initial_states[i][j][k] =
 885                         best_state[av_clip(round(p), 1, 255)][av_clip((a + b) / gob_count, 0, 255)];
 886                 }
 887             }
 888         }
 889     }
 890
 891     if (s->version > 1) {
 892         s->num_v_slices = (avctx->width > 352 || avctx->height > 288 || !avctx->slices) ? 2 : 1;
 893         for (; s->num_v_slices < 9; s->num_v_slices++) {
 894             for (s->num_h_slices = s->num_v_slices; s->num_h_slices < 2*s->num_v_slices; s->num_h_slices++) {
 895                 if (avctx->slices == s->num_h_slices * s->num_v_slices && avctx->slices <= 64 || !avctx->slices)
 896                     goto slices_ok;
 897             }
 898         }
 899         av_log(avctx, AV_LOG_ERROR,
 900                "Unsupported number %d of slices requested, please specify a "
 901                "supported number with -slices (ex:4,6,9,12,16, ...)\n",
 902                avctx->slices);
 903         return AVERROR(ENOSYS);
 904 slices_ok:
 905         write_extradata(s);
 906     }
 907
 908     if ((ret = ffv1_init_slice_contexts(s)) < 0)
 909         return ret;
 910     if ((ret = ffv1_init_slices_state(s)) < 0)
 911         return ret;
 912
 913 #define STATS_OUT_SIZE 1024 * 1024 * 6
 914     if (avctx->flags & CODEC_FLAG_PASS1) {
 915         avctx->stats_out = av_mallocz(STATS_OUT_SIZE);
 916         if (!avctx->stats_out)
 917             return AVERROR(ENOMEM);
 918         for (i = 0; i < s->quant_table_count; i++)
 919             for (j = 0; j < s->slice_count; j++) {
 920                 FFV1Context *sf = s->slice_context[j];
 921                 av_assert0(!sf->rc_stat2[i]);
 922                 sf->rc_stat2[i] = av_mallocz(s->context_count[i] *
 923                                              sizeof(*sf->rc_stat2[i]));
 924                 if (!sf->rc_stat2[i])
 925                     return AVERROR(ENOMEM);
 926             }
 927     }
 928
 929     return 0;
 930 }
 931
 932 static void encode_slice_header(FFV1Context *f, FFV1Context *fs)
 933 {
 934     RangeCoder *c = &fs->c;
 935     uint8_t state[CONTEXT_SIZE];
 936     int j;
 937     memset(state, 128, sizeof(state));
 938
 939     put_symbol(c, state, (fs->slice_x     +1)*f->num_h_slices / f->width   , 0);
 940     put_symbol(c, state, (fs->slice_y     +1)*f->num_v_slices / f->height  , 0);
 941     put_symbol(c, state, (fs->slice_width +1)*f->num_h_slices / f->width -1, 0);
 942     put_symbol(c, state, (fs->slice_height+1)*f->num_v_slices / f->height-1, 0);
 943     for (j=0; j<f->plane_count; j++) {
 944         put_symbol(c, state, f->plane[j].quant_table_index, 0);
 945         av_assert0(f->plane[j].quant_table_index == f->avctx->context_model);
 946     }
 947     if (!f->picture.f->interlaced_frame)
 948         put_symbol(c, state, 3, 0);
 949     else
 950         put_symbol(c, state, 1 + !f->picture.f->top_field_first, 0);
 951     put_symbol(c, state, f->picture.f->sample_aspect_ratio.num, 0);
 952     put_symbol(c, state, f->picture.f->sample_aspect_ratio.den, 0);
 953 }
 954
 955 static int encode_slice(AVCodecContext *c, void *arg)
 956 {
 957     FFV1Context *fs  = *(void **)arg;
 958     FFV1Context *f   = fs->avctx->priv_data;
 959     int width        = fs->slice_width;
 960     int height       = fs->slice_height;
 961     int x            = fs->slice_x;
 962     int y            = fs->slice_y;
 963     AVFrame *const p = f->picture.f;
 964     const int ps     = av_pix_fmt_desc_get(c->pix_fmt)->comp[0].step_minus1 + 1;
 965
 966     if (p->key_frame)
 967         ffv1_clear_slice_state(f, fs);
 968     if (f->version > 2) {
 969         encode_slice_header(f, fs);
 970     }
 971     if (!fs->ac) {
 972         if (f->version > 2)
 973             put_rac(&fs->c, (uint8_t[]) { 129 }, 0);
 974         fs->ac_byte_count = f->version > 2 || (!x && !y) ? ff_rac_terminate(&fs->c) : 0;
 975         init_put_bits(&fs->pb,
 976                       fs->c.bytestream_start + fs->ac_byte_count,
 977                       fs->c.bytestream_end - fs->c.bytestream_start - fs->ac_byte_count);
 978     }
 979
 980     if (f->colorspace == 0) {
 981         const int chroma_width  = FF_CEIL_RSHIFT(width,  f->chroma_h_shift);
 982         const int chroma_height = FF_CEIL_RSHIFT(height, f->chroma_v_shift);
 983         const int cx            = x >> f->chroma_h_shift;
 984         const int cy            = y >> f->chroma_v_shift;
 985
 986         encode_plane(fs, p->data[0] + ps*x + y*p->linesize[0], width, height, p->linesize[0], 0);
 987
 988         if (f->chroma_planes) {
 989             encode_plane(fs, p->data[1] + ps*cx+cy*p->linesize[1], chroma_width, chroma_height, p->linesize[1], 1);
 990             encode_plane(fs, p->data[2] + ps*cx+cy*p->linesize[2], chroma_width, chroma_height, p->linesize[2], 1);
 991         }
 992         if (fs->transparency)
 993             encode_plane(fs, p->data[3] + ps*x + y*p->linesize[3], width, height, p->linesize[3], 2);
 994     } else {
 995         uint8_t *planes[3] = {p->data[0] + ps*x + y*p->linesize[0],
 996                               p->data[1] + ps*x + y*p->linesize[1],
 997                               p->data[2] + ps*x + y*p->linesize[2]};
 998         encode_rgb_frame(fs, planes, width, height, p->linesize);
 999     }
1000     emms_c();
1001
1002     return 0;
1003 }
1004
1005 static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
1006                         const AVFrame *pict, int *got_packet)
1007 {
1008     FFV1Context *f      = avctx->priv_data;
1009     RangeCoder *const c = &f->slice_context[0]->c;
1010     AVFrame *const p    = f->picture.f;
1011     int used_count      = 0;
1012     uint8_t keystate    = 128;
1013     uint8_t *buf_p;
1014     int i, ret;
1015
1016     if ((ret = ff_alloc_packet2(avctx, pkt, avctx->width*avctx->height*((8*2+1+1)*4)/8
1017                                             + FF_MIN_BUFFER_SIZE)) < 0)
1018         return ret;
1019
1020     ff_init_range_encoder(c, pkt->data, pkt->size);
1021     ff_build_rac_states(c, 0.05 * (1LL << 32), 256 - 8);
1022
1023     av_frame_unref(p);
1024     if ((ret = av_frame_ref(p, pict)) < 0)
1025         return ret;
1026     p->pict_type = AV_PICTURE_TYPE_I;
1027
1028     if (avctx->gop_size == 0 || f->picture_number % avctx->gop_size == 0) {
1029         put_rac(c, &keystate, 1);
1030         p->key_frame = 1;
1031         f->gob_count++;
1032         write_header(f);
1033     } else {
1034         put_rac(c, &keystate, 0);
1035         p->key_frame = 0;
1036     }
1037
1038     if (f->ac > 1) {
1039         int i;
1040         for (i = 1; i < 256; i++) {
1041             c->one_state[i]        = f->state_transition[i];
1042             c->zero_state[256 - i] = 256 - c->one_state[i];
1043         }
1044     }
1045
1046     for (i = 1; i < f->slice_count; i++) {
1047         FFV1Context *fs = f->slice_context[i];
1048         uint8_t *start  = pkt->data + (pkt->size - used_count) * (int64_t)i / f->slice_count;
1049         int len         = pkt->size / f->slice_count;
1050         ff_init_range_encoder(&fs->c, start, len);
1051     }
1052     avctx->execute(avctx, encode_slice, &f->slice_context[0], NULL,
1053                    f->slice_count, sizeof(void *));
1054
1055     buf_p = pkt->data;
1056     for (i = 0; i < f->slice_count; i++) {
1057         FFV1Context *fs = f->slice_context[i];
1058         int bytes;
1059
1060         if (fs->ac) {
1061             uint8_t state = 129;
1062             put_rac(&fs->c, &state, 0);
1063             bytes = ff_rac_terminate(&fs->c);
1064         } else {
1065             flush_put_bits(&fs->pb); // FIXME: nicer padding
1066             bytes = fs->ac_byte_count + (put_bits_count(&fs->pb) + 7) / 8;
1067         }
1068         if (i > 0 || f->version > 2) {
1069             av_assert0(bytes < pkt->size / f->slice_count);
1070             memmove(buf_p, fs->c.bytestream_start, bytes);
1071             av_assert0(bytes < (1 << 24));
1072             AV_WB24(buf_p + bytes, bytes);
1073             bytes += 3;
1074         }
1075         if (f->ec) {
1076             unsigned v;
1077             buf_p[bytes++] = 0;
1078             v = av_crc(av_crc_get_table(AV_CRC_32_IEEE), 0, buf_p, bytes);
1079             AV_WL32(buf_p + bytes, v);
1080             bytes += 4;
1081         }
1082         buf_p += bytes;
1083     }
1084
1085     if ((avctx->flags & CODEC_FLAG_PASS1) && (f->picture_number & 31) == 0) {
1086         int j, k, m;
1087         char *p   = avctx->stats_out;
1088         char *end = p + STATS_OUT_SIZE;
1089
1090         memset(f->rc_stat, 0, sizeof(f->rc_stat));
1091         for (i = 0; i < f->quant_table_count; i++)
1092             memset(f->rc_stat2[i], 0, f->context_count[i] * sizeof(*f->rc_stat2[i]));
1093
1094         for (j = 0; j < f->slice_count; j++) {
1095             FFV1Context *fs = f->slice_context[j];
1096             for (i = 0; i < 256; i++) {
1097                 f->rc_stat[i][0] += fs->rc_stat[i][0];
1098                 f->rc_stat[i][1] += fs->rc_stat[i][1];
1099             }
1100             for (i = 0; i < f->quant_table_count; i++) {
1101                 for (k = 0; k < f->context_count[i]; k++)
1102                     for (m = 0; m < 32; m++) {
1103                         f->rc_stat2[i][k][m][0] += fs->rc_stat2[i][k][m][0];
1104                         f->rc_stat2[i][k][m][1] += fs->rc_stat2[i][k][m][1];
1105                     }
1106             }
1107         }
1108
1109         for (j = 0; j < 256; j++) {
1110             snprintf(p, end - p, "%" PRIu64 " %" PRIu64 " ",
1111                      f->rc_stat[j][0], f->rc_stat[j][1]);
1112             p += strlen(p);
1113         }
1114         snprintf(p, end - p, "\n");
1115
1116         for (i = 0; i < f->quant_table_count; i++) {
1117             for (j = 0; j < f->context_count[i]; j++)
1118                 for (m = 0; m < 32; m++) {
1119                     snprintf(p, end - p, "%" PRIu64 " %" PRIu64 " ",
1120                              f->rc_stat2[i][j][m][0], f->rc_stat2[i][j][m][1]);
1121                     p += strlen(p);
1122                 }
1123         }
1124         snprintf(p, end - p, "%d\n", f->gob_count);
1125     } else if (avctx->flags & CODEC_FLAG_PASS1)
1126         avctx->stats_out[0] = '\0';
1127
1128     f->picture_number++;
1129     pkt->size   = buf_p - pkt->data;
1130     pkt->flags |= AV_PKT_FLAG_KEY * p->key_frame;
1131     *got_packet = 1;
1132
1133     return 0;
1134 }
1135
1136 #define OFFSET(x) offsetof(FFV1Context, x)
1137 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
1138 static const AVOption options[] = {
1139     { "slicecrc", "Protect slices with CRCs", OFFSET(ec), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 1, VE },
1140     { NULL }
1141 };
1142
1143 static const AVClass ffv1_class = {
1144     .class_name = "ffv1 encoder",
1145     .item_name  = av_default_item_name,
1146     .option     = options,
1147     .version    = LIBAVUTIL_VERSION_INT,
1148 };
1149
1150 static const AVCodecDefault ffv1_defaults[] = {
1151     { "coder", "-1" },
1152     { NULL },
1153 };
1154
1155 AVCodec ff_ffv1_encoder = {
1156     .name           = "ffv1",
1157     .type           = AVMEDIA_TYPE_VIDEO,
1158     .id             = AV_CODEC_ID_FFV1,
1159     .priv_data_size = sizeof(FFV1Context),
1160     .init           = encode_init,
1161     .encode2        = encode_frame,
1162     .close          = ffv1_close,
1163     .capabilities   = CODEC_CAP_SLICE_THREADS,
1164     .pix_fmts       = (const enum AVPixelFormat[]) {
1165         AV_PIX_FMT_YUV420P,   AV_PIX_FMT_YUVA420P,  AV_PIX_FMT_YUVA422P,  AV_PIX_FMT_YUV444P,
1166         AV_PIX_FMT_YUVA444P,  AV_PIX_FMT_YUV440P,   AV_PIX_FMT_YUV422P,   AV_PIX_FMT_YUV411P,
1167         AV_PIX_FMT_YUV410P,   AV_PIX_FMT_0RGB32,    AV_PIX_FMT_RGB32,     AV_PIX_FMT_YUV420P16,
1168         AV_PIX_FMT_YUV422P16, AV_PIX_FMT_YUV444P16, AV_PIX_FMT_YUV444P9,  AV_PIX_FMT_YUV422P9,
1169         AV_PIX_FMT_YUV420P9,  AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10,
1170         AV_PIX_FMT_GRAY16,    AV_PIX_FMT_GRAY8,     AV_PIX_FMT_GBRP9,     AV_PIX_FMT_GBRP10,
1171         AV_PIX_FMT_GBRP12,    AV_PIX_FMT_GBRP14,
1172         AV_PIX_FMT_NONE
1173
1174     },
1175     .long_name      = NULL_IF_CONFIG_SMALL("FFmpeg video codec #1"),
1176     .defaults       = ffv1_defaults,
1177     .priv_class     = &ffv1_class,
1178 };