git.sesse.net Git - ffmpeg/blob - libavcodec/ffv1enc.c

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