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