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