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