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