LCOV - code coverage report
Current view: top level - libavcodec - ffv1enc_template.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 91 110 82.7 %
Date: 2017-12-11 04:34:20 Functions: 4 4 100.0 %

          Line data    Source code
       1             : /*
       2             :  * FFV1 encoder template
       3             :  *
       4             :  * Copyright (c) 2003-2016 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     1527000 : static av_always_inline int RENAME(encode_line)(FFV1Context *s, int w,
      24             :                                                 TYPE *sample[3],
      25             :                                                 int plane_index, int bits)
      26             : {
      27     1527000 :     PlaneContext *const p = &s->plane[plane_index];
      28     1527000 :     RangeCoder *const c   = &s->c;
      29             :     int x;
      30     1527000 :     int run_index = s->run_index;
      31     1527000 :     int run_count = 0;
      32     1527000 :     int run_mode  = 0;
      33             : 
      34     1527000 :     if (s->ac != AC_GOLOMB_RICE) {
      35      808200 :         if (c->bytestream_end - c->bytestream < w * 35) {
      36           0 :             av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
      37           0 :             return AVERROR_INVALIDDATA;
      38             :         }
      39             :     } else {
      40      718800 :         if (s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb) >> 3) < w * 4) {
      41           0 :             av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
      42           0 :             return AVERROR_INVALIDDATA;
      43             :         }
      44             :     }
      45             : 
      46     1527000 :     if (s->slice_coding_mode == 1) {
      47           0 :         for (x = 0; x < w; x++) {
      48             :             int i;
      49           0 :             int v = sample[0][x];
      50           0 :             for (i = bits-1; i>=0; i--) {
      51           0 :                 uint8_t state = 128;
      52           0 :                 put_rac(c, &state, (v>>i) & 1);
      53             :             }
      54             :         }
      55           0 :         return 0;
      56             :     }
      57             : 
      58   238132500 :     for (x = 0; x < w; x++) {
      59             :         int diff, context;
      60             : 
      61   236605500 :         context = RENAME(get_context)(p, sample[0] + x, sample[1] + x, sample[2] + x);
      62   236605500 :         diff    = sample[0][x] - RENAME(predict)(sample[0] + x, sample[1] + x);
      63             : 
      64   236605500 :         if (context < 0) {
      65    96644538 :             context = -context;
      66    96644538 :             diff    = -diff;
      67             :         }
      68             : 
      69   236605500 :         diff = fold(diff, bits);
      70             : 
      71   236605500 :         if (s->ac != AC_GOLOMB_RICE) {
      72   122117000 :             if (s->flags & AV_CODEC_FLAG_PASS1) {
      73           0 :                 put_symbol_inline(c, p->state[context], diff, 1, s->rc_stat,
      74           0 :                                   s->rc_stat2[p->quant_table_index][context]);
      75             :             } else {
      76   122117000 :                 put_symbol_inline(c, p->state[context], diff, 1, NULL, NULL);
      77             :             }
      78             :         } else {
      79   114488500 :             if (context == 0)
      80     2991173 :                 run_mode = 1;
      81             : 
      82   114488500 :             if (run_mode) {
      83     4823030 :                 if (diff) {
      84     3838553 :                     while (run_count >= 1 << ff_log2_run[run_index]) {
      85     1194121 :                         run_count -= 1 << ff_log2_run[run_index];
      86     1194121 :                         run_index++;
      87     1194121 :                         put_bits(&s->pb, 1, 1);
      88             :                     }
      89             : 
      90     1322216 :                     put_bits(&s->pb, 1 + ff_log2_run[run_index], run_count);
      91     1322216 :                     if (run_index)
      92     1221317 :                         run_index--;
      93     1322216 :                     run_count = 0;
      94     1322216 :                     run_mode  = 0;
      95     1322216 :                     if (diff > 0)
      96      617300 :                         diff--;
      97             :                 } else {
      98     3500814 :                     run_count++;
      99             :                 }
     100             :             }
     101             : 
     102             :             ff_dlog(s->avctx, "count:%d index:%d, mode:%d, x:%d pos:%d\n",
     103             :                     run_count, run_index, run_mode, x,
     104             :                     (int)put_bits_count(&s->pb));
     105             : 
     106   114488500 :             if (run_mode == 0)
     107   110987686 :                 put_vlc_symbol(&s->pb, &p->vlc_state[context], diff, bits);
     108             :         }
     109             :     }
     110     1527000 :     if (run_mode) {
     111      141755 :         while (run_count >= 1 << ff_log2_run[run_index]) {
     112       37845 :             run_count -= 1 << ff_log2_run[run_index];
     113       37845 :             run_index++;
     114       37845 :             put_bits(&s->pb, 1, 1);
     115             :         }
     116             : 
     117       51955 :         if (run_count)
     118       34260 :             put_bits(&s->pb, 1, 1);
     119             :     }
     120     1527000 :     s->run_index = run_index;
     121             : 
     122     1527000 :     return 0;
     123             : }
     124             : 
     125        1600 : static int RENAME(encode_rgb_frame)(FFV1Context *s, const uint8_t *src[3],
     126             :                                     int w, int h, const int stride[3])
     127             : {
     128             :     int x, y, p, i;
     129        1600 :     const int ring_size = s->context_model ? 3 : 2;
     130             :     TYPE *sample[4][3];
     131        1600 :     int lbd    = s->bits_per_raw_sample <= 8;
     132        1600 :     int packed = !src[1];
     133        1600 :     int bits   = s->bits_per_raw_sample > 0 ? s->bits_per_raw_sample : 8;
     134        1600 :     int offset = 1 << bits;
     135             : 
     136        1600 :     s->run_index = 0;
     137             : 
     138        3200 :     memset(RENAME(s->sample_buffer), 0, ring_size * MAX_PLANES *
     139        1600 :            (w + 6) * sizeof(*RENAME(s->sample_buffer)));
     140             : 
     141      181200 :     for (y = 0; y < h; y++) {
     142      538800 :         for (i = 0; i < ring_size; i++)
     143     1796000 :             for (p = 0; p < MAX_PLANES; p++)
     144     1436800 :                 sample[p][i]= RENAME(s->sample_buffer) + p*ring_size*(w+6) + ((h+i-y)%ring_size)*(w+6) + 3;
     145             : 
     146    30708000 :         for (x = 0; x < w; x++) {
     147    30528400 :             int b, g, r, av_uninit(a);
     148    30528400 :             if (lbd) {
     149    15264200 :                 unsigned v = *((const uint32_t*)(src[0] + x*4 + stride[0]*y));
     150    15264200 :                 b =  v        & 0xFF;
     151    15264200 :                 g = (v >>  8) & 0xFF;
     152    15264200 :                 r = (v >> 16) & 0xFF;
     153    15264200 :                 a =  v >> 24;
     154    15264200 :             } else if (packed) {
     155    15264200 :                 const uint16_t *p = ((const uint16_t*)(src[0] + x*6 + stride[0]*y));
     156    15264200 :                 r = p[0];
     157    15264200 :                 g = p[1];
     158    15264200 :                 b = p[2];
     159             :             } else if (sizeof(TYPE) == 4) {
     160           0 :                 g = *((const uint16_t *)(src[0] + x*2 + stride[0]*y));
     161           0 :                 b = *((const uint16_t *)(src[1] + x*2 + stride[1]*y));
     162           0 :                 r = *((const uint16_t *)(src[2] + x*2 + stride[2]*y));
     163             :             } else {
     164           0 :                 b = *((const uint16_t *)(src[0] + x*2 + stride[0]*y));
     165           0 :                 g = *((const uint16_t *)(src[1] + x*2 + stride[1]*y));
     166           0 :                 r = *((const uint16_t *)(src[2] + x*2 + stride[2]*y));
     167             :             }
     168             : 
     169    30528400 :             if (s->slice_coding_mode != 1) {
     170    30528400 :                 b -= g;
     171    30528400 :                 r -= g;
     172    30528400 :                 g += (b * s->slice_rct_by_coef + r * s->slice_rct_ry_coef) >> 2;
     173    30528400 :                 b += offset;
     174    30528400 :                 r += offset;
     175             :             }
     176             : 
     177    30528400 :             sample[0][0][x] = g;
     178    30528400 :             sample[1][0][x] = b;
     179    30528400 :             sample[2][0][x] = r;
     180    30528400 :             sample[3][0][x] = a;
     181             :         }
     182      718400 :         for (p = 0; p < 3 + s->transparency; p++) {
     183             :             int ret;
     184      538800 :             sample[p][0][-1] = sample[p][1][0  ];
     185      538800 :             sample[p][1][ w] = sample[p][1][w-1];
     186      538800 :             if (lbd && s->slice_coding_mode == 0)
     187      269400 :                 ret = RENAME(encode_line)(s, w, sample[p], (p + 1) / 2, 9);
     188             :             else
     189      269400 :                 ret = RENAME(encode_line)(s, w, sample[p], (p + 1) / 2, bits + (s->slice_coding_mode != 1));
     190      538800 :             if (ret < 0)
     191           0 :                 return ret;
     192             :         }
     193             :     }
     194        1600 :     return 0;
     195             : }
     196             : 

Generated by: LCOV version 1.13