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

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