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