ffv1.h 5.12 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37
/*
 * FFV1 codec for libavcodec
 *
 * Copyright (c) 2003-2012 Michael Niedermayer <michaelni@gmx.at>
 *
 * This file is part of FFmpeg.
 *
 * FFmpeg is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * FFmpeg is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with FFmpeg; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

#ifndef AVCODEC_FFV1_H
#define AVCODEC_FFV1_H

/**
 * @file
 * FF Video Codec 1 (a lossless codec)
 */

#include "libavutil/avassert.h"
#include "libavutil/crc.h"
#include "libavutil/opt.h"
#include "libavutil/imgutils.h"
#include "libavutil/pixdesc.h"
#include "libavutil/timer.h"
#include "avcodec.h"
38
#include "get_bits.h"
39
#include "internal.h"
40
#include "mathops.h"
41 42
#include "put_bits.h"
#include "rangecoder.h"
43
#include "thread.h"
44 45 46 47 48 49 50 51 52 53 54 55

#ifdef __INTEL_COMPILER
#undef av_flatten
#define av_flatten
#endif

#define MAX_PLANES 4
#define CONTEXT_SIZE 32

#define MAX_QUANT_TABLES 8
#define MAX_CONTEXT_INPUTS 5

56 57 58
#define AC_GOLOMB_RICE          0
#define AC_RANGE_DEFAULT_TAB    1
#define AC_RANGE_CUSTOM_TAB     2
59
#define AC_RANGE_DEFAULT_TAB_FORCE -2
60

61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76
typedef struct VlcState {
    int16_t drift;
    uint16_t error_sum;
    int8_t bias;
    uint8_t count;
} VlcState;

typedef struct PlaneContext {
    int16_t quant_table[MAX_CONTEXT_INPUTS][256];
    int quant_table_index;
    int context_count;
    uint8_t (*state)[CONTEXT_SIZE];
    VlcState *vlc_state;
    uint8_t interlace_bit_state[2];
} PlaneContext;

77
#define MAX_SLICES 1024
78 79 80 81 82 83 84 85 86 87

typedef struct FFV1Context {
    AVClass *class;
    AVCodecContext *avctx;
    RangeCoder c;
    GetBitContext gb;
    PutBitContext pb;
    uint64_t rc_stat[256][2];
    uint64_t (*rc_stat2[MAX_QUANT_TABLES])[32][2];
    int version;
88
    int micro_version;
89 90
    int width, height;
    int chroma_planes;
91
    int chroma_h_shift, chroma_v_shift;
92 93 94
    int transparency;
    int flags;
    int picture_number;
95
    int key_frame;
96
    ThreadFrame picture, last_picture;
97
    struct FFV1Context *fsrc;
98 99

    AVFrame *cur;
100 101 102 103 104 105 106 107 108 109 110 111
    int plane_count;
    int ac;                              ///< 1=range coder <-> 0=golomb rice
    int ac_byte_count;                   ///< number of bytes used for AC coding
    PlaneContext plane[MAX_PLANES];
    int16_t quant_table[MAX_CONTEXT_INPUTS][256];
    int16_t quant_tables[MAX_QUANT_TABLES][MAX_CONTEXT_INPUTS][256];
    int context_count[MAX_QUANT_TABLES];
    uint8_t state_transition[256];
    uint8_t (*initial_states[MAX_QUANT_TABLES])[32];
    int run_index;
    int colorspace;
    int16_t *sample_buffer;
112 113 114
    int32_t *sample_buffer32;

    int use32bit;
115

116
    int ec;
117
    int intra;
118 119
    int slice_damaged;
    int key_frame_ok;
120
    int context_model;
121

122 123 124 125
    int bits_per_raw_sample;
    int packed_at_lsb;

    int gob_count;
126 127 128 129
    int quant_table_count;

    struct FFV1Context *slice_context[MAX_SLICES];
    int slice_count;
130
    int max_slice_count;
131 132 133 134 135 136
    int num_v_slices;
    int num_h_slices;
    int slice_width;
    int slice_height;
    int slice_x;
    int slice_y;
137 138
    int slice_reset_contexts;
    int slice_coding_mode;
139 140
    int slice_rct_by_coef;
    int slice_rct_ry_coef;
141 142
} FFV1Context;

143 144 145 146 147 148 149
int ff_ffv1_common_init(AVCodecContext *avctx);
int ff_ffv1_init_slice_state(FFV1Context *f, FFV1Context *fs);
int ff_ffv1_init_slices_state(FFV1Context *f);
int ff_ffv1_init_slice_contexts(FFV1Context *f);
int ff_ffv1_allocate_initial_states(FFV1Context *f);
void ff_ffv1_clear_slice_state(FFV1Context *f, FFV1Context *fs);
int ff_ffv1_close(AVCodecContext *avctx);
150 151 152 153 154 155 156

static av_always_inline int fold(int diff, int bits)
{
    if (bits == 8)
        diff = (int8_t)diff;
    else {
        diff +=  1 << (bits  - 1);
157
        diff  = av_mod_uintp2(diff, bits);
158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197
        diff -=  1 << (bits  - 1);
    }

    return diff;
}

static inline void update_vlc_state(VlcState *const state, const int v)
{
    int drift = state->drift;
    int count = state->count;
    state->error_sum += FFABS(v);
    drift            += v;

    if (count == 128) { // FIXME: variable
        count            >>= 1;
        drift            >>= 1;
        state->error_sum >>= 1;
    }
    count++;

    if (drift <= -count) {
        if (state->bias > -128)
            state->bias--;

        drift += count;
        if (drift <= -count)
            drift = -count + 1;
    } else if (drift > 0) {
        if (state->bias < 127)
            state->bias++;

        drift -= count;
        if (drift > 0)
            drift = 0;
    }

    state->drift = drift;
    state->count = count;
}

198 199 200 201 202 203
#define TYPE int16_t
#define RENAME(name) name
#include "ffv1_template.c"
#undef TYPE
#undef RENAME

204 205 206 207 208 209
#define TYPE int32_t
#define RENAME(name) name ## 32
#include "ffv1_template.c"
#undef TYPE
#undef RENAME

210
#endif /* AVCODEC_FFV1_H */