00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00028 #include "libavutil/avassert.h"
00029 #include "libavutil/crc.h"
00030 #include "libavutil/opt.h"
00031 #include "libavutil/imgutils.h"
00032 #include "libavutil/pixdesc.h"
00033 #include "libavutil/timer.h"
00034 #include "avcodec.h"
00035 #include "internal.h"
00036 #include "get_bits.h"
00037 #include "dsputil.h"
00038 #include "rangecoder.h"
00039 #include "golomb.h"
00040 #include "mathops.h"
00041 #include "ffv1.h"
00042
00043 static const int8_t quant5_10bit[256] = {
00044 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1,
00045 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
00046 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
00047 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00048 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00049 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00050 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00051 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00052 -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
00053 -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
00054 -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
00055 -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
00056 -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -1,
00057 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
00058 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
00059 -1, -1, -1, -1, -1, -1, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0,
00060 };
00061
00062 static const int8_t quant5[256] = {
00063 0, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00064 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00065 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00066 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00067 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00068 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00069 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00070 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00071 -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
00072 -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
00073 -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
00074 -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
00075 -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
00076 -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
00077 -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
00078 -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -1, -1, -1,
00079 };
00080
00081 static const int8_t quant9_10bit[256] = {
00082 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2,
00083 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3,
00084 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
00085 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4,
00086 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
00087 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
00088 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
00089 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
00090 -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4,
00091 -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4,
00092 -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4,
00093 -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4,
00094 -4, -4, -4, -4, -4, -4, -4, -4, -4, -3, -3, -3, -3, -3, -3, -3,
00095 -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3,
00096 -3, -3, -3, -3, -3, -3, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
00097 -2, -2, -2, -2, -1, -1, -1, -1, -1, -1, -1, -1, -0, -0, -0, -0,
00098 };
00099
00100 static const int8_t quant11[256] = {
00101 0, 1, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4,
00102 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
00103 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
00104 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
00105 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
00106 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
00107 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
00108 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
00109 -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5,
00110 -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5,
00111 -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5,
00112 -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5,
00113 -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5,
00114 -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -4, -4,
00115 -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4,
00116 -4, -4, -4, -4, -4, -3, -3, -3, -3, -3, -3, -3, -2, -2, -2, -1,
00117 };
00118
00119 static const uint8_t ver2_state[256] = {
00120 0, 10, 10, 10, 10, 16, 16, 16, 28, 16, 16, 29, 42, 49, 20, 49,
00121 59, 25, 26, 26, 27, 31, 33, 33, 33, 34, 34, 37, 67, 38, 39, 39,
00122 40, 40, 41, 79, 43, 44, 45, 45, 48, 48, 64, 50, 51, 52, 88, 52,
00123 53, 74, 55, 57, 58, 58, 74, 60, 101, 61, 62, 84, 66, 66, 68, 69,
00124 87, 82, 71, 97, 73, 73, 82, 75, 111, 77, 94, 78, 87, 81, 83, 97,
00125 85, 83, 94, 86, 99, 89, 90, 99, 111, 92, 93, 134, 95, 98, 105, 98,
00126 105, 110, 102, 108, 102, 118, 103, 106, 106, 113, 109, 112, 114, 112, 116, 125,
00127 115, 116, 117, 117, 126, 119, 125, 121, 121, 123, 145, 124, 126, 131, 127, 129,
00128 165, 130, 132, 138, 133, 135, 145, 136, 137, 139, 146, 141, 143, 142, 144, 148,
00129 147, 155, 151, 149, 151, 150, 152, 157, 153, 154, 156, 168, 158, 162, 161, 160,
00130 172, 163, 169, 164, 166, 184, 167, 170, 177, 174, 171, 173, 182, 176, 180, 178,
00131 175, 189, 179, 181, 186, 183, 192, 185, 200, 187, 191, 188, 190, 197, 193, 196,
00132 197, 194, 195, 196, 198, 202, 199, 201, 210, 203, 207, 204, 205, 206, 208, 214,
00133 209, 211, 221, 212, 213, 215, 224, 216, 217, 218, 219, 220, 222, 228, 223, 225,
00134 226, 224, 227, 229, 240, 230, 231, 232, 233, 234, 235, 236, 238, 239, 237, 242,
00135 241, 243, 242, 244, 245, 246, 247, 248, 249, 250, 251, 252, 252, 253, 254, 255,
00136 };
00137
00138 static void find_best_state(uint8_t best_state[256][256],
00139 const uint8_t one_state[256])
00140 {
00141 int i, j, k, m;
00142 double l2tab[256];
00143
00144 for (i = 1; i < 256; i++)
00145 l2tab[i] = log2(i / 256.0);
00146
00147 for (i = 0; i < 256; i++) {
00148 double best_len[256];
00149 double p = i / 256.0;
00150
00151 for (j = 0; j < 256; j++)
00152 best_len[j] = 1 << 30;
00153
00154 for (j = FFMAX(i - 10, 1); j < FFMIN(i + 11, 256); j++) {
00155 double occ[256] = { 0 };
00156 double len = 0;
00157 occ[j] = 1.0;
00158 for (k = 0; k < 256; k++) {
00159 double newocc[256] = { 0 };
00160 for (m = 1; m < 256; m++)
00161 if (occ[m]) {
00162 len -=occ[m]*( p *l2tab[ m]
00163 + (1-p)*l2tab[256-m]);
00164 }
00165 if (len < best_len[k]) {
00166 best_len[k] = len;
00167 best_state[i][k] = j;
00168 }
00169 for (m = 0; m < 256; m++)
00170 if (occ[m]) {
00171 newocc[ one_state[ m]] += occ[m] * p;
00172 newocc[256 - one_state[256 - m]] += occ[m] * (1 - p);
00173 }
00174 memcpy(occ, newocc, sizeof(occ));
00175 }
00176 }
00177 }
00178 }
00179
00180 static av_always_inline av_flatten void put_symbol_inline(RangeCoder *c,
00181 uint8_t *state, int v,
00182 int is_signed,
00183 uint64_t rc_stat[256][2],
00184 uint64_t rc_stat2[32][2])
00185 {
00186 int i;
00187
00188 #define put_rac(C, S, B) \
00189 do { \
00190 if (rc_stat) { \
00191 rc_stat[*(S)][B]++; \
00192 rc_stat2[(S) - state][B]++; \
00193 } \
00194 put_rac(C, S, B); \
00195 } while (0)
00196
00197 if (v) {
00198 const int a = FFABS(v);
00199 const int e = av_log2(a);
00200 put_rac(c, state + 0, 0);
00201 if (e <= 9) {
00202 for (i = 0; i < e; i++)
00203 put_rac(c, state + 1 + i, 1);
00204 put_rac(c, state + 1 + i, 0);
00205
00206 for (i = e - 1; i >= 0; i--)
00207 put_rac(c, state + 22 + i, (a >> i) & 1);
00208
00209 if (is_signed)
00210 put_rac(c, state + 11 + e, v < 0);
00211 } else {
00212 for (i = 0; i < e; i++)
00213 put_rac(c, state + 1 + FFMIN(i, 9), 1);
00214 put_rac(c, state + 1 + 9, 0);
00215
00216 for (i = e - 1; i >= 0; i--)
00217 put_rac(c, state + 22 + FFMIN(i, 9), (a >> i) & 1);
00218
00219 if (is_signed)
00220 put_rac(c, state + 11 + 10, v < 0);
00221 }
00222 } else {
00223 put_rac(c, state + 0, 1);
00224 }
00225 #undef put_rac
00226 }
00227
00228 static av_noinline void put_symbol(RangeCoder *c, uint8_t *state,
00229 int v, int is_signed)
00230 {
00231 put_symbol_inline(c, state, v, is_signed, NULL, NULL);
00232 }
00233
00234
00235 static inline void put_vlc_symbol(PutBitContext *pb, VlcState *const state,
00236 int v, int bits)
00237 {
00238 int i, k, code;
00239 v = fold(v - state->bias, bits);
00240
00241 i = state->count;
00242 k = 0;
00243 while (i < state->error_sum) {
00244 k++;
00245 i += i;
00246 }
00247
00248 av_assert2(k <= 13);
00249
00250 #if 0 // JPEG LS
00251 if (k == 0 && 2 * state->drift <= -state->count)
00252 code = v ^ (-1);
00253 else
00254 code = v;
00255 #else
00256 code = v ^ ((2 * state->drift + state->count) >> 31);
00257 #endif
00258
00259 av_dlog(NULL, "v:%d/%d bias:%d error:%d drift:%d count:%d k:%d\n", v, code,
00260 state->bias, state->error_sum, state->drift, state->count, k);
00261 set_sr_golomb(pb, code, k, 12, bits);
00262
00263 update_vlc_state(state, v);
00264 }
00265
00266 static av_always_inline int encode_line(FFV1Context *s, int w,
00267 int16_t *sample[3],
00268 int plane_index, int bits)
00269 {
00270 PlaneContext *const p = &s->plane[plane_index];
00271 RangeCoder *const c = &s->c;
00272 int x;
00273 int run_index = s->run_index;
00274 int run_count = 0;
00275 int run_mode = 0;
00276
00277 if (s->ac) {
00278 if (c->bytestream_end - c->bytestream < w * 20) {
00279 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
00280 return AVERROR_INVALIDDATA;
00281 }
00282 } else {
00283 if (s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb) >> 3) < w * 4) {
00284 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
00285 return AVERROR_INVALIDDATA;
00286 }
00287 }
00288
00289 for (x = 0; x < w; x++) {
00290 int diff, context;
00291
00292 context = get_context(p, sample[0] + x, sample[1] + x, sample[2] + x);
00293 diff = sample[0][x] - predict(sample[0] + x, sample[1] + x);
00294
00295 if (context < 0) {
00296 context = -context;
00297 diff = -diff;
00298 }
00299
00300 diff = fold(diff, bits);
00301
00302 if (s->ac) {
00303 if (s->flags & CODEC_FLAG_PASS1) {
00304 put_symbol_inline(c, p->state[context], diff, 1, s->rc_stat,
00305 s->rc_stat2[p->quant_table_index][context]);
00306 } else {
00307 put_symbol_inline(c, p->state[context], diff, 1, NULL, NULL);
00308 }
00309 } else {
00310 if (context == 0)
00311 run_mode = 1;
00312
00313 if (run_mode) {
00314 if (diff) {
00315 while (run_count >= 1 << ff_log2_run[run_index]) {
00316 run_count -= 1 << ff_log2_run[run_index];
00317 run_index++;
00318 put_bits(&s->pb, 1, 1);
00319 }
00320
00321 put_bits(&s->pb, 1 + ff_log2_run[run_index], run_count);
00322 if (run_index)
00323 run_index--;
00324 run_count = 0;
00325 run_mode = 0;
00326 if (diff > 0)
00327 diff--;
00328 } else {
00329 run_count++;
00330 }
00331 }
00332
00333 av_dlog(s->avctx, "count:%d index:%d, mode:%d, x:%d pos:%d\n",
00334 run_count, run_index, run_mode, x,
00335 (int)put_bits_count(&s->pb));
00336
00337 if (run_mode == 0)
00338 put_vlc_symbol(&s->pb, &p->vlc_state[context], diff, bits);
00339 }
00340 }
00341 if (run_mode) {
00342 while (run_count >= 1 << ff_log2_run[run_index]) {
00343 run_count -= 1 << ff_log2_run[run_index];
00344 run_index++;
00345 put_bits(&s->pb, 1, 1);
00346 }
00347
00348 if (run_count)
00349 put_bits(&s->pb, 1, 1);
00350 }
00351 s->run_index = run_index;
00352
00353 return 0;
00354 }
00355
00356 static void encode_plane(FFV1Context *s, uint8_t *src, int w, int h,
00357 int stride, int plane_index)
00358 {
00359 int x, y, i;
00360 const int ring_size = s->avctx->context_model ? 3 : 2;
00361 int16_t *sample[3];
00362 s->run_index = 0;
00363
00364 memset(s->sample_buffer, 0, ring_size * (w + 6) * sizeof(*s->sample_buffer));
00365
00366 for (y = 0; y < h; y++) {
00367 for (i = 0; i < ring_size; i++)
00368 sample[i] = s->sample_buffer + (w + 6) * ((h + i - y) % ring_size) + 3;
00369
00370 sample[0][-1]= sample[1][0 ];
00371 sample[1][ w]= sample[1][w-1];
00372
00373 if (s->bits_per_raw_sample <= 8) {
00374 for (x = 0; x < w; x++)
00375 sample[0][x] = src[x + stride * y];
00376 encode_line(s, w, sample, plane_index, 8);
00377 } else {
00378 if (s->packed_at_lsb) {
00379 for (x = 0; x < w; x++) {
00380 sample[0][x] = ((uint16_t*)(src + stride*y))[x];
00381 }
00382 } else {
00383 for (x = 0; x < w; x++) {
00384 sample[0][x] = ((uint16_t*)(src + stride*y))[x] >> (16 - s->bits_per_raw_sample);
00385 }
00386 }
00387 encode_line(s, w, sample, plane_index, s->bits_per_raw_sample);
00388 }
00389
00390 }
00391 }
00392
00393 static void encode_rgb_frame(FFV1Context *s, uint8_t *src[3], int w, int h, int stride[3])
00394 {
00395 int x, y, p, i;
00396 const int ring_size = s->avctx->context_model ? 3 : 2;
00397 int16_t *sample[4][3];
00398 int lbd = s->avctx->bits_per_raw_sample <= 8;
00399 int bits = s->avctx->bits_per_raw_sample > 0 ? s->avctx->bits_per_raw_sample : 8;
00400 int offset = 1 << bits;
00401
00402 s->run_index = 0;
00403
00404 memset(s->sample_buffer, 0, ring_size * MAX_PLANES *
00405 (w + 6) * sizeof(*s->sample_buffer));
00406
00407 for (y = 0; y < h; y++) {
00408 for (i = 0; i < ring_size; i++)
00409 for (p = 0; p < MAX_PLANES; p++)
00410 sample[p][i]= s->sample_buffer + p*ring_size*(w+6) + ((h+i-y)%ring_size)*(w+6) + 3;
00411
00412 for (x = 0; x < w; x++) {
00413 int b, g, r, av_uninit(a);
00414 if (lbd) {
00415 unsigned v = *((uint32_t*)(src[0] + x*4 + stride[0]*y));
00416 b = v & 0xFF;
00417 g = (v >> 8) & 0xFF;
00418 r = (v >> 16) & 0xFF;
00419 a = v >> 24;
00420 } else {
00421 b = *((uint16_t*)(src[0] + x*2 + stride[0]*y));
00422 g = *((uint16_t*)(src[1] + x*2 + stride[1]*y));
00423 r = *((uint16_t*)(src[2] + x*2 + stride[2]*y));
00424 }
00425
00426 b -= g;
00427 r -= g;
00428 g += (b + r) >> 2;
00429 b += offset;
00430 r += offset;
00431
00432 sample[0][0][x] = g;
00433 sample[1][0][x] = b;
00434 sample[2][0][x] = r;
00435 sample[3][0][x] = a;
00436 }
00437 for (p = 0; p < 3 + s->transparency; p++) {
00438 sample[p][0][-1] = sample[p][1][0 ];
00439 sample[p][1][ w] = sample[p][1][w-1];
00440 if (lbd)
00441 encode_line(s, w, sample[p], (p + 1) / 2, 9);
00442 else
00443 encode_line(s, w, sample[p], (p + 1) / 2, bits + 1);
00444 }
00445 }
00446 }
00447
00448 static void write_quant_table(RangeCoder *c, int16_t *quant_table)
00449 {
00450 int last = 0;
00451 int i;
00452 uint8_t state[CONTEXT_SIZE];
00453 memset(state, 128, sizeof(state));
00454
00455 for (i = 1; i < 128; i++)
00456 if (quant_table[i] != quant_table[i - 1]) {
00457 put_symbol(c, state, i - last - 1, 0);
00458 last = i;
00459 }
00460 put_symbol(c, state, i - last - 1, 0);
00461 }
00462
00463 static void write_quant_tables(RangeCoder *c,
00464 int16_t quant_table[MAX_CONTEXT_INPUTS][256])
00465 {
00466 int i;
00467 for (i = 0; i < 5; i++)
00468 write_quant_table(c, quant_table[i]);
00469 }
00470
00471 static void write_header(FFV1Context *f)
00472 {
00473 uint8_t state[CONTEXT_SIZE];
00474 int i, j;
00475 RangeCoder *const c = &f->slice_context[0]->c;
00476
00477 memset(state, 128, sizeof(state));
00478
00479 if (f->version < 2) {
00480 put_symbol(c, state, f->version, 0);
00481 put_symbol(c, state, f->ac, 0);
00482 if (f->ac > 1) {
00483 for (i = 1; i < 256; i++)
00484 put_symbol(c, state,
00485 f->state_transition[i] - c->one_state[i], 1);
00486 }
00487 put_symbol(c, state, f->colorspace, 0);
00488 if (f->version > 0)
00489 put_symbol(c, state, f->bits_per_raw_sample, 0);
00490 put_rac(c, state, f->chroma_planes);
00491 put_symbol(c, state, f->chroma_h_shift, 0);
00492 put_symbol(c, state, f->chroma_v_shift, 0);
00493 put_rac(c, state, f->transparency);
00494
00495 write_quant_tables(c, f->quant_table);
00496 } else if (f->version < 3) {
00497 put_symbol(c, state, f->slice_count, 0);
00498 for (i = 0; i < f->slice_count; i++) {
00499 FFV1Context *fs = f->slice_context[i];
00500 put_symbol(c, state,
00501 (fs->slice_x + 1) * f->num_h_slices / f->width, 0);
00502 put_symbol(c, state,
00503 (fs->slice_y + 1) * f->num_v_slices / f->height, 0);
00504 put_symbol(c, state,
00505 (fs->slice_width + 1) * f->num_h_slices / f->width - 1,
00506 0);
00507 put_symbol(c, state,
00508 (fs->slice_height + 1) * f->num_v_slices / f->height - 1,
00509 0);
00510 for (j = 0; j < f->plane_count; j++) {
00511 put_symbol(c, state, f->plane[j].quant_table_index, 0);
00512 av_assert0(f->plane[j].quant_table_index == f->avctx->context_model);
00513 }
00514 }
00515 }
00516 }
00517
00518 static int write_extradata(FFV1Context *f)
00519 {
00520 RangeCoder *const c = &f->c;
00521 uint8_t state[CONTEXT_SIZE];
00522 int i, j, k;
00523 uint8_t state2[32][CONTEXT_SIZE];
00524 unsigned v;
00525
00526 memset(state2, 128, sizeof(state2));
00527 memset(state, 128, sizeof(state));
00528
00529 f->avctx->extradata_size = 10000 + 4 +
00530 (11 * 11 * 5 * 5 * 5 + 11 * 11 * 11) * 32;
00531 f->avctx->extradata = av_malloc(f->avctx->extradata_size);
00532 ff_init_range_encoder(c, f->avctx->extradata, f->avctx->extradata_size);
00533 ff_build_rac_states(c, 0.05 * (1LL << 32), 256 - 8);
00534
00535 put_symbol(c, state, f->version, 0);
00536 if (f->version > 2) {
00537 if (f->version == 3)
00538 f->minor_version = 2;
00539 put_symbol(c, state, f->minor_version, 0);
00540 }
00541
00542 put_symbol(c, state, f->ac, 0);
00543 if (f->ac > 1)
00544 for (i = 1; i < 256; i++)
00545 put_symbol(c, state, f->state_transition[i] - c->one_state[i], 1);
00546
00547 put_symbol(c, state, f->colorspace, 0);
00548 put_symbol(c, state, f->bits_per_raw_sample, 0);
00549 put_rac(c, state, f->chroma_planes);
00550 put_symbol(c, state, f->chroma_h_shift, 0);
00551 put_symbol(c, state, f->chroma_v_shift, 0);
00552 put_rac(c, state, f->transparency);
00553 put_symbol(c, state, f->num_h_slices - 1, 0);
00554 put_symbol(c, state, f->num_v_slices - 1, 0);
00555
00556 put_symbol(c, state, f->quant_table_count, 0);
00557 for (i = 0; i < f->quant_table_count; i++)
00558 write_quant_tables(c, f->quant_tables[i]);
00559
00560 for (i = 0; i < f->quant_table_count; i++) {
00561 for (j = 0; j < f->context_count[i] * CONTEXT_SIZE; j++)
00562 if (f->initial_states[i] && f->initial_states[i][0][j] != 128)
00563 break;
00564 if (j < f->context_count[i] * CONTEXT_SIZE) {
00565 put_rac(c, state, 1);
00566 for (j = 0; j < f->context_count[i]; j++)
00567 for (k = 0; k < CONTEXT_SIZE; k++) {
00568 int pred = j ? f->initial_states[i][j - 1][k] : 128;
00569 put_symbol(c, state2[k],
00570 (int8_t)(f->initial_states[i][j][k] - pred), 1);
00571 }
00572 } else {
00573 put_rac(c, state, 0);
00574 }
00575 }
00576
00577 if (f->version > 2) {
00578 put_symbol(c, state, f->ec, 0);
00579 }
00580
00581 f->avctx->extradata_size = ff_rac_terminate(c);
00582 v = av_crc(av_crc_get_table(AV_CRC_32_IEEE), 0, f->avctx->extradata, f->avctx->extradata_size);
00583 AV_WL32(f->avctx->extradata + f->avctx->extradata_size, v);
00584 f->avctx->extradata_size += 4;
00585
00586 return 0;
00587 }
00588
00589 static int sort_stt(FFV1Context *s, uint8_t stt[256])
00590 {
00591 int i, i2, changed, print = 0;
00592
00593 do {
00594 changed = 0;
00595 for (i = 12; i < 244; i++) {
00596 for (i2 = i + 1; i2 < 245 && i2 < i + 4; i2++) {
00597
00598 #define COST(old, new) \
00599 s->rc_stat[old][0] * -log2((256 - (new)) / 256.0) + \
00600 s->rc_stat[old][1] * -log2((new) / 256.0)
00601
00602 #define COST2(old, new) \
00603 COST(old, new) + COST(256 - (old), 256 - (new))
00604
00605 double size0 = COST2(i, i) + COST2(i2, i2);
00606 double sizeX = COST2(i, i2) + COST2(i2, i);
00607 if (size0 - sizeX > size0*(1e-14) && i != 128 && i2 != 128) {
00608 int j;
00609 FFSWAP(int, stt[i], stt[i2]);
00610 FFSWAP(int, s->rc_stat[i][0], s->rc_stat[i2][0]);
00611 FFSWAP(int, s->rc_stat[i][1], s->rc_stat[i2][1]);
00612 if (i != 256 - i2) {
00613 FFSWAP(int, stt[256 - i], stt[256 - i2]);
00614 FFSWAP(int, s->rc_stat[256 - i][0], s->rc_stat[256 - i2][0]);
00615 FFSWAP(int, s->rc_stat[256 - i][1], s->rc_stat[256 - i2][1]);
00616 }
00617 for (j = 1; j < 256; j++) {
00618 if (stt[j] == i)
00619 stt[j] = i2;
00620 else if (stt[j] == i2)
00621 stt[j] = i;
00622 if (i != 256 - i2) {
00623 if (stt[256 - j] == 256 - i)
00624 stt[256 - j] = 256 - i2;
00625 else if (stt[256 - j] == 256 - i2)
00626 stt[256 - j] = 256 - i;
00627 }
00628 }
00629 print = changed = 1;
00630 }
00631 }
00632 }
00633 } while (changed);
00634 return print;
00635 }
00636
00637 static av_cold int encode_init(AVCodecContext *avctx)
00638 {
00639 FFV1Context *s = avctx->priv_data;
00640 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(avctx->pix_fmt);
00641 int i, j, k, m, ret;
00642
00643 ffv1_common_init(avctx);
00644
00645 s->version = 0;
00646
00647 if ((avctx->flags & (CODEC_FLAG_PASS1|CODEC_FLAG_PASS2)) || avctx->slices>1)
00648 s->version = FFMAX(s->version, 2);
00649
00650 if (avctx->level == 3) {
00651 s->version = 3;
00652 }
00653
00654 if (s->ec < 0) {
00655 s->ec = (s->version >= 3);
00656 }
00657
00658 if (s->version >= 2 && avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
00659 av_log(avctx, AV_LOG_ERROR, "Version 2 needed for requested features but version 2 is experimental and not enabled\n");
00660 return AVERROR_INVALIDDATA;
00661 }
00662
00663 s->ac = avctx->coder_type > 0 ? 2 : 0;
00664
00665 s->plane_count = 3;
00666 switch(avctx->pix_fmt) {
00667 case AV_PIX_FMT_YUV444P9:
00668 case AV_PIX_FMT_YUV422P9:
00669 case AV_PIX_FMT_YUV420P9:
00670 if (!avctx->bits_per_raw_sample)
00671 s->bits_per_raw_sample = 9;
00672 case AV_PIX_FMT_YUV444P10:
00673 case AV_PIX_FMT_YUV420P10:
00674 case AV_PIX_FMT_YUV422P10:
00675 s->packed_at_lsb = 1;
00676 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
00677 s->bits_per_raw_sample = 10;
00678 case AV_PIX_FMT_GRAY16:
00679 case AV_PIX_FMT_YUV444P16:
00680 case AV_PIX_FMT_YUV422P16:
00681 case AV_PIX_FMT_YUV420P16:
00682 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample) {
00683 s->bits_per_raw_sample = 16;
00684 } else if (!s->bits_per_raw_sample) {
00685 s->bits_per_raw_sample = avctx->bits_per_raw_sample;
00686 }
00687 if (s->bits_per_raw_sample <= 8) {
00688 av_log(avctx, AV_LOG_ERROR, "bits_per_raw_sample invalid\n");
00689 return AVERROR_INVALIDDATA;
00690 }
00691 if (!s->ac && avctx->coder_type == -1) {
00692 av_log(avctx, AV_LOG_INFO, "bits_per_raw_sample > 8, forcing coder 1\n");
00693 s->ac = 2;
00694 }
00695 if (!s->ac) {
00696 av_log(avctx, AV_LOG_ERROR, "bits_per_raw_sample of more than 8 needs -coder 1 currently\n");
00697 return AVERROR(ENOSYS);
00698 }
00699 s->version = FFMAX(s->version, 1);
00700 case AV_PIX_FMT_GRAY8:
00701 case AV_PIX_FMT_YUV444P:
00702 case AV_PIX_FMT_YUV440P:
00703 case AV_PIX_FMT_YUV422P:
00704 case AV_PIX_FMT_YUV420P:
00705 case AV_PIX_FMT_YUV411P:
00706 case AV_PIX_FMT_YUV410P:
00707 s->chroma_planes = desc->nb_components < 3 ? 0 : 1;
00708 s->colorspace = 0;
00709 break;
00710 case AV_PIX_FMT_YUVA444P:
00711 case AV_PIX_FMT_YUVA422P:
00712 case AV_PIX_FMT_YUVA420P:
00713 s->chroma_planes = 1;
00714 s->colorspace = 0;
00715 s->transparency = 1;
00716 break;
00717 case AV_PIX_FMT_RGB32:
00718 s->colorspace = 1;
00719 s->transparency = 1;
00720 break;
00721 case AV_PIX_FMT_0RGB32:
00722 s->colorspace = 1;
00723 break;
00724 case AV_PIX_FMT_GBRP9:
00725 if (!avctx->bits_per_raw_sample)
00726 s->bits_per_raw_sample = 9;
00727 case AV_PIX_FMT_GBRP10:
00728 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
00729 s->bits_per_raw_sample = 10;
00730 case AV_PIX_FMT_GBRP12:
00731 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
00732 s->bits_per_raw_sample = 12;
00733 case AV_PIX_FMT_GBRP14:
00734 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
00735 s->bits_per_raw_sample = 14;
00736 else if (!s->bits_per_raw_sample)
00737 s->bits_per_raw_sample = avctx->bits_per_raw_sample;
00738 s->colorspace = 1;
00739 s->chroma_planes = 1;
00740 s->version = FFMAX(s->version, 1);
00741 break;
00742 default:
00743 av_log(avctx, AV_LOG_ERROR, "format not supported\n");
00744 return AVERROR(ENOSYS);
00745 }
00746 if (s->transparency) {
00747 av_log(avctx, AV_LOG_WARNING, "Storing alpha plane, this will require a recent FFV1 decoder to playback!\n");
00748 }
00749 if (avctx->context_model > 1U) {
00750 av_log(avctx, AV_LOG_ERROR, "Invalid context model %d, valid values are 0 and 1\n", avctx->context_model);
00751 return AVERROR(EINVAL);
00752 }
00753
00754 if (s->ac > 1)
00755 for (i = 1; i < 256; i++)
00756 s->state_transition[i] = ver2_state[i];
00757
00758 for (i = 0; i < 256; i++) {
00759 s->quant_table_count = 2;
00760 if (s->bits_per_raw_sample <= 8) {
00761 s->quant_tables[0][0][i]= quant11[i];
00762 s->quant_tables[0][1][i]= 11*quant11[i];
00763 s->quant_tables[0][2][i]= 11*11*quant11[i];
00764 s->quant_tables[1][0][i]= quant11[i];
00765 s->quant_tables[1][1][i]= 11*quant11[i];
00766 s->quant_tables[1][2][i]= 11*11*quant5 [i];
00767 s->quant_tables[1][3][i]= 5*11*11*quant5 [i];
00768 s->quant_tables[1][4][i]= 5*5*11*11*quant5 [i];
00769 } else {
00770 s->quant_tables[0][0][i]= quant9_10bit[i];
00771 s->quant_tables[0][1][i]= 11*quant9_10bit[i];
00772 s->quant_tables[0][2][i]= 11*11*quant9_10bit[i];
00773 s->quant_tables[1][0][i]= quant9_10bit[i];
00774 s->quant_tables[1][1][i]= 11*quant9_10bit[i];
00775 s->quant_tables[1][2][i]= 11*11*quant5_10bit[i];
00776 s->quant_tables[1][3][i]= 5*11*11*quant5_10bit[i];
00777 s->quant_tables[1][4][i]= 5*5*11*11*quant5_10bit[i];
00778 }
00779 }
00780 s->context_count[0] = (11 * 11 * 11 + 1) / 2;
00781 s->context_count[1] = (11 * 11 * 5 * 5 * 5 + 1) / 2;
00782 memcpy(s->quant_table, s->quant_tables[avctx->context_model],
00783 sizeof(s->quant_table));
00784
00785 for (i = 0; i < s->plane_count; i++) {
00786 PlaneContext *const p = &s->plane[i];
00787
00788 memcpy(p->quant_table, s->quant_table, sizeof(p->quant_table));
00789 p->quant_table_index = avctx->context_model;
00790 p->context_count = s->context_count[p->quant_table_index];
00791 }
00792
00793 if ((ret = ffv1_allocate_initial_states(s)) < 0)
00794 return ret;
00795
00796 avctx->coded_frame = &s->picture;
00797 if (!s->transparency)
00798 s->plane_count = 2;
00799 avcodec_get_chroma_sub_sample(avctx->pix_fmt, &s->chroma_h_shift, &s->chroma_v_shift);
00800 s->picture_number = 0;
00801
00802 if (avctx->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2)) {
00803 for (i = 0; i < s->quant_table_count; i++) {
00804 s->rc_stat2[i] = av_mallocz(s->context_count[i] *
00805 sizeof(*s->rc_stat2[i]));
00806 if (!s->rc_stat2[i])
00807 return AVERROR(ENOMEM);
00808 }
00809 }
00810 if (avctx->stats_in) {
00811 char *p = avctx->stats_in;
00812 uint8_t best_state[256][256];
00813 int gob_count = 0;
00814 char *next;
00815
00816 av_assert0(s->version >= 2);
00817
00818 for (;;) {
00819 for (j = 0; j < 256; j++)
00820 for (i = 0; i < 2; i++) {
00821 s->rc_stat[j][i] = strtol(p, &next, 0);
00822 if (next == p) {
00823 av_log(avctx, AV_LOG_ERROR,
00824 "2Pass file invalid at %d %d [%s]\n", j, i, p);
00825 return AVERROR_INVALIDDATA;
00826 }
00827 p = next;
00828 }
00829 for (i = 0; i < s->quant_table_count; i++)
00830 for (j = 0; j < s->context_count[i]; j++) {
00831 for (k = 0; k < 32; k++)
00832 for (m = 0; m < 2; m++) {
00833 s->rc_stat2[i][j][k][m] = strtol(p, &next, 0);
00834 if (next == p) {
00835 av_log(avctx, AV_LOG_ERROR,
00836 "2Pass file invalid at %d %d %d %d [%s]\n",
00837 i, j, k, m, p);
00838 return AVERROR_INVALIDDATA;
00839 }
00840 p = next;
00841 }
00842 }
00843 gob_count = strtol(p, &next, 0);
00844 if (next == p || gob_count <= 0) {
00845 av_log(avctx, AV_LOG_ERROR, "2Pass file invalid\n");
00846 return AVERROR_INVALIDDATA;
00847 }
00848 p = next;
00849 while (*p == '\n' || *p == ' ')
00850 p++;
00851 if (p[0] == 0)
00852 break;
00853 }
00854 sort_stt(s, s->state_transition);
00855
00856 find_best_state(best_state, s->state_transition);
00857
00858 for (i = 0; i < s->quant_table_count; i++) {
00859 for (j = 0; j < s->context_count[i]; j++)
00860 for (k = 0; k < 32; k++) {
00861 double p = 128;
00862 if (s->rc_stat2[i][j][k][0] + s->rc_stat2[i][j][k][1]) {
00863 p = 256.0 * s->rc_stat2[i][j][k][1] /
00864 (s->rc_stat2[i][j][k][0] + s->rc_stat2[i][j][k][1]);
00865 }
00866 s->initial_states[i][j][k] =
00867 best_state[av_clip(round(p), 1, 255)][av_clip((s->rc_stat2[i][j][k][0] +
00868 s->rc_stat2[i][j][k][1]) /
00869 gob_count, 0, 255)];
00870 }
00871 }
00872 }
00873
00874 if (s->version > 1) {
00875 s->num_v_slices = (avctx->width > 352 || avctx->height > 288 || !avctx->slices) ? 2 : 1;
00876 for (; s->num_v_slices < 9; s->num_v_slices++) {
00877 for (s->num_h_slices = s->num_v_slices; s->num_h_slices < 2*s->num_v_slices; s->num_h_slices++) {
00878 if (avctx->slices == s->num_h_slices * s->num_v_slices && avctx->slices <= 64 || !avctx->slices)
00879 goto slices_ok;
00880 }
00881 }
00882 av_log(avctx, AV_LOG_ERROR,
00883 "Unsupported number %d of slices requested, please specify a "
00884 "supported number with -slices (ex:4,6,9,12,16, ...)\n",
00885 avctx->slices);
00886 return AVERROR(ENOSYS);
00887 slices_ok:
00888 write_extradata(s);
00889 }
00890
00891 if ((ret = ffv1_init_slice_contexts(s)) < 0)
00892 return ret;
00893 if ((ret = ffv1_init_slices_state(s)) < 0)
00894 return ret;
00895
00896 #define STATS_OUT_SIZE 1024 * 1024 * 6
00897 if (avctx->flags & CODEC_FLAG_PASS1) {
00898 avctx->stats_out = av_mallocz(STATS_OUT_SIZE);
00899 for (i = 0; i < s->quant_table_count; i++)
00900 for (j = 0; j < s->slice_count; j++) {
00901 FFV1Context *sf = s->slice_context[j];
00902 av_assert0(!sf->rc_stat2[i]);
00903 sf->rc_stat2[i] = av_mallocz(s->context_count[i] *
00904 sizeof(*sf->rc_stat2[i]));
00905 if (!sf->rc_stat2[i])
00906 return AVERROR(ENOMEM);
00907 }
00908 }
00909
00910 return 0;
00911 }
00912
00913 static void encode_slice_header(FFV1Context *f, FFV1Context *fs)
00914 {
00915 RangeCoder *c = &fs->c;
00916 uint8_t state[CONTEXT_SIZE];
00917 int j;
00918 memset(state, 128, sizeof(state));
00919
00920 put_symbol(c, state, (fs->slice_x +1)*f->num_h_slices / f->width , 0);
00921 put_symbol(c, state, (fs->slice_y +1)*f->num_v_slices / f->height , 0);
00922 put_symbol(c, state, (fs->slice_width +1)*f->num_h_slices / f->width -1, 0);
00923 put_symbol(c, state, (fs->slice_height+1)*f->num_v_slices / f->height-1, 0);
00924 for (j=0; j<f->plane_count; j++) {
00925 put_symbol(c, state, f->plane[j].quant_table_index, 0);
00926 av_assert0(f->plane[j].quant_table_index == f->avctx->context_model);
00927 }
00928 if (!f->picture.interlaced_frame)
00929 put_symbol(c, state, 3, 0);
00930 else
00931 put_symbol(c, state, 1 + !f->picture.top_field_first, 0);
00932 put_symbol(c, state, f->picture.sample_aspect_ratio.num, 0);
00933 put_symbol(c, state, f->picture.sample_aspect_ratio.den, 0);
00934 }
00935
00936 static int encode_slice(AVCodecContext *c, void *arg)
00937 {
00938 FFV1Context *fs = *(void **)arg;
00939 FFV1Context *f = fs->avctx->priv_data;
00940 int width = fs->slice_width;
00941 int height = fs->slice_height;
00942 int x = fs->slice_x;
00943 int y = fs->slice_y;
00944 AVFrame *const p = &f->picture;
00945 const int ps = av_pix_fmt_desc_get(c->pix_fmt)->comp[0].step_minus1 + 1;
00946
00947 if (p->key_frame)
00948 ffv1_clear_slice_state(f, fs);
00949 if (f->version > 2) {
00950 encode_slice_header(f, fs);
00951 }
00952 if (!fs->ac) {
00953 if (f->version > 2)
00954 put_rac(&fs->c, (uint8_t[]) { 129 }, 0);
00955 fs->ac_byte_count = f->version > 2 || (!x && !y) ? ff_rac_terminate(&fs->c) : 0;
00956 init_put_bits(&fs->pb,
00957 fs->c.bytestream_start + fs->ac_byte_count,
00958 fs->c.bytestream_end - fs->c.bytestream_start - fs->ac_byte_count);
00959 }
00960
00961 if (f->colorspace == 0) {
00962 const int chroma_width = -((-width) >> f->chroma_h_shift);
00963 const int chroma_height = -((-height) >> f->chroma_v_shift);
00964 const int cx = x >> f->chroma_h_shift;
00965 const int cy = y >> f->chroma_v_shift;
00966
00967 encode_plane(fs, p->data[0] + ps*x + y*p->linesize[0], width, height, p->linesize[0], 0);
00968
00969 if (f->chroma_planes) {
00970 encode_plane(fs, p->data[1] + ps*cx+cy*p->linesize[1], chroma_width, chroma_height, p->linesize[1], 1);
00971 encode_plane(fs, p->data[2] + ps*cx+cy*p->linesize[2], chroma_width, chroma_height, p->linesize[2], 1);
00972 }
00973 if (fs->transparency)
00974 encode_plane(fs, p->data[3] + ps*x + y*p->linesize[3], width, height, p->linesize[3], 2);
00975 } else {
00976 uint8_t *planes[3] = {p->data[0] + ps*x + y*p->linesize[0],
00977 p->data[1] + ps*x + y*p->linesize[1],
00978 p->data[2] + ps*x + y*p->linesize[2]};
00979 encode_rgb_frame(fs, planes, width, height, p->linesize);
00980 }
00981 emms_c();
00982
00983 return 0;
00984 }
00985
00986 static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
00987 const AVFrame *pict, int *got_packet)
00988 {
00989 FFV1Context *f = avctx->priv_data;
00990 RangeCoder *const c = &f->slice_context[0]->c;
00991 AVFrame *const p = &f->picture;
00992 int used_count = 0;
00993 uint8_t keystate = 128;
00994 uint8_t *buf_p;
00995 int i, ret;
00996
00997 if ((ret = ff_alloc_packet2(avctx, pkt, avctx->width*avctx->height*((8*2+1+1)*4)/8
00998 + FF_MIN_BUFFER_SIZE)) < 0)
00999 return ret;
01000
01001 ff_init_range_encoder(c, pkt->data, pkt->size);
01002 ff_build_rac_states(c, 0.05 * (1LL << 32), 256 - 8);
01003
01004 *p = *pict;
01005 p->pict_type = AV_PICTURE_TYPE_I;
01006
01007 if (avctx->gop_size == 0 || f->picture_number % avctx->gop_size == 0) {
01008 put_rac(c, &keystate, 1);
01009 p->key_frame = 1;
01010 f->gob_count++;
01011 write_header(f);
01012 } else {
01013 put_rac(c, &keystate, 0);
01014 p->key_frame = 0;
01015 }
01016
01017 if (f->ac > 1) {
01018 int i;
01019 for (i = 1; i < 256; i++) {
01020 c->one_state[i] = f->state_transition[i];
01021 c->zero_state[256 - i] = 256 - c->one_state[i];
01022 }
01023 }
01024
01025 for (i = 1; i < f->slice_count; i++) {
01026 FFV1Context *fs = f->slice_context[i];
01027 uint8_t *start = pkt->data + (pkt->size - used_count) * (int64_t)i / f->slice_count;
01028 int len = pkt->size / f->slice_count;
01029 ff_init_range_encoder(&fs->c, start, len);
01030 }
01031 avctx->execute(avctx, encode_slice, &f->slice_context[0], NULL,
01032 f->slice_count, sizeof(void *));
01033
01034 buf_p = pkt->data;
01035 for (i = 0; i < f->slice_count; i++) {
01036 FFV1Context *fs = f->slice_context[i];
01037 int bytes;
01038
01039 if (fs->ac) {
01040 uint8_t state = 129;
01041 put_rac(&fs->c, &state, 0);
01042 bytes = ff_rac_terminate(&fs->c);
01043 } else {
01044 flush_put_bits(&fs->pb);
01045 bytes = fs->ac_byte_count + (put_bits_count(&fs->pb) + 7) / 8;
01046 }
01047 if (i > 0 || f->version > 2) {
01048 av_assert0(bytes < pkt->size / f->slice_count);
01049 memmove(buf_p, fs->c.bytestream_start, bytes);
01050 av_assert0(bytes < (1 << 24));
01051 AV_WB24(buf_p + bytes, bytes);
01052 bytes += 3;
01053 }
01054 if (f->ec) {
01055 unsigned v;
01056 buf_p[bytes++] = 0;
01057 v = av_crc(av_crc_get_table(AV_CRC_32_IEEE), 0, buf_p, bytes);
01058 AV_WL32(buf_p + bytes, v);
01059 bytes += 4;
01060 }
01061 buf_p += bytes;
01062 }
01063
01064 if ((avctx->flags & CODEC_FLAG_PASS1) && (f->picture_number & 31) == 0) {
01065 int j, k, m;
01066 char *p = avctx->stats_out;
01067 char *end = p + STATS_OUT_SIZE;
01068
01069 memset(f->rc_stat, 0, sizeof(f->rc_stat));
01070 for (i = 0; i < f->quant_table_count; i++)
01071 memset(f->rc_stat2[i], 0, f->context_count[i] * sizeof(*f->rc_stat2[i]));
01072
01073 for (j = 0; j < f->slice_count; j++) {
01074 FFV1Context *fs = f->slice_context[j];
01075 for (i = 0; i < 256; i++) {
01076 f->rc_stat[i][0] += fs->rc_stat[i][0];
01077 f->rc_stat[i][1] += fs->rc_stat[i][1];
01078 }
01079 for (i = 0; i < f->quant_table_count; i++) {
01080 for (k = 0; k < f->context_count[i]; k++)
01081 for (m = 0; m < 32; m++) {
01082 f->rc_stat2[i][k][m][0] += fs->rc_stat2[i][k][m][0];
01083 f->rc_stat2[i][k][m][1] += fs->rc_stat2[i][k][m][1];
01084 }
01085 }
01086 }
01087
01088 for (j = 0; j < 256; j++) {
01089 snprintf(p, end - p, "%" PRIu64 " %" PRIu64 " ",
01090 f->rc_stat[j][0], f->rc_stat[j][1]);
01091 p += strlen(p);
01092 }
01093 snprintf(p, end - p, "\n");
01094
01095 for (i = 0; i < f->quant_table_count; i++) {
01096 for (j = 0; j < f->context_count[i]; j++)
01097 for (m = 0; m < 32; m++) {
01098 snprintf(p, end - p, "%" PRIu64 " %" PRIu64 " ",
01099 f->rc_stat2[i][j][m][0], f->rc_stat2[i][j][m][1]);
01100 p += strlen(p);
01101 }
01102 }
01103 snprintf(p, end - p, "%d\n", f->gob_count);
01104 } else if (avctx->flags & CODEC_FLAG_PASS1)
01105 avctx->stats_out[0] = '\0';
01106
01107 f->picture_number++;
01108 pkt->size = buf_p - pkt->data;
01109 pkt->flags |= AV_PKT_FLAG_KEY * p->key_frame;
01110 *got_packet = 1;
01111
01112 return 0;
01113 }
01114
01115 #define OFFSET(x) offsetof(FFV1Context, x)
01116 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
01117 static const AVOption options[] = {
01118 { "slicecrc", "Protect slices with CRCs", OFFSET(ec), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 1, VE },
01119 { NULL }
01120 };
01121
01122 static const AVClass class = {
01123 .class_name = "ffv1 encoder",
01124 .item_name = av_default_item_name,
01125 .option = options,
01126 .version = LIBAVUTIL_VERSION_INT,
01127 };
01128
01129 static const AVCodecDefault ffv1_defaults[] = {
01130 { "coder", "-1" },
01131 { NULL },
01132 };
01133
01134 AVCodec ff_ffv1_encoder = {
01135 .name = "ffv1",
01136 .type = AVMEDIA_TYPE_VIDEO,
01137 .id = AV_CODEC_ID_FFV1,
01138 .priv_data_size = sizeof(FFV1Context),
01139 .init = encode_init,
01140 .encode2 = encode_frame,
01141 .close = ffv1_close,
01142 .capabilities = CODEC_CAP_SLICE_THREADS,
01143 .pix_fmts = (const enum AVPixelFormat[]) {
01144 AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUVA420P, AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUV444P,
01145 AV_PIX_FMT_YUVA444P, AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV411P,
01146 AV_PIX_FMT_YUV410P, AV_PIX_FMT_0RGB32, AV_PIX_FMT_RGB32, AV_PIX_FMT_YUV420P16,
01147 AV_PIX_FMT_YUV422P16, AV_PIX_FMT_YUV444P16, AV_PIX_FMT_YUV444P9, AV_PIX_FMT_YUV422P9,
01148 AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10,
01149 AV_PIX_FMT_GRAY16, AV_PIX_FMT_GRAY8, AV_PIX_FMT_GBRP9, AV_PIX_FMT_GBRP10,
01150 AV_PIX_FMT_GBRP12, AV_PIX_FMT_GBRP14,
01151 AV_PIX_FMT_NONE
01152
01153 },
01154 .long_name = NULL_IF_CONFIG_SMALL("FFmpeg video codec #1"),
01155 .defaults = ffv1_defaults,
01156 .priv_class = &class,
01157 };
