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