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