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 FF_API_CODER_TYPE
 558 FF_DISABLE_DEPRECATION_WARNINGS
 559     if (avctx->coder_type != -1)
 560         s->ac = avctx->coder_type > 0 ? AC_RANGE_CUSTOM_TAB : AC_GOLOMB_RICE;
 561     else
 562 FF_ENABLE_DEPRECATION_WARNINGS
 563 #endif
 564     if (s->ac == 1) // Compatbility with common command line usage
 565         s->ac = AC_RANGE_CUSTOM_TAB;
 566     else if (s->ac == AC_RANGE_DEFAULT_TAB_FORCE)
 567         s->ac = AC_RANGE_DEFAULT_TAB;
 568
 569     s->plane_count = 3;
 570     switch(avctx->pix_fmt) {
 571     case AV_PIX_FMT_GRAY9:
 572     case AV_PIX_FMT_YUV444P9:
 573     case AV_PIX_FMT_YUV422P9:
 574     case AV_PIX_FMT_YUV420P9:
 575     case AV_PIX_FMT_YUVA444P9:
 576     case AV_PIX_FMT_YUVA422P9:
 577     case AV_PIX_FMT_YUVA420P9:
 578         if (!avctx->bits_per_raw_sample)
 579             s->bits_per_raw_sample = 9;
 580     case AV_PIX_FMT_GRAY10:
 581     case AV_PIX_FMT_YUV444P10:
 582     case AV_PIX_FMT_YUV440P10:
 583     case AV_PIX_FMT_YUV420P10:
 584     case AV_PIX_FMT_YUV422P10:
 585     case AV_PIX_FMT_YUVA444P10:
 586     case AV_PIX_FMT_YUVA422P10:
 587     case AV_PIX_FMT_YUVA420P10:
 588         if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
 589             s->bits_per_raw_sample = 10;
 590     case AV_PIX_FMT_GRAY12:
 591     case AV_PIX_FMT_YUV444P12:
 592     case AV_PIX_FMT_YUV440P12:
 593     case AV_PIX_FMT_YUV420P12:
 594     case AV_PIX_FMT_YUV422P12:
 595         if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
 596             s->bits_per_raw_sample = 12;
 597     case AV_PIX_FMT_YUV444P14:
 598     case AV_PIX_FMT_YUV420P14:
 599     case AV_PIX_FMT_YUV422P14:
 600         if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
 601             s->bits_per_raw_sample = 14;
 602         s->packed_at_lsb = 1;
 603     case AV_PIX_FMT_GRAY16:
 604     case AV_PIX_FMT_YUV444P16:
 605     case AV_PIX_FMT_YUV422P16:
 606     case AV_PIX_FMT_YUV420P16:
 607     case AV_PIX_FMT_YUVA444P16:
 608     case AV_PIX_FMT_YUVA422P16:
 609     case AV_PIX_FMT_YUVA420P16:
 610         if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample) {
 611             s->bits_per_raw_sample = 16;
 612         } else if (!s->bits_per_raw_sample) {
 613             s->bits_per_raw_sample = avctx->bits_per_raw_sample;
 614         }
 615         if (s->bits_per_raw_sample <= 8) {
 616             av_log(avctx, AV_LOG_ERROR, "bits_per_raw_sample invalid\n");
 617             return AVERROR_INVALIDDATA;
 618         }
 619         s->version = FFMAX(s->version, 1);
 620     case AV_PIX_FMT_GRAY8:
 621     case AV_PIX_FMT_YA8:
 622     case AV_PIX_FMT_YUV444P:
 623     case AV_PIX_FMT_YUV440P:
 624     case AV_PIX_FMT_YUV422P:
 625     case AV_PIX_FMT_YUV420P:
 626     case AV_PIX_FMT_YUV411P:
 627     case AV_PIX_FMT_YUV410P:
 628     case AV_PIX_FMT_YUVA444P:
 629     case AV_PIX_FMT_YUVA422P:
 630     case AV_PIX_FMT_YUVA420P:
 631         s->chroma_planes = desc->nb_components < 3 ? 0 : 1;
 632         s->colorspace = 0;
 633         s->transparency = !!(desc->flags & AV_PIX_FMT_FLAG_ALPHA);
 634         if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
 635             s->bits_per_raw_sample = 8;
 636         else if (!s->bits_per_raw_sample)
 637             s->bits_per_raw_sample = 8;
 638         break;
 639     case AV_PIX_FMT_RGB32:
 640         s->colorspace = 1;
 641         s->transparency = 1;
 642         s->chroma_planes = 1;
 643         s->bits_per_raw_sample = 8;
 644         break;
 645     case AV_PIX_FMT_RGBA64:
 646         s->colorspace = 1;
 647         s->transparency = 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_RGB48:
 654         s->colorspace = 1;
 655         s->chroma_planes = 1;
 656         s->bits_per_raw_sample = 16;
 657         s->use32bit = 1;
 658         s->version = FFMAX(s->version, 1);
 659         break;
 660     case AV_PIX_FMT_0RGB32:
 661         s->colorspace = 1;
 662         s->chroma_planes = 1;
 663         s->bits_per_raw_sample = 8;
 664         break;
 665     case AV_PIX_FMT_GBRP9:
 666         if (!avctx->bits_per_raw_sample)
 667             s->bits_per_raw_sample = 9;
 668     case AV_PIX_FMT_GBRP10:
 669     case AV_PIX_FMT_GBRAP10:
 670         if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
 671             s->bits_per_raw_sample = 10;
 672     case AV_PIX_FMT_GBRP12:
 673     case AV_PIX_FMT_GBRAP12:
 674         if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
 675             s->bits_per_raw_sample = 12;
 676     case AV_PIX_FMT_GBRP14:
 677         if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
 678             s->bits_per_raw_sample = 14;
 679     case AV_PIX_FMT_GBRP16:
 680     case AV_PIX_FMT_GBRAP16:
 681         if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
 682             s->bits_per_raw_sample = 16;
 683         else if (!s->bits_per_raw_sample)
 684             s->bits_per_raw_sample = avctx->bits_per_raw_sample;
 685         s->transparency = !!(desc->flags & AV_PIX_FMT_FLAG_ALPHA);
 686         s->colorspace = 1;
 687         s->chroma_planes = 1;
 688         if (s->bits_per_raw_sample >= 16) {
 689             s->use32bit = 1;
 690         }
 691         s->version = FFMAX(s->version, 1);
 692         break;
 693     default:
 694         av_log(avctx, AV_LOG_ERROR, "format not supported\n");
 695         return AVERROR(ENOSYS);
 696     }
 697     av_assert0(s->bits_per_raw_sample >= 8);
 698
 699     if (s->bits_per_raw_sample > 8) {
 700         if (s->ac == AC_GOLOMB_RICE) {
 701             av_log(avctx, AV_LOG_INFO,
 702                     "bits_per_raw_sample > 8, forcing range coder\n");
 703             s->ac = AC_RANGE_CUSTOM_TAB;
 704         }
 705     }
 706 #if FF_API_PRIVATE_OPT
 707 FF_DISABLE_DEPRECATION_WARNINGS
 708     if (avctx->context_model)
 709         s->context_model = avctx->context_model;
 710     if (avctx->context_model > 1U) {
 711         av_log(avctx, AV_LOG_ERROR, "Invalid context model %d, valid values are 0 and 1\n", avctx->context_model);
 712         return AVERROR(EINVAL);
 713     }
 714 FF_ENABLE_DEPRECATION_WARNINGS
 715 #endif
 716
 717     if (s->ac == AC_RANGE_CUSTOM_TAB) {
 718         for (i = 1; i < 256; i++)
 719             s->state_transition[i] = ver2_state[i];
 720     } else {
 721         RangeCoder c;
 722         ff_build_rac_states(&c, 0.05 * (1LL << 32), 256 - 8);
 723         for (i = 1; i < 256; i++)
 724             s->state_transition[i] = c.one_state[i];
 725     }
 726
 727     for (i = 0; i < 256; i++) {
 728         s->quant_table_count = 2;
 729         if (s->bits_per_raw_sample <= 8) {
 730             s->quant_tables[0][0][i]=           quant11[i];
 731             s->quant_tables[0][1][i]=        11*quant11[i];
 732             s->quant_tables[0][2][i]=     11*11*quant11[i];
 733             s->quant_tables[1][0][i]=           quant11[i];
 734             s->quant_tables[1][1][i]=        11*quant11[i];
 735             s->quant_tables[1][2][i]=     11*11*quant5 [i];
 736             s->quant_tables[1][3][i]=   5*11*11*quant5 [i];
 737             s->quant_tables[1][4][i]= 5*5*11*11*quant5 [i];
 738         } else {
 739             s->quant_tables[0][0][i]=           quant9_10bit[i];
 740             s->quant_tables[0][1][i]=        11*quant9_10bit[i];
 741             s->quant_tables[0][2][i]=     11*11*quant9_10bit[i];
 742             s->quant_tables[1][0][i]=           quant9_10bit[i];
 743             s->quant_tables[1][1][i]=        11*quant9_10bit[i];
 744             s->quant_tables[1][2][i]=     11*11*quant5_10bit[i];
 745             s->quant_tables[1][3][i]=   5*11*11*quant5_10bit[i];
 746             s->quant_tables[1][4][i]= 5*5*11*11*quant5_10bit[i];
 747         }
 748     }
 749     s->context_count[0] = (11 * 11 * 11        + 1) / 2;
 750     s->context_count[1] = (11 * 11 * 5 * 5 * 5 + 1) / 2;
 751     memcpy(s->quant_table, s->quant_tables[s->context_model],
 752            sizeof(s->quant_table));
 753
 754     for (i = 0; i < s->plane_count; i++) {
 755         PlaneContext *const p = &s->plane[i];
 756
 757         memcpy(p->quant_table, s->quant_table, sizeof(p->quant_table));
 758         p->quant_table_index = s->context_model;
 759         p->context_count     = s->context_count[p->quant_table_index];
 760     }
 761
 762     if ((ret = ff_ffv1_allocate_initial_states(s)) < 0)
 763         return ret;
 764
 765 #if FF_API_CODED_FRAME
 766 FF_DISABLE_DEPRECATION_WARNINGS
 767     avctx->coded_frame->pict_type = AV_PICTURE_TYPE_I;
 768 FF_ENABLE_DEPRECATION_WARNINGS
 769 #endif
 770
 771     if (!s->transparency)
 772         s->plane_count = 2;
 773     if (!s->chroma_planes && s->version > 3)
 774         s->plane_count--;
 775
 776     ret = av_pix_fmt_get_chroma_sub_sample (avctx->pix_fmt, &s->chroma_h_shift, &s->chroma_v_shift);
 777     if (ret)
 778         return ret;
 779
 780     s->picture_number = 0;
 781
 782     if (avctx->flags & (AV_CODEC_FLAG_PASS1 | AV_CODEC_FLAG_PASS2)) {
 783         for (i = 0; i < s->quant_table_count; i++) {
 784             s->rc_stat2[i] = av_mallocz(s->context_count[i] *
 785                                         sizeof(*s->rc_stat2[i]));
 786             if (!s->rc_stat2[i])
 787                 return AVERROR(ENOMEM);
 788         }
 789     }
 790     if (avctx->stats_in) {
 791         char *p = avctx->stats_in;
 792         uint8_t (*best_state)[256] = av_malloc_array(256, 256);
 793         int gob_count = 0;
 794         char *next;
 795         if (!best_state)
 796             return AVERROR(ENOMEM);
 797
 798         av_assert0(s->version >= 2);
 799
 800         for (;;) {
 801             for (j = 0; j < 256; j++)
 802                 for (i = 0; i < 2; i++) {
 803                     s->rc_stat[j][i] = strtol(p, &next, 0);
 804                     if (next == p) {
 805                         av_log(avctx, AV_LOG_ERROR,
 806                                "2Pass file invalid at %d %d [%s]\n", j, i, p);
 807                         av_freep(&best_state);
 808                         return AVERROR_INVALIDDATA;
 809                     }
 810                     p = next;
 811                 }
 812             for (i = 0; i < s->quant_table_count; i++)
 813                 for (j = 0; j < s->context_count[i]; j++) {
 814                     for (k = 0; k < 32; k++)
 815                         for (m = 0; m < 2; m++) {
 816                             s->rc_stat2[i][j][k][m] = strtol(p, &next, 0);
 817                             if (next == p) {
 818                                 av_log(avctx, AV_LOG_ERROR,
 819                                        "2Pass file invalid at %d %d %d %d [%s]\n",
 820                                        i, j, k, m, p);
 821                                 av_freep(&best_state);
 822                                 return AVERROR_INVALIDDATA;
 823                             }
 824                             p = next;
 825                         }
 826                 }
 827             gob_count = strtol(p, &next, 0);
 828             if (next == p || gob_count <= 0) {
 829                 av_log(avctx, AV_LOG_ERROR, "2Pass file invalid\n");
 830                 av_freep(&best_state);
 831                 return AVERROR_INVALIDDATA;
 832             }
 833             p = next;
 834             while (*p == '\n' || *p == ' ')
 835                 p++;
 836             if (p[0] == 0)
 837                 break;
 838         }
 839         if (s->ac == AC_RANGE_CUSTOM_TAB)
 840             sort_stt(s, s->state_transition);
 841
 842         find_best_state(best_state, s->state_transition);
 843
 844         for (i = 0; i < s->quant_table_count; i++) {
 845             for (k = 0; k < 32; k++) {
 846                 double a=0, b=0;
 847                 int jp = 0;
 848                 for (j = 0; j < s->context_count[i]; j++) {
 849                     double p = 128;
 850                     if (s->rc_stat2[i][j][k][0] + s->rc_stat2[i][j][k][1] > 200 && j || a+b > 200) {
 851                         if (a+b)
 852                             p = 256.0 * b / (a + b);
 853                         s->initial_states[i][jp][k] =
 854                             best_state[av_clip(round(p), 1, 255)][av_clip_uint8((a + b) / gob_count)];
 855                         for(jp++; jp<j; jp++)
 856                             s->initial_states[i][jp][k] = s->initial_states[i][jp-1][k];
 857                         a=b=0;
 858                     }
 859                     a += s->rc_stat2[i][j][k][0];
 860                     b += s->rc_stat2[i][j][k][1];
 861                     if (a+b) {
 862                         p = 256.0 * b / (a + b);
 863                     }
 864                     s->initial_states[i][j][k] =
 865                         best_state[av_clip(round(p), 1, 255)][av_clip_uint8((a + b) / gob_count)];
 866                 }
 867             }
 868         }
 869         av_freep(&best_state);
 870     }
 871
 872     if (s->version > 1) {
 873         int plane_count = 1 + 2*s->chroma_planes + s->transparency;
 874         int max_h_slices = AV_CEIL_RSHIFT(avctx->width , s->chroma_h_shift);
 875         int max_v_slices = AV_CEIL_RSHIFT(avctx->height, s->chroma_v_shift);
 876         s->num_v_slices = (avctx->width > 352 || avctx->height > 288 || !avctx->slices) ? 2 : 1;
 877
 878         s->num_v_slices = FFMIN(s->num_v_slices, max_v_slices);
 879
 880         for (; s->num_v_slices < 32; s->num_v_slices++) {
 881             for (s->num_h_slices = s->num_v_slices; s->num_h_slices < 2*s->num_v_slices; s->num_h_slices++) {
 882                 int maxw = (avctx->width  + s->num_h_slices - 1) / s->num_h_slices;
 883                 int maxh = (avctx->height + s->num_v_slices - 1) / s->num_v_slices;
 884                 if (s->num_h_slices > max_h_slices || s->num_v_slices > max_v_slices)
 885                     continue;
 886                 if (maxw * maxh * (int64_t)(s->bits_per_raw_sample+1) * plane_count > 8<<24)
 887                     continue;
 888                 if (avctx->slices == s->num_h_slices * s->num_v_slices && avctx->slices <= MAX_SLICES || !avctx->slices)
 889                     goto slices_ok;
 890             }
 891         }
 892         av_log(avctx, AV_LOG_ERROR,
 893                "Unsupported number %d of slices requested, please specify a "
 894                "supported number with -slices (ex:4,6,9,12,16, ...)\n",
 895                avctx->slices);
 896         return AVERROR(ENOSYS);
 897 slices_ok:
 898         if ((ret = write_extradata(s)) < 0)
 899             return ret;
 900     }
 901
 902     if ((ret = ff_ffv1_init_slice_contexts(s)) < 0)
 903         return ret;
 904     s->slice_count = s->max_slice_count;
 905     if ((ret = ff_ffv1_init_slices_state(s)) < 0)
 906         return ret;
 907
 908 #define STATS_OUT_SIZE 1024 * 1024 * 6
 909     if (avctx->flags & AV_CODEC_FLAG_PASS1) {
 910         avctx->stats_out = av_mallocz(STATS_OUT_SIZE);
 911         if (!avctx->stats_out)
 912             return AVERROR(ENOMEM);
 913         for (i = 0; i < s->quant_table_count; i++)
 914             for (j = 0; j < s->max_slice_count; j++) {
 915                 FFV1Context *sf = s->slice_context[j];
 916                 av_assert0(!sf->rc_stat2[i]);
 917                 sf->rc_stat2[i] = av_mallocz(s->context_count[i] *
 918                                              sizeof(*sf->rc_stat2[i]));
 919                 if (!sf->rc_stat2[i])
 920                     return AVERROR(ENOMEM);
 921             }
 922     }
 923
 924     return 0;
 925 }
 926
 927 static void encode_slice_header(FFV1Context *f, FFV1Context *fs)
 928 {
 929     RangeCoder *c = &fs->c;
 930     uint8_t state[CONTEXT_SIZE];
 931     int j;
 932     memset(state, 128, sizeof(state));
 933
 934     put_symbol(c, state, (fs->slice_x     +1)*f->num_h_slices / f->width   , 0);
 935     put_symbol(c, state, (fs->slice_y     +1)*f->num_v_slices / f->height  , 0);
 936     put_symbol(c, state, (fs->slice_width +1)*f->num_h_slices / f->width -1, 0);
 937     put_symbol(c, state, (fs->slice_height+1)*f->num_v_slices / f->height-1, 0);
 938     for (j=0; j<f->plane_count; j++) {
 939         put_symbol(c, state, f->plane[j].quant_table_index, 0);
 940         av_assert0(f->plane[j].quant_table_index == f->context_model);
 941     }
 942     if (!f->picture.f->interlaced_frame)
 943         put_symbol(c, state, 3, 0);
 944     else
 945         put_symbol(c, state, 1 + !f->picture.f->top_field_first, 0);
 946     put_symbol(c, state, f->picture.f->sample_aspect_ratio.num, 0);
 947     put_symbol(c, state, f->picture.f->sample_aspect_ratio.den, 0);
 948     if (f->version > 3) {
 949         put_rac(c, state, fs->slice_coding_mode == 1);
 950         if (fs->slice_coding_mode == 1)
 951             ff_ffv1_clear_slice_state(f, fs);
 952         put_symbol(c, state, fs->slice_coding_mode, 0);
 953         if (fs->slice_coding_mode != 1) {
 954             put_symbol(c, state, fs->slice_rct_by_coef, 0);
 955             put_symbol(c, state, fs->slice_rct_ry_coef, 0);
 956         }
 957     }
 958 }
 959
 960 static void choose_rct_params(FFV1Context *fs, const uint8_t *src[3], const int stride[3], int w, int h)
 961 {
 962 #define NB_Y_COEFF 15
 963     static const int rct_y_coeff[15][2] = {
 964         {0, 0}, //      4G
 965         {1, 1}, //  R + 2G + B
 966         {2, 2}, // 2R      + 2B
 967         {0, 2}, //      2G + 2B
 968         {2, 0}, // 2R + 2G
 969         {4, 0}, // 4R
 970         {0, 4}, //           4B
 971
 972         {0, 3}, //      1G + 3B
 973         {3, 0}, // 3R + 1G
 974         {3, 1}, // 3R      +  B
 975         {1, 3}, //  R      + 3B
 976         {1, 2}, //  R +  G + 2B
 977         {2, 1}, // 2R +  G +  B
 978         {0, 1}, //      3G +  B
 979         {1, 0}, //  R + 3G
 980     };
 981
 982     int stat[NB_Y_COEFF] = {0};
 983     int x, y, i, p, best;
 984     int16_t *sample[3];
 985     int lbd = fs->bits_per_raw_sample <= 8;
 986
 987     for (y = 0; y < h; y++) {
 988         int lastr=0, lastg=0, lastb=0;
 989         for (p = 0; p < 3; p++)
 990             sample[p] = fs->sample_buffer + p*w;
 991
 992         for (x = 0; x < w; x++) {
 993             int b, g, r;
 994             int ab, ag, ar;
 995             if (lbd) {
 996                 unsigned v = *((const uint32_t*)(src[0] + x*4 + stride[0]*y));
 997                 b =  v        & 0xFF;
 998                 g = (v >>  8) & 0xFF;
 999                 r = (v >> 16) & 0xFF;
1000             } else {
1001                 b = *((const uint16_t*)(src[0] + x*2 + stride[0]*y));
1002                 g = *((const uint16_t*)(src[1] + x*2 + stride[1]*y));
1003                 r = *((const uint16_t*)(src[2] + x*2 + stride[2]*y));
1004             }
1005
1006             ar = r - lastr;
1007             ag = g - lastg;
1008             ab = b - lastb;
1009             if (x && y) {
1010                 int bg = ag - sample[0][x];
1011                 int bb = ab - sample[1][x];
1012                 int br = ar - sample[2][x];
1013
1014                 br -= bg;
1015                 bb -= bg;
1016
1017                 for (i = 0; i<NB_Y_COEFF; i++) {
1018                     stat[i] += FFABS(bg + ((br*rct_y_coeff[i][0] + bb*rct_y_coeff[i][1])>>2));
1019                 }
1020
1021             }
1022             sample[0][x] = ag;
1023             sample[1][x] = ab;
1024             sample[2][x] = ar;
1025
1026             lastr = r;
1027             lastg = g;
1028             lastb = b;
1029         }
1030     }
1031
1032     best = 0;
1033     for (i=1; i<NB_Y_COEFF; i++) {
1034         if (stat[i] < stat[best])
1035             best = i;
1036     }
1037
1038     fs->slice_rct_by_coef = rct_y_coeff[best][1];
1039     fs->slice_rct_ry_coef = rct_y_coeff[best][0];
1040 }
1041
1042 static int encode_slice(AVCodecContext *c, void *arg)
1043 {
1044     FFV1Context *fs  = *(void **)arg;
1045     FFV1Context *f   = fs->avctx->priv_data;
1046     int width        = fs->slice_width;
1047     int height       = fs->slice_height;
1048     int x            = fs->slice_x;
1049     int y            = fs->slice_y;
1050     const AVFrame *const p = f->picture.f;
1051     const int ps     = av_pix_fmt_desc_get(c->pix_fmt)->comp[0].step;
1052     int ret;
1053     RangeCoder c_bak = fs->c;
1054     const uint8_t *planes[4] = {p->data[0] + ps*x + y*p->linesize[0],
1055                                 p->data[1] ? p->data[1] + ps*x + y*p->linesize[1] : NULL,
1056                                 p->data[2] ? p->data[2] + ps*x + y*p->linesize[2] : NULL,
1057                                 p->data[3] ? p->data[3] + ps*x + y*p->linesize[3] : NULL};
1058
1059     fs->slice_coding_mode = 0;
1060     if (f->version > 3) {
1061         choose_rct_params(fs, planes, p->linesize, width, height);
1062     } else {
1063         fs->slice_rct_by_coef = 1;
1064         fs->slice_rct_ry_coef = 1;
1065     }
1066
1067 retry:
1068     if (f->key_frame)
1069         ff_ffv1_clear_slice_state(f, fs);
1070     if (f->version > 2) {
1071         encode_slice_header(f, fs);
1072     }
1073     if (fs->ac == AC_GOLOMB_RICE) {
1074         fs->ac_byte_count = f->version > 2 || (!x && !y) ? ff_rac_terminate(&fs->c, f->version > 2) : 0;
1075         init_put_bits(&fs->pb,
1076                       fs->c.bytestream_start + fs->ac_byte_count,
1077                       fs->c.bytestream_end - fs->c.bytestream_start - fs->ac_byte_count);
1078     }
1079
1080     if (f->colorspace == 0 && c->pix_fmt != AV_PIX_FMT_YA8) {
1081         const int chroma_width  = AV_CEIL_RSHIFT(width,  f->chroma_h_shift);
1082         const int chroma_height = AV_CEIL_RSHIFT(height, f->chroma_v_shift);
1083         const int cx            = x >> f->chroma_h_shift;
1084         const int cy            = y >> f->chroma_v_shift;
1085
1086         ret = encode_plane(fs, p->data[0] + ps*x + y*p->linesize[0], width, height, p->linesize[0], 0, 1);
1087
1088         if (f->chroma_planes) {
1089             ret |= encode_plane(fs, p->data[1] + ps*cx+cy*p->linesize[1], chroma_width, chroma_height, p->linesize[1], 1, 1);
1090             ret |= encode_plane(fs, p->data[2] + ps*cx+cy*p->linesize[2], chroma_width, chroma_height, p->linesize[2], 1, 1);
1091         }
1092         if (fs->transparency)
1093             ret |= encode_plane(fs, p->data[3] + ps*x + y*p->linesize[3], width, height, p->linesize[3], 2, 1);
1094     } else if (c->pix_fmt == AV_PIX_FMT_YA8) {
1095         ret  = encode_plane(fs, p->data[0] +     ps*x + y*p->linesize[0], width, height, p->linesize[0], 0, 2);
1096         ret |= encode_plane(fs, p->data[0] + 1 + ps*x + y*p->linesize[0], width, height, p->linesize[0], 1, 2);
1097     } else if (f->use32bit) {
1098         ret = encode_rgb_frame32(fs, planes, width, height, p->linesize);
1099     } else {
1100         ret = encode_rgb_frame(fs, planes, width, height, p->linesize);
1101     }
1102     emms_c();
1103
1104     if (ret < 0) {
1105         av_assert0(fs->slice_coding_mode == 0);
1106         if (fs->version < 4 || !fs->ac) {
1107             av_log(c, AV_LOG_ERROR, "Buffer too small\n");
1108             return ret;
1109         }
1110         av_log(c, AV_LOG_DEBUG, "Coding slice as PCM\n");
1111         fs->slice_coding_mode = 1;
1112         fs->c = c_bak;
1113         goto retry;
1114     }
1115
1116     return 0;
1117 }
1118
1119 static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
1120                         const AVFrame *pict, int *got_packet)
1121 {
1122     FFV1Context *f      = avctx->priv_data;
1123     RangeCoder *const c = &f->slice_context[0]->c;
1124     AVFrame *const p    = f->picture.f;
1125     uint8_t keystate    = 128;
1126     uint8_t *buf_p;
1127     int i, ret;
1128     int64_t maxsize =   AV_INPUT_BUFFER_MIN_SIZE
1129                       + avctx->width*avctx->height*37LL*4;
1130
1131     if(!pict) {
1132         if (avctx->flags & AV_CODEC_FLAG_PASS1) {
1133             int j, k, m;
1134             char *p   = avctx->stats_out;
1135             char *end = p + STATS_OUT_SIZE;
1136
1137             memset(f->rc_stat, 0, sizeof(f->rc_stat));
1138             for (i = 0; i < f->quant_table_count; i++)
1139                 memset(f->rc_stat2[i], 0, f->context_count[i] * sizeof(*f->rc_stat2[i]));
1140
1141             av_assert0(f->slice_count == f->max_slice_count);
1142             for (j = 0; j < f->slice_count; j++) {
1143                 FFV1Context *fs = f->slice_context[j];
1144                 for (i = 0; i < 256; i++) {
1145                     f->rc_stat[i][0] += fs->rc_stat[i][0];
1146                     f->rc_stat[i][1] += fs->rc_stat[i][1];
1147                 }
1148                 for (i = 0; i < f->quant_table_count; i++) {
1149                     for (k = 0; k < f->context_count[i]; k++)
1150                         for (m = 0; m < 32; m++) {
1151                             f->rc_stat2[i][k][m][0] += fs->rc_stat2[i][k][m][0];
1152                             f->rc_stat2[i][k][m][1] += fs->rc_stat2[i][k][m][1];
1153                         }
1154                 }
1155             }
1156
1157             for (j = 0; j < 256; j++) {
1158                 snprintf(p, end - p, "%" PRIu64 " %" PRIu64 " ",
1159                         f->rc_stat[j][0], f->rc_stat[j][1]);
1160                 p += strlen(p);
1161             }
1162             snprintf(p, end - p, "\n");
1163
1164             for (i = 0; i < f->quant_table_count; i++) {
1165                 for (j = 0; j < f->context_count[i]; j++)
1166                     for (m = 0; m < 32; m++) {
1167                         snprintf(p, end - p, "%" PRIu64 " %" PRIu64 " ",
1168                                 f->rc_stat2[i][j][m][0], f->rc_stat2[i][j][m][1]);
1169                         p += strlen(p);
1170                     }
1171             }
1172             snprintf(p, end - p, "%d\n", f->gob_count);
1173         }
1174         return 0;
1175     }
1176
1177     if (f->version > 3)
1178         maxsize = AV_INPUT_BUFFER_MIN_SIZE + avctx->width*avctx->height*3LL*4;
1179
1180     if (maxsize > INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE - 32) {
1181         av_log(avctx, AV_LOG_WARNING, "Cannot allocate worst case packet size, the encoding could fail\n");
1182         maxsize = INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE - 32;
1183     }
1184
1185     if ((ret = ff_alloc_packet2(avctx, pkt, maxsize, 0)) < 0)
1186         return ret;
1187
1188     ff_init_range_encoder(c, pkt->data, pkt->size);
1189     ff_build_rac_states(c, 0.05 * (1LL << 32), 256 - 8);
1190
1191     av_frame_unref(p);
1192     if ((ret = av_frame_ref(p, pict)) < 0)
1193         return ret;
1194 #if FF_API_CODED_FRAME
1195 FF_DISABLE_DEPRECATION_WARNINGS
1196     avctx->coded_frame->pict_type = AV_PICTURE_TYPE_I;
1197 FF_ENABLE_DEPRECATION_WARNINGS
1198 #endif
1199
1200     if (avctx->gop_size == 0 || f->picture_number % avctx->gop_size == 0) {
1201         put_rac(c, &keystate, 1);
1202         f->key_frame = 1;
1203         f->gob_count++;
1204         write_header(f);
1205     } else {
1206         put_rac(c, &keystate, 0);
1207         f->key_frame = 0;
1208     }
1209
1210     if (f->ac == AC_RANGE_CUSTOM_TAB) {
1211         int i;
1212         for (i = 1; i < 256; i++) {
1213             c->one_state[i]        = f->state_transition[i];
1214             c->zero_state[256 - i] = 256 - c->one_state[i];
1215         }
1216     }
1217
1218     for (i = 0; i < f->slice_count; i++) {
1219         FFV1Context *fs = f->slice_context[i];
1220         uint8_t *start  = pkt->data + pkt->size * (int64_t)i / f->slice_count;
1221         int len         = pkt->size / f->slice_count;
1222         if (i) {
1223             ff_init_range_encoder(&fs->c, start, len);
1224         } else {
1225             av_assert0(fs->c.bytestream_end >= fs->c.bytestream_start + len);
1226             av_assert0(fs->c.bytestream < fs->c.bytestream_start + len);
1227             fs->c.bytestream_end = fs->c.bytestream_start + len;
1228         }
1229     }
1230     avctx->execute(avctx, encode_slice, &f->slice_context[0], NULL,
1231                    f->slice_count, sizeof(void *));
1232
1233     buf_p = pkt->data;
1234     for (i = 0; i < f->slice_count; i++) {
1235         FFV1Context *fs = f->slice_context[i];
1236         int bytes;
1237
1238         if (fs->ac != AC_GOLOMB_RICE) {
1239             bytes = ff_rac_terminate(&fs->c, 1);
1240         } else {
1241             flush_put_bits(&fs->pb); // FIXME: nicer padding
1242             bytes = fs->ac_byte_count + (put_bits_count(&fs->pb) + 7) / 8;
1243         }
1244         if (i > 0 || f->version > 2) {
1245             av_assert0(bytes < pkt->size / f->slice_count);
1246             memmove(buf_p, fs->c.bytestream_start, bytes);
1247             av_assert0(bytes < (1 << 24));
1248             AV_WB24(buf_p + bytes, bytes);
1249             bytes += 3;
1250         }
1251         if (f->ec) {
1252             unsigned v;
1253             buf_p[bytes++] = 0;
1254             v = av_crc(av_crc_get_table(AV_CRC_32_IEEE), 0, buf_p, bytes);
1255             AV_WL32(buf_p + bytes, v);
1256             bytes += 4;
1257         }
1258         buf_p += bytes;
1259     }
1260
1261     if (avctx->flags & AV_CODEC_FLAG_PASS1)
1262         avctx->stats_out[0] = '\0';
1263
1264 #if FF_API_CODED_FRAME
1265 FF_DISABLE_DEPRECATION_WARNINGS
1266     avctx->coded_frame->key_frame = f->key_frame;
1267 FF_ENABLE_DEPRECATION_WARNINGS
1268 #endif
1269
1270     f->picture_number++;
1271     pkt->size   = buf_p - pkt->data;
1272     pkt->pts    =
1273     pkt->dts    = pict->pts;
1274     pkt->flags |= AV_PKT_FLAG_KEY * f->key_frame;
1275     *got_packet = 1;
1276
1277     return 0;
1278 }
1279
1280 static av_cold int encode_close(AVCodecContext *avctx)
1281 {
1282     ff_ffv1_close(avctx);
1283     return 0;
1284 }
1285
1286 #define OFFSET(x) offsetof(FFV1Context, x)
1287 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
1288 static const AVOption options[] = {
1289     { "slicecrc", "Protect slices with CRCs", OFFSET(ec), AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, VE },
1290     { "coder", "Coder type", OFFSET(ac), AV_OPT_TYPE_INT,
1291             { .i64 = 0 }, -2, 2, VE, "coder" },
1292         { "rice", "Golomb rice", 0, AV_OPT_TYPE_CONST,
1293             { .i64 = AC_GOLOMB_RICE }, INT_MIN, INT_MAX, VE, "coder" },
1294         { "range_def", "Range with default table", 0, AV_OPT_TYPE_CONST,
1295             { .i64 = AC_RANGE_DEFAULT_TAB_FORCE }, INT_MIN, INT_MAX, VE, "coder" },
1296         { "range_tab", "Range with custom table", 0, AV_OPT_TYPE_CONST,
1297             { .i64 = AC_RANGE_CUSTOM_TAB }, INT_MIN, INT_MAX, VE, "coder" },
1298         { "ac", "Range with custom table (the ac option exists for compatibility and is deprecated)", 0, AV_OPT_TYPE_CONST,
1299             { .i64 = 1 }, INT_MIN, INT_MAX, VE, "coder" },
1300     { "context", "Context model", OFFSET(context_model), AV_OPT_TYPE_INT,
1301             { .i64 = 0 }, 0, 1, VE },
1302
1303     { NULL }
1304 };
1305
1306 static const AVClass ffv1_class = {
1307     .class_name = "ffv1 encoder",
1308     .item_name  = av_default_item_name,
1309     .option     = options,
1310     .version    = LIBAVUTIL_VERSION_INT,
1311 };
1312
1313 #if FF_API_CODER_TYPE
1314 static const AVCodecDefault ffv1_defaults[] = {
1315     { "coder", "-1" },
1316     { NULL },
1317 };
1318 #endif
1319
1320 AVCodec ff_ffv1_encoder = {
1321     .name           = "ffv1",
1322     .long_name      = NULL_IF_CONFIG_SMALL("FFmpeg video codec #1"),
1323     .type           = AVMEDIA_TYPE_VIDEO,
1324     .id             = AV_CODEC_ID_FFV1,
1325     .priv_data_size = sizeof(FFV1Context),
1326     .init           = encode_init,
1327     .encode2        = encode_frame,
1328     .close          = encode_close,
1329     .capabilities   = AV_CODEC_CAP_SLICE_THREADS | AV_CODEC_CAP_DELAY,
1330     .pix_fmts       = (const enum AVPixelFormat[]) {
1331         AV_PIX_FMT_YUV420P,   AV_PIX_FMT_YUVA420P,  AV_PIX_FMT_YUVA422P,  AV_PIX_FMT_YUV444P,
1332         AV_PIX_FMT_YUVA444P,  AV_PIX_FMT_YUV440P,   AV_PIX_FMT_YUV422P,   AV_PIX_FMT_YUV411P,
1333         AV_PIX_FMT_YUV410P,   AV_PIX_FMT_0RGB32,    AV_PIX_FMT_RGB32,     AV_PIX_FMT_YUV420P16,
1334         AV_PIX_FMT_YUV422P16, AV_PIX_FMT_YUV444P16, AV_PIX_FMT_YUV444P9,  AV_PIX_FMT_YUV422P9,
1335         AV_PIX_FMT_YUV420P9,  AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10,
1336         AV_PIX_FMT_YUV420P12, AV_PIX_FMT_YUV422P12, AV_PIX_FMT_YUV444P12,
1337         AV_PIX_FMT_YUVA444P16, AV_PIX_FMT_YUVA422P16, AV_PIX_FMT_YUVA420P16,
1338         AV_PIX_FMT_YUVA444P10, AV_PIX_FMT_YUVA422P10, AV_PIX_FMT_YUVA420P10,
1339         AV_PIX_FMT_YUVA444P9, AV_PIX_FMT_YUVA422P9, AV_PIX_FMT_YUVA420P9,
1340         AV_PIX_FMT_GRAY16,    AV_PIX_FMT_GRAY8,     AV_PIX_FMT_GBRP9,     AV_PIX_FMT_GBRP10,
1341         AV_PIX_FMT_GBRP12,    AV_PIX_FMT_GBRP14,
1342         AV_PIX_FMT_GBRAP10, AV_PIX_FMT_GBRAP12,
1343         AV_PIX_FMT_YA8,
1344         AV_PIX_FMT_GRAY10, AV_PIX_FMT_GRAY12,
1345         AV_PIX_FMT_GBRP16, AV_PIX_FMT_RGB48,
1346         AV_PIX_FMT_GBRAP16, AV_PIX_FMT_RGBA64,
1347         AV_PIX_FMT_GRAY9,
1348         AV_PIX_FMT_YUV420P14, AV_PIX_FMT_YUV422P14, AV_PIX_FMT_YUV444P14,
1349         AV_PIX_FMT_YUV440P10, AV_PIX_FMT_YUV440P12,
1350         AV_PIX_FMT_NONE
1351
1352     },
1353 #if FF_API_CODER_TYPE
1354     .defaults       = ffv1_defaults,
1355 #endif
1356     .priv_class     = &ffv1_class,
1357     .caps_internal  = FF_CODEC_CAP_INIT_CLEANUP,
1358 };