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