libavcodec/ffv1.c

   1 /*
   2  * FFV1 codec for libavcodec
   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)
  26  */
  27
  28 #include "libavutil/attributes.h"
  29 #include "libavutil/avassert.h"
  30 #include "libavutil/mem.h"
  31
  32 #include "avcodec.h"
  33 #include "ffv1.h"
  34 #include "libavutil/refstruct.h"
  35
  36 av_cold int ff_ffv1_common_init(AVCodecContext *avctx, FFV1Context *s)
  37 {
  38     if (!avctx->width || !avctx->height)
  39         return AVERROR_INVALIDDATA;
  40
  41     s->avctx = avctx;
  42     s->flags = avctx->flags;
  43
  44     s->width  = avctx->width;
  45     s->height = avctx->height;
  46
  47     // defaults
  48     s->num_h_slices = 1;
  49     s->num_v_slices = 1;
  50
  51     return 0;
  52 }
  53
  54 static void planes_free(AVRefStructOpaque opaque, void *obj)
  55 {
  56     PlaneContext *planes = obj;
  57
  58     for (int i = 0; i < MAX_PLANES; i++) {
  59         PlaneContext *p = &planes[i];
  60
  61         av_freep(&p->state);
  62         av_freep(&p->vlc_state);
  63     }
  64 }
  65
  66 PlaneContext* ff_ffv1_planes_alloc(void)
  67 {
  68     return av_refstruct_alloc_ext(sizeof(PlaneContext) * MAX_PLANES,
  69                                   0, NULL, planes_free);
  70 }
  71
  72 av_cold int ff_ffv1_init_slice_state(const FFV1Context *f,
  73                                      FFV1SliceContext *sc)
  74 {
  75     int j, i;
  76
  77     for (j = 0; j < f->plane_count; j++) {
  78         PlaneContext *const p = &sc->plane[j];
  79
  80         if (f->ac != AC_GOLOMB_RICE) {
  81             if (!p->state)
  82                 p->state = av_calloc(p->context_count, CONTEXT_SIZE *
  83                                      sizeof(uint8_t));
  84             if (!p->state)
  85                 return AVERROR(ENOMEM);
  86         } else {
  87             if (!p->vlc_state) {
  88                 p->vlc_state = av_calloc(p->context_count, sizeof(*p->vlc_state));
  89                 if (!p->vlc_state)
  90                     return AVERROR(ENOMEM);
  91                 for (i = 0; i < p->context_count; i++) {
  92                     p->vlc_state[i].error_sum = 4;
  93                     p->vlc_state[i].count     = 1;
  94                 }
  95             }
  96         }
  97     }
  98
  99     if (f->ac == AC_RANGE_CUSTOM_TAB) {
 100         //FIXME only redo if state_transition changed
 101         for (j = 1; j < 256; j++) {
 102             sc->c. one_state[      j] = f->state_transition[j];
 103             sc->c.zero_state[256 - j] = 256 - sc->c.one_state[j];
 104         }
 105     }
 106
 107     return 0;
 108 }
 109
 110 av_cold int ff_ffv1_init_slices_state(FFV1Context *f)
 111 {
 112     int i, ret;
 113     for (i = 0; i < f->max_slice_count; i++) {
 114         if ((ret = ff_ffv1_init_slice_state(f, &f->slices[i])) < 0)
 115             return AVERROR(ENOMEM);
 116     }
 117     return 0;
 118 }
 119
 120 int ff_need_new_slices(int width, int num_h_slices, int chroma_shift) {
 121     int mpw = 1<<chroma_shift;
 122     int i = width * (int64_t)(num_h_slices - 1) / num_h_slices;
 123
 124     return width % mpw && (width - i) % mpw == 0;
 125 }
 126
 127 int ff_slice_coord(const FFV1Context *f, int width, int sx, int num_h_slices, int chroma_shift) {
 128     int mpw = 1<<chroma_shift;
 129     int awidth = FFALIGN(width, mpw);
 130
 131     if (f->combined_version <= 0x40002)
 132         return width * sx / num_h_slices;
 133
 134     sx = (2LL * awidth * sx + num_h_slices * mpw) / (2 * num_h_slices * mpw) * mpw;
 135     if (sx == awidth)
 136         sx = width;
 137     return sx;
 138 }
 139
 140 av_cold int ff_ffv1_init_slice_contexts(FFV1Context *f)
 141 {
 142     int max_slice_count = f->num_h_slices * f->num_v_slices;
 143
 144     av_assert0(max_slice_count > 0);
 145
 146     f->slices = av_calloc(max_slice_count, sizeof(*f->slices));
 147     if (!f->slices)
 148         return AVERROR(ENOMEM);
 149
 150     f->max_slice_count = max_slice_count;
 151
 152     for (int i = 0; i < max_slice_count; i++) {
 153         FFV1SliceContext *sc = &f->slices[i];
 154         int sx          = i % f->num_h_slices;
 155         int sy          = i / f->num_h_slices;
 156         int sxs         = ff_slice_coord(f, f->avctx->width , sx    , f->num_h_slices, f->chroma_h_shift);
 157         int sxe         = ff_slice_coord(f, f->avctx->width , sx + 1, f->num_h_slices, f->chroma_h_shift);
 158         int sys         = ff_slice_coord(f, f->avctx->height, sy   ,  f->num_v_slices, f->chroma_v_shift);
 159         int sye         = ff_slice_coord(f, f->avctx->height, sy + 1, f->num_v_slices, f->chroma_v_shift);
 160
 161         sc->slice_width  = sxe - sxs;
 162         sc->slice_height = sye - sys;
 163         sc->slice_x      = sxs;
 164         sc->slice_y      = sys;
 165         sc->sx           = sx;
 166         sc->sy           = sy;
 167
 168         sc->sample_buffer = av_malloc_array((f->width + 6), 3 * MAX_PLANES *
 169                                             sizeof(*sc->sample_buffer));
 170         sc->sample_buffer32 = av_malloc_array((f->width + 6), 3 * MAX_PLANES *
 171                                               sizeof(*sc->sample_buffer32));
 172         if (!sc->sample_buffer || !sc->sample_buffer32)
 173             return AVERROR(ENOMEM);
 174
 175         sc->plane = ff_ffv1_planes_alloc();
 176         if (!sc->plane)
 177             return AVERROR(ENOMEM);
 178     }
 179
 180     return 0;
 181 }
 182
 183 int ff_ffv1_allocate_initial_states(FFV1Context *f)
 184 {
 185     int i;
 186
 187     for (i = 0; i < f->quant_table_count; i++) {
 188         f->initial_states[i] = av_malloc_array(f->context_count[i],
 189                                          sizeof(*f->initial_states[i]));
 190         if (!f->initial_states[i])
 191             return AVERROR(ENOMEM);
 192         memset(f->initial_states[i], 128,
 193                f->context_count[i] * sizeof(*f->initial_states[i]));
 194     }
 195     return 0;
 196 }
 197
 198 void ff_ffv1_clear_slice_state(const FFV1Context *f, FFV1SliceContext *sc)
 199 {
 200     int i, j;
 201
 202     for (i = 0; i < f->plane_count; i++) {
 203         PlaneContext *p = &sc->plane[i];
 204
 205         if (f->ac != AC_GOLOMB_RICE) {
 206             if (f->initial_states[p->quant_table_index]) {
 207                 memcpy(p->state, f->initial_states[p->quant_table_index],
 208                        CONTEXT_SIZE * p->context_count);
 209             } else
 210                 memset(p->state, 128, CONTEXT_SIZE * p->context_count);
 211         } else {
 212             for (j = 0; j < p->context_count; j++) {
 213                 p->vlc_state[j].drift     = 0;
 214                 p->vlc_state[j].error_sum = 4;    //FFMAX((RANGE + 32)/64, 2);
 215                 p->vlc_state[j].bias      = 0;
 216                 p->vlc_state[j].count     = 1;
 217             }
 218         }
 219     }
 220 }
 221
 222 void ff_ffv1_compute_bits_per_plane(const FFV1Context *f, FFV1SliceContext *sc, int bits[4], int *offset, int mask[4], int bits_per_raw_sample)
 223 {
 224     // to simplify we use the remap_count as the symbol range in each plane
 225     if (!sc->remap) {
 226         sc->remap_count[0] =
 227         sc->remap_count[1] =
 228         sc->remap_count[2] =
 229         sc->remap_count[3] = 1 << (bits_per_raw_sample > 0 ? bits_per_raw_sample : 8);
 230     }
 231
 232     if (sc->remap)
 233         av_assert0(bits_per_raw_sample > 8); //breaks with lbd, needs review if added
 234
 235     //bits with no RCT
 236     for (int p=0; p<3+f->transparency; p++) {
 237         bits[p] = av_ceil_log2(sc->remap_count[p]);
 238         if (mask)
 239             mask[p] = (1<<bits[p]) - 1;
 240     }
 241
 242     //RCT
 243     if (sc->slice_coding_mode == 0) {
 244         *offset = sc->remap_count[0];
 245
 246         bits[0] = av_ceil_log2(FFMAX3(sc->remap_count[0], sc->remap_count[1], sc->remap_count[2]));
 247         bits[1] = av_ceil_log2(sc->remap_count[0] + sc->remap_count[1]);
 248         bits[2] = av_ceil_log2(sc->remap_count[0] + sc->remap_count[2]);
 249
 250         //old version coded a bit more than needed
 251         if (f->combined_version < 0x40008) {
 252             bits[0]++;
 253             if(f->transparency)
 254                 bits[3]++;
 255         }
 256     }
 257 }
 258
 259 int ff_ffv1_get_symbol(RangeCoder *c, uint8_t *state, int is_signed)
 260 {
 261     return get_symbol_inline(c, state, is_signed);
 262 }
 263
 264 av_cold void ff_ffv1_close(FFV1Context *s)
 265 {
 266     int i, j;
 267
 268     for (j = 0; j < s->max_slice_count; j++) {
 269         FFV1SliceContext *sc = &s->slices[j];
 270
 271         av_freep(&sc->sample_buffer);
 272         av_freep(&sc->sample_buffer32);
 273         for(int p = 0; p < 4 ; p++) {
 274             av_freep(&sc->fltmap[p]);
 275             av_freep(&sc->fltmap32[p]);
 276             sc->fltmap_size  [p] = 0;
 277             sc->fltmap32_size[p] = 0;
 278         }
 279
 280         av_refstruct_unref(&sc->plane);
 281     }
 282
 283     av_refstruct_unref(&s->slice_damaged);
 284
 285     for (j = 0; j < s->quant_table_count; j++) {
 286         av_freep(&s->initial_states[j]);
 287         for (i = 0; i < s->max_slice_count; i++) {
 288             FFV1SliceContext *sc = &s->slices[i];
 289             av_freep(&sc->rc_stat2[j]);
 290         }
 291         av_freep(&s->rc_stat2[j]);
 292     }
 293
 294     av_freep(&s->slices);
 295 }