LCOV - code coverage report
Current view: top level - libavcodec - ffv1.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 109 127 85.8 %
Date: 2017-12-12 11:08:38 Functions: 7 7 100.0 %

          Line data    Source code
       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/crc.h"
      31             : #include "libavutil/opt.h"
      32             : #include "libavutil/imgutils.h"
      33             : #include "libavutil/pixdesc.h"
      34             : #include "libavutil/timer.h"
      35             : 
      36             : #include "avcodec.h"
      37             : #include "internal.h"
      38             : #include "rangecoder.h"
      39             : #include "mathops.h"
      40             : #include "ffv1.h"
      41             : 
      42          85 : av_cold int ff_ffv1_common_init(AVCodecContext *avctx)
      43             : {
      44          85 :     FFV1Context *s = avctx->priv_data;
      45             : 
      46          85 :     if (!avctx->width || !avctx->height)
      47           0 :         return AVERROR_INVALIDDATA;
      48             : 
      49          85 :     s->avctx = avctx;
      50          85 :     s->flags = avctx->flags;
      51             : 
      52          85 :     s->picture.f = av_frame_alloc();
      53          85 :     s->last_picture.f = av_frame_alloc();
      54          85 :     if (!s->picture.f || !s->last_picture.f)
      55           0 :         return AVERROR(ENOMEM);
      56             : 
      57          85 :     s->width  = avctx->width;
      58          85 :     s->height = avctx->height;
      59             : 
      60             :     // defaults
      61          85 :     s->num_h_slices = 1;
      62          85 :     s->num_v_slices = 1;
      63             : 
      64          85 :     return 0;
      65             : }
      66             : 
      67       10104 : av_cold int ff_ffv1_init_slice_state(FFV1Context *f, FFV1Context *fs)
      68             : {
      69             :     int j, i;
      70             : 
      71       10104 :     fs->plane_count  = f->plane_count;
      72       10104 :     fs->transparency = f->transparency;
      73       30312 :     for (j = 0; j < f->plane_count; j++) {
      74       20208 :         PlaneContext *const p = &fs->plane[j];
      75             : 
      76       20208 :         if (fs->ac != AC_GOLOMB_RICE) {
      77        9888 :             if (!p->state)
      78         480 :                 p->state = av_malloc_array(p->context_count, CONTEXT_SIZE *
      79             :                                      sizeof(uint8_t));
      80        9888 :             if (!p->state)
      81           0 :                 return AVERROR(ENOMEM);
      82             :         } else {
      83       10320 :             if (!p->vlc_state) {
      84         520 :                 p->vlc_state = av_mallocz_array(p->context_count, sizeof(VlcState));
      85         520 :                 if (!p->vlc_state)
      86           0 :                     return AVERROR(ENOMEM);
      87      213640 :                 for (i = 0; i < p->context_count; i++) {
      88      213120 :                     p->vlc_state[i].error_sum = 4;
      89      213120 :                     p->vlc_state[i].count     = 1;
      90             :                 }
      91             :             }
      92             :         }
      93             :     }
      94             : 
      95       10104 :     if (fs->ac == AC_RANGE_CUSTOM_TAB) {
      96             :         //FIXME only redo if state_transition changed
      97     1265664 :         for (j = 1; j < 256; j++) {
      98     1260720 :             fs->c. one_state[      j] = f->state_transition[j];
      99     1260720 :             fs->c.zero_state[256 - j] = 256 - fs->c.one_state[j];
     100             :         }
     101             :     }
     102             : 
     103       10104 :     return 0;
     104             : }
     105             : 
     106          28 : av_cold int ff_ffv1_init_slices_state(FFV1Context *f)
     107             : {
     108             :     int i, ret;
     109         128 :     for (i = 0; i < f->max_slice_count; i++) {
     110         100 :         FFV1Context *fs = f->slice_context[i];
     111         100 :         if ((ret = ff_ffv1_init_slice_state(f, fs)) < 0)
     112           0 :             return AVERROR(ENOMEM);
     113             :     }
     114          28 :     return 0;
     115             : }
     116             : 
     117          85 : av_cold int ff_ffv1_init_slice_contexts(FFV1Context *f)
     118             : {
     119             :     int i;
     120             : 
     121          85 :     f->max_slice_count = f->num_h_slices * f->num_v_slices;
     122          85 :     av_assert0(f->max_slice_count > 0);
     123             : 
     124         389 :     for (i = 0; i < f->max_slice_count; i++) {
     125         304 :         int sx          = i % f->num_h_slices;
     126         304 :         int sy          = i / f->num_h_slices;
     127         304 :         int sxs         = f->avctx->width  *  sx      / f->num_h_slices;
     128         304 :         int sxe         = f->avctx->width  * (sx + 1) / f->num_h_slices;
     129         304 :         int sys         = f->avctx->height *  sy      / f->num_v_slices;
     130         304 :         int sye         = f->avctx->height * (sy + 1) / f->num_v_slices;
     131         304 :         FFV1Context *fs = av_mallocz(sizeof(*fs));
     132             : 
     133         304 :         if (!fs)
     134           0 :             goto memfail;
     135             : 
     136         304 :         f->slice_context[i] = fs;
     137         304 :         memcpy(fs, f, sizeof(*fs));
     138         304 :         memset(fs->rc_stat2, 0, sizeof(fs->rc_stat2));
     139             : 
     140         304 :         fs->slice_width  = sxe - sxs;
     141         304 :         fs->slice_height = sye - sys;
     142         304 :         fs->slice_x      = sxs;
     143         304 :         fs->slice_y      = sys;
     144             : 
     145         304 :         fs->sample_buffer = av_malloc_array((fs->width + 6), 3 * MAX_PLANES *
     146             :                                       sizeof(*fs->sample_buffer));
     147         304 :         fs->sample_buffer32 = av_malloc_array((fs->width + 6), 3 * MAX_PLANES *
     148             :                                         sizeof(*fs->sample_buffer32));
     149         304 :         if (!fs->sample_buffer || !fs->sample_buffer32) {
     150           0 :             av_freep(&fs->sample_buffer);
     151           0 :             av_freep(&fs->sample_buffer32);
     152           0 :             av_freep(&f->slice_context[i]);
     153           0 :             goto memfail;
     154             :         }
     155             :     }
     156          85 :     return 0;
     157             : 
     158           0 : memfail:
     159           0 :     while(--i >= 0) {
     160           0 :         av_freep(&f->slice_context[i]->sample_buffer);
     161           0 :         av_freep(&f->slice_context[i]->sample_buffer32);
     162           0 :         av_freep(&f->slice_context[i]);
     163             :     }
     164           0 :     return AVERROR(ENOMEM);
     165             : }
     166             : 
     167          77 : int ff_ffv1_allocate_initial_states(FFV1Context *f)
     168             : {
     169             :     int i;
     170             : 
     171         231 :     for (i = 0; i < f->quant_table_count; i++) {
     172         154 :         f->initial_states[i] = av_malloc_array(f->context_count[i],
     173             :                                          sizeof(*f->initial_states[i]));
     174         154 :         if (!f->initial_states[i])
     175           0 :             return AVERROR(ENOMEM);
     176         154 :         memset(f->initial_states[i], 128,
     177         154 :                f->context_count[i] * sizeof(*f->initial_states[i]));
     178             :     }
     179          77 :     return 0;
     180             : }
     181             : 
     182        1104 : void ff_ffv1_clear_slice_state(FFV1Context *f, FFV1Context *fs)
     183             : {
     184             :     int i, j;
     185             : 
     186        3312 :     for (i = 0; i < f->plane_count; i++) {
     187        2208 :         PlaneContext *p = &fs->plane[i];
     188             : 
     189        2208 :         p->interlace_bit_state[0] = 128;
     190        2208 :         p->interlace_bit_state[1] = 128;
     191             : 
     192        2208 :         if (fs->ac != AC_GOLOMB_RICE) {
     193        1056 :             if (f->initial_states[p->quant_table_index]) {
     194        1056 :                 memcpy(p->state, f->initial_states[p->quant_table_index],
     195        1056 :                        CONTEXT_SIZE * p->context_count);
     196             :             } else
     197           0 :                 memset(p->state, 128, CONTEXT_SIZE * p->context_count);
     198             :         } else {
     199      768384 :             for (j = 0; j < p->context_count; j++) {
     200      767232 :                 p->vlc_state[j].drift     = 0;
     201      767232 :                 p->vlc_state[j].error_sum = 4;    //FFMAX((RANGE + 32)/64, 2);
     202      767232 :                 p->vlc_state[j].bias      = 0;
     203      767232 :                 p->vlc_state[j].count     = 1;
     204             :             }
     205             :         }
     206             :     }
     207        1104 : }
     208             : 
     209             : 
     210          85 : av_cold int ff_ffv1_close(AVCodecContext *avctx)
     211             : {
     212          85 :     FFV1Context *s = avctx->priv_data;
     213             :     int i, j;
     214             : 
     215          85 :     if (s->picture.f)
     216          85 :         ff_thread_release_buffer(avctx, &s->picture);
     217          85 :     av_frame_free(&s->picture.f);
     218             : 
     219          85 :     if (s->last_picture.f)
     220          85 :         ff_thread_release_buffer(avctx, &s->last_picture);
     221          85 :     av_frame_free(&s->last_picture.f);
     222             : 
     223         389 :     for (j = 0; j < s->max_slice_count; j++) {
     224         304 :         FFV1Context *fs = s->slice_context[j];
     225         912 :         for (i = 0; i < s->plane_count; i++) {
     226         608 :             PlaneContext *p = &fs->plane[i];
     227             : 
     228         608 :             av_freep(&p->state);
     229         608 :             av_freep(&p->vlc_state);
     230             :         }
     231         304 :         av_freep(&fs->sample_buffer);
     232         304 :         av_freep(&fs->sample_buffer32);
     233             :     }
     234             : 
     235          85 :     av_freep(&avctx->stats_out);
     236         239 :     for (j = 0; j < s->quant_table_count; j++) {
     237         154 :         av_freep(&s->initial_states[j]);
     238         746 :         for (i = 0; i < s->max_slice_count; i++) {
     239         592 :             FFV1Context *sf = s->slice_context[i];
     240         592 :             av_freep(&sf->rc_stat2[j]);
     241             :         }
     242         154 :         av_freep(&s->rc_stat2[j]);
     243             :     }
     244             : 
     245         389 :     for (i = 0; i < s->max_slice_count; i++)
     246         304 :         av_freep(&s->slice_context[i]);
     247             : 
     248          85 :     return 0;
     249             : }

Generated by: LCOV version 1.13