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